Create a new Time typed path

@param <A>
@param property property name
@param type property type
@return property path
176923
@SuppressWarnings("unchecked")
    public <A extends Comparable<?>> TimePath<A> getTime(String property, Class<A> type) {
        Class<? extends A> vtype = validate(property, type);
        return super.createTime(property, (Class<? super A>) vtype);
    }
1334467
public static <T extends Comparable<?>> TimePath<T> timePath(Class<? extends T> type, PathMetadata metadata) {
        return new TimePath<T>(type, metadata);
    }
258475
public static <T> DslPath<T> dslPath(Class<? extends T> type, Path<?> parent, String property) {
        return new DslPath<T>(type, PathMetadataFactory.forProperty(parent, property));
    }
1201971
public static <T extends Comparable<?>> TimePath<T> timePath(Class<? extends T> type, Path<?> parent,
            String property) {
        return new TimePath<T>(type, PathMetadataFactory.forProperty(parent, property));
    }
209649
@NonNull
	public <T> T asObject(String subPath, Class<T> type)
	{
		return config.asObject(key + '.' + subPath, type);
	}
643378
public void addToPath(String path, String property) {
        Props props = pathMap.computeIfAbsent(path, k -> new Props(this, null, path));
        props.getProperties().add(property);
    }
169091
public ObjectAndType initProperty(final Object target, Type type, final String attr) {
    Object propObj = target;
    Object property = null;

    int index = 0;
    String[] attrs = Strings.split(attr, ".");
    while (index < attrs.length) {
      try {
        property = getProperty(propObj, attrs[index]);
        Type propertyType = null;
        if (attrs[index].contains("[") && null != property) {
          propertyType = new IdentifierType(property.getClass());
        } else {
          propertyType = type.getPropertyType(attrs[index]);
          if (null == propertyType) {
            logger.error("Cannot find property type [{}] of {}", attrs[index], propObj.getClass());
            throw new RuntimeException(
                "Cannot find property type " + attrs[index] + " of " + propObj.getClass().getName());
          }
        }
        if (null == property) {
          property = propertyType.newInstance();
          setProperty(propObj, attrs[index], property);
        }
        index++;
        propObj = property;
        type = propertyType;
      } catch (Exception e) {
        throw new RuntimeException(e);
      }
    }
    return new ObjectAndType(property, type);
  }
266357
public static StringPath stringPath(Path<?> parent, String property) {
        return new StringPath(PathMetadataFactory.forProperty(parent, property));
    }
435579
public static <T extends Number & Comparable<?>> NumberPath<T> numberPath(Class<? extends T> type,
            Path<?> parent, String property) {
        return new NumberPath<T>(type, PathMetadataFactory.forProperty(parent, property));
    }
897649
@SuppressWarnings("unchecked")
    public PathBuilder<Object> get(String property) {
        SimpleEntry<String, Class<?>> entry = new SimpleEntry<String, Class<?>>(property, Object.class);
        PathBuilder<Object> path = (PathBuilder<Object>) properties.get(entry);
        PathBuilder<?> existingPath = null;
        if (path == null) {
            Class<?> vtype = validate(property, Object.class);
            path = new PathBuilder<Object>(vtype, forProperty(property), validator);
            existingPath = properties.putIfAbsent(entry, path);
        }
        return existingPath == null ? path : (PathBuilder<Object>) existingPath;
    }
175911
public static <T> Path<T> path(Class<? extends T> type, PathMetadata metadata) {
        return new PathImpl<T>(type, metadata);
    }
712653
public static <E, F> PropertySelector<E, F> newPropertySelector(String path, Class<E> from) {
        return new PropertySelector<E, F>(path, from);
    }
882893
@SuppressWarnings("unchecked")
    protected <A extends Comparable> ComparablePath<A> createComparable(String property, Class<? super A> type) {
        return add(new ComparablePath<A>((Class) type, forProperty(property)));
    }
985250
public <K, V, E extends SimpleExpression<V>> MapPath<K, V, E> getMap(String property, Class<K> key, Class<V> value, Class<? super E> queryType) {
        validate(property, Map.class);
        return super.createMap(property, key, value, queryType);
    }
647208
public static String buildTypeSourcePath(final String sourcePath, final String type) {
        val newName = type.replace(".", File.separator);
        return sourcePath + "/src/main/java/" + newName + ".java";
    }
1096772
public <A, E extends SimpleExpression<A>> CollectionPath<A, E> getCollection(String property, Class<A> type, Class<? super E> queryType) {
        validate(property, Collection.class);
        return super.createCollection(property, type, queryType, PathInits.DIRECT);
    }
918934
public static <T> SimplePath<T> path(Class<? extends T> type, Path<?> parent, String property) {
        return simplePath(type, parent, property);
    }