Create a new Path expression

@param type type of expression
@param parent parent path
@param property property name
@return path expression
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));
    }
374785
public static PathMetadata forArrayAccess(Path<?> parent, Expression<Integer> index) {
        return new PathMetadata(parent, index, PathType.ARRAYVALUE);
    }
726242
public static <E, Q extends SimpleExpression<? super E>> CollectionPath<E, Q> collectionPath(Class<E> type, Class<Q> queryType, PathMetadata metadata) {
        return new CollectionPath<E, Q>(type, queryType, metadata);
    }
292025
public static PathMetadata forListAccess(Path<?> parent, @Nonnegative int index) {
        return new PathMetadata(parent, index, PathType.LISTVALUE_CONSTANT);
    }
682558
public static <KT> PathMetadata forMapAccess(Path<?> parent, Expression<KT> key) {
        return new PathMetadata(parent, key, PathType.MAPVALUE);
    }
249469
@SuppressWarnings("unchecked")
    public static <X, Y> PropertyPathExpression<X, Y> getExpression(
            Class<X> source, String propertyPath, Class<Y> valueClass) {
        final PropertyPathExpressionKey key = new PropertyPathExpressionKey(
                source, propertyPath);
        PropertyPathExpression<Object, Object> expression = cache.get(key);

        if (expression == null) {
            expression = new PropertyPathExpression<Object, Object>(
                    (Class<Object>) source, propertyPath);
            final PropertyPathExpression<Object, Object> oldExpression = cache
                    .putIfAbsent(key, expression);

            if (oldExpression != null) {
                expression = oldExpression;
            }
        }

        return (PropertyPathExpression<X, Y>) expression;
    }
281866
@SuppressWarnings("unchecked")
    protected <A> SimplePath<A> createSimple(String property, Class<? super A> type) {
        return add(new SimplePath<A>((Class<A>) type, forProperty(property)));
    }
135388
public static BooleanPath booleanPath(Path<?> parent, String property) {
        return new BooleanPath(PathMetadataFactory.forProperty(parent, property));
    }
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);
    }
1181847
public static <T extends Comparable<?>> ComparableEntityPath<T> comparableEntityPath(Class<? extends T> type,
                                                                             Path<?> parent, String property) {
        return new ComparableEntityPath<T>(type, PathMetadataFactory.forProperty(parent, property));
    }
916631
@SuppressWarnings("unchecked")
    protected <A extends Comparable> TimePath<A> createTime(String property, Class<? super A> type) {
        return add(new TimePath<A>((Class) type, forProperty(property)));
    }
175170
public static <T extends Enum<T>> EnumPath<T> enumPath(Class<? extends T> type, Path<?> parent, String property) {
        return new EnumPath<T>(type, PathMetadataFactory.forProperty(parent, property));
    }
1190781
@SuppressWarnings("unchecked")
    protected <A extends Comparable> DateTimePath<A> createDateTime(String property, Class<? super A> type) {
        return add(new DateTimePath<A>((Class) type, forProperty(property)));
    }
249679
@SuppressWarnings("unchecked")
    protected <K, V, E extends SimpleExpression<? super V>> MapPath<K, V, E> createMap(String property, Class<? super K> key, Class<? super V> value, Class<? super E> queryType) {
        return add(new MapPath<K, V, E>(key, value, (Class) queryType, forProperty(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));
    }
643378
public void addToPath(String path, String property) {
        Props props = pathMap.computeIfAbsent(path, k -> new Props(this, null, path));
        props.getProperties().add(property);
    }
829800
@SuppressWarnings("unchecked")
    public <A extends Comparable<?>> DatePath<A> getDate(String property, Class<A> type) {
        Class<? extends A> vtype = validate(property, type);
        return super.createDate(property, (Class<? super A>) vtype);
    }