Create a new Simple path

@param <A>
@param property property name
@param type property type
@return property path
325663
@SuppressWarnings("unchecked")
    public <A> SimplePath<A> getSimple(String property, Class<A> type) {
        Class<? extends A> vtype = validate(property, type);
        return super.createSimple(property, (Class<? super A>) vtype);
    }
118051
public <A> A createAliasForProperty(Class<A> cl, Expression<?> path) {
        return createProxy(cl, path);
    }
645622
public static Converter<String, Object> createPathParamConverter(final Type resultType) {
    if (!(resultType instanceof Class)) {
      throw new IllegalArgumentException("Unsupported @PathParam type " + resultType);
    }
    return new Converter<String, Object>() {
      @Override
      public Object convert(String value) {
        return ConvertUtils.convert(value, (Class<?>) resultType);
      }
    };
  }
1155017
public ConfigurationMetadata visitProperties(T type,
                                                 @Nullable String description) {

        String path = buildTypePath(type, type);
        ConfigurationMetadata configurationMetadata = new ConfigurationMetadata();
        configurationMetadata.name = NameUtils.hyphenate(path, true);
        configurationMetadata.type = getTypeString(type);
        configurationMetadata.description = description;
        this.configurations.add(configurationMetadata);
        return configurationMetadata;
    }
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);
    }
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;
    }
86080
public static void addNewMapping(final Class<?> type, final String property, final String mapping) {
        allowedColmns.computeIfAbsent(type, k -> new HashMap<>());
        allowedColmns.get(type).put(property, mapping);
    }
643378
public void addToPath(String path, String property) {
        Props props = pathMap.computeIfAbsent(path, k -> new Props(this, null, path));
        props.getProperties().add(property);
    }
790669
public <A, E extends SimpleExpression<A>> SetPath<A, E> getSet(String property, Class<A> type, Class<? super E> queryType) {
        validate(property, Set.class);
        return super.createSet(property, type, queryType, PathInits.DIRECT);
    }
513231
@SuppressWarnings("unchecked")
    public <T> PathBuilder<T> create(Class<T> type) {
        PathBuilder<T> rv = (PathBuilder<T>) paths.get(type);
        if (rv == null) {
            rv = new PathBuilder<T>(type, variableName(type));
            paths.put(type, rv);
        }
        return rv;
    }
284029
public static <T extends Comparable<?>> DateTimePath<T> dateTimePath(Class<? extends T> type, PathMetadata metadata) {
        return new DateTimePath<T>(type, metadata);
    }
627140
public static <T extends Comparable<?>> DateTimePath<T> dateTimePath(Class<? extends T> type, Path<?> parent,
            String property) {
        return new DateTimePath<T>(type, PathMetadataFactory.forProperty(parent, property));
    }
907968
public static <T> SimplePath<T> path(Class<? extends T> type, PathMetadata metadata) {
        return simplePath(type, metadata);
    }
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));
    }
598887
public static <T extends Comparable<?>> ComparablePath<T> comparablePath(Class<? extends T> type,
            String variable) {
        return new ComparablePath<T>(type, PathMetadataFactory.forVariable(variable));
    }
113526
public static <T> DslPath<T> dslPath(Class<? extends T> type, PathMetadata metadata) {
        return new DslPath<T>(type, metadata);
    }
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));
    }