Create a new Time typed path

@param <A>
@param path existing path
@return property path
431208
@SuppressWarnings("unchecked")
    public <A extends Comparable<?>> TimePath<A> get(TimePath<A> path) {
        TimePath<A> newPath = getTime(toString(path), (Class<A>) path.getType());
        return addMetadataOf(newPath, path);
    }
997036
public static <T extends Comparable<?>> DatePath<T> datePath(Class<? extends T> type, Path<?> parent,
            String property) {
        return new DatePath<T>(type, PathMetadataFactory.forProperty(parent, property));
    }
562832
public UriBuilder path(String path) throws URISyntaxException {
        path = path.trim();
        if (getPath().endsWith("/")) {
            return new UriBuilder(setPath(String.format("%s%s", getPath(), path)));
        } else {
            return new UriBuilder(setPath(String.format("%s/%s", getPath(), path)));
        }
    }
1021602
public static String path( String path ) {
		String pathToBase = getPathToBase();
		if( pathToBase == null )
			return path;
		return new File(pathToBase,path).getAbsolutePath();
	}
175911
public static <T> Path<T> path(Class<? extends T> type, PathMetadata metadata) {
        return new PathImpl<T>(type, metadata);
    }
1227928
public static Path withoutLeadingSeparator(Path path) {
    return new Path(StringUtils.removeStart(path.toString(), Path.SEPARATOR));
  }
1256551
public static Typeface createFromFile(@Nullable String path) {
        Typeface typeface = TYPEFACES.get(path);
        if (typeface != null) {
            return typeface;
        } else {
            typeface = Typeface.createFromFile(path);
            TYPEFACES.put(path, typeface);
            return typeface;
        }
    }
1338753
private synchronized ActivePath getActivePath(final String path) {
        ActivePath activePath = activePaths.get(path);
        if (activePath == null) {
            activePath = new ActivePath(path);
            activePaths.put(path, activePath);
        }
        return activePath;
    }
984113
@SuppressWarnings("unchecked")
    public <A extends Comparable<?>> DateTimePath<A> getDateTime(String property, Class<A> type) {
        Class<? extends A> vtype = validate(property, type);
        return super.createDateTime(property, (Class<? super A>) vtype);
    }
712653
public static <E, F> PropertySelector<E, F> newPropertySelector(String path, Class<E> from) {
        return new PropertySelector<E, F>(path, from);
    }
333930
public static RouteImpl create(final String path, final Route route) {
        return create(path, DEFAULT_ACCEPT_TYPE, route);
    }
1230100
@SuppressWarnings("unchecked")
    public <A extends Comparable<?>> DatePath<A> get(DatePath<A> path) {
        DatePath<A> newPath = getDate(toString(path), (Class<A>) path.getType());
        return addMetadataOf(newPath, path);
    }
1335078
public static <A, E> ArrayPath<A, E> arrayPath(Class<A> arrayType, PathMetadata metadata) {
        return new ArrayPath<A, E>(arrayType, metadata);
    }
1233774
public static <T> Path<T> path(Class<? extends T> type, Path<?> parent, String property) {
        return new PathImpl<T>(type, parent, property);
    }
794361
@SuppressWarnings("unchecked")
    @Nullable
    public <T> T executeWithKey(Path<T> path) {
        return executeWithKey((Class<T>) path.getType(), path);
    }
284029
public static <T extends Comparable<?>> DateTimePath<T> dateTimePath(Class<? extends T> type, PathMetadata metadata) {
        return new DateTimePath<T>(type, metadata);
    }
917279
@SuppressWarnings("unchecked")
    public <A> PathBuilder<A> get(String property, Class<A> type) {
        SimpleEntry<String, Class<?>> entry = new SimpleEntry<String, Class<?>>(property, type);
        PathBuilder<A> path = (PathBuilder<A>) properties.get(entry);
        PathBuilder<?> existingPath = null;
        if (path == null) {
            Class<? extends A> vtype = validate(property, type);
            path = new PathBuilder<A>(vtype, forProperty(property), validator);
            existingPath = properties.putIfAbsent(entry, path);
        }
        return existingPath == null ? path : (PathBuilder<A>) existingPath;
    }