}
    }

    private static Long toLong(final String s) {
        if (StringUtil.isEmpty(s)) {
            return null;
        }
        return Long.valueOf(DecimalFormatUtil.normalize(s));
    }

    /**
     * 変換された{@literal long}に変換します。
     *
     * @param o
     *            変換元のオブジェクト
     * @return 変換された{@literal long}
     */

     * @throws Exception
     */
    public void testNormalize() throws Exception {
        assertEquals("1", "1000.00", DecimalFormatUtil.normalize("1,000.00", Locale.JAPAN));
        assertEquals("2", "1000", DecimalFormatUtil.normalize("1,000", Locale.JAPAN));
        assertEquals("3", "1000.00", DecimalFormatUtil.normalize("1.000,00", Locale.GERMAN));
    }

            path = path.replace('\\', File.separatorChar).replace('/', File.separatorChar);

            File file = new File(path);
            if (file.isAbsolute()) {
                // path was already absolute, just normalize file separator and we're done
                result = file.getPath();
            } else if (file.getPath().startsWith(File.separator)) {

        }
    }

    private static Byte toByte(final String s) {
        if (StringUtil.isEmpty(s)) {
            return null;
        }
        return Byte.valueOf(DecimalFormatUtil.normalize(s));
    }

    /**
     * {@literal byte}に変換します。
     *
     * @param o
     *            変換元のオブジェクト
     * @return 変換された{@literal byte}
     */
    public static byte toPrimitiveByte(final Object o) {

        }
    }

    private static Integer toInteger(final String s) {
        if (StringUtil.isEmpty(s)) {
            return null;
        }
        return Integer.valueOf(DecimalFormatUtil.normalize(s));
    }

    /**
     * {@literal int}に変換します。
     *
     * @param o
     *            変換元のオブジェクト
     * @return 変換された{@literal int}
     */
    public static int toPrimitiveInt(final Object o) {

        if (Files.isDirectory(pomPath)) {
            pomPath = context.locate(pomPath);
        }

        if (pomPath == null || !Files.isRegularFile(pomPath)) {
            return Optional.empty();
        }

        Optional<RelativeProject> mappedProject = Optional.ofNullable(context.getRawModel(pomFile, pomPath.normalize()))

        }
    }

    private static Double toDouble(final String s) {
        if (StringUtil.isEmpty(s)) {
            return null;
        }
        return new Double(DecimalFormatUtil.normalize(s));
    }

    /**
     * {@literal double}に変換します。
     *
     * @param o
     *            変換元のオブジェクト
     * @return 変換された{@literal double}
     */

        }
    }

    private static Float toFloat(final String s) {
        if (StringUtil.isEmpty(s)) {
            return null;
        }
        return new Float(DecimalFormatUtil.normalize(s));
    }

    /**
     * {@literal float}に変換します。
     *
     * @param o
     *            変換元のオブジェクト
     * @return 変換された{@literal float}
     */

        }
    }

    private static Short toShort(final String s) {
        if (StringUtil.isEmpty(s)) {
            return null;
        }
        return Short.valueOf(DecimalFormatUtil.normalize(s));
    }

    /**
     * {@literal short}に変換します。
     *
     * @param o
     *            変換元のオブジェクト
     * @return 変換された{@literal short}
     */

        Path path = getPath().getParent().resolve(norm);
        Path relatedPom = locator.locateExistingPom(path);
        if (relatedPom != null) {
            return new PathSource(relatedPom.normalize(), null);
        }
        return null;
    }

    @Override
    public boolean equals(Object o) {
        return this == o || o instanceof PathSource ps && Objects.equals(path, ps.path);
    }