How to use

com.querydsl.core.types.dsl.ComparablePath

constructor

/**
 * Create a new Path expression
 *
 * @param type type of expression
 * @param metadata path metadata
 * @param <T> type of expression
 * @return path expression
 */
public static <T extends Comparable<?>> ComparablePath<T> comparablePath(Class<? extends T> type,
                                     PathMetadata metadata) {
  return new ComparablePath<T>(type, metadata);
}

/**
 * Create a new Path expression
 *
 * @param type type of expression
 * @param parent parent path
 * @param property property path
 * @return path expression
 */
public static <T extends Comparable<?>> ComparablePath<T> comparablePath(Class<? extends T> type,
    Path<?> parent, String property) {
  return new ComparablePath<T>(type, PathMetadataFactory.forProperty(parent, property));
}

/**
 * Create a new Path expression
 *
 * @param type type of expression
 * @param variable variable name
 * @return path expression
 */
public static <T extends Comparable<?>> ComparablePath<T> comparablePath(Class<? extends T> type,
    String variable) {
  return new ComparablePath<T>(type, PathMetadataFactory.forVariable(variable));
}

/**
 * Create a new Comparable typed path
 *
 * @param <A>
 * @param property property name
 * @param type property type
 * @return property path
 */
@SuppressWarnings("unchecked")
protected <A extends Comparable> ComparablePath<A> createComparable(String property, Class<? super A> type) {
  return add(new ComparablePath<A>((Class) type, forProperty(property)));
}

/**
 * Create a new ComparableExpression
 *
 * @param expr Expression of type Comparable
 * @return new ComparableExpression
 */
public static <T extends Comparable<?>> ComparableExpression<T> asComparable(Expression<T> expr) {
  Expression<T> underlyingMixin = ExpressionUtils.extract(expr);
  if (underlyingMixin instanceof PathImpl) {
    return new ComparablePath<T>((PathImpl<T>) underlyingMixin);
  } else if (underlyingMixin instanceof OperationImpl) {
    return new ComparableOperation<T>((OperationImpl<T>) underlyingMixin);
  } else if (underlyingMixin instanceof TemplateExpressionImpl) {
    return new ComparableTemplate<T>((TemplateExpressionImpl<T>) underlyingMixin);
  } else {
    return new ComparableExpression<T>(underlyingMixin) {
      private static final long serialVersionUID = 389920618099394430L;
      @Override
      public <R, C> R accept(Visitor<R, C> v, C context) {
        return this.mixin.accept(v, context);
      }
    };
  }
}

@SuppressWarnings("unchecked")
@Test
public void various() {
  List<Path<?>> paths = new ArrayList<Path<?>>();
  paths.add(new ArrayPath(String[].class, "p"));
  paths.add(new BeanPath(Object.class, "p"));
  paths.add(new BooleanPath("p"));
  paths.add(new CollectionPath(String.class, StringPath.class, "p"));
  paths.add(new ComparablePath(String.class,"p"));
  paths.add(new DatePath(Date.class,"p"));
  paths.add(new DateTimePath(Date.class,"p"));
  paths.add(new EnumPath(ExampleEnum.class,"p"));
  paths.add(new ListPath(String.class, StringPath.class, "p"));
  paths.add(new MapPath(String.class, String.class, StringPath.class, "p"));
  paths.add(new NumberPath(Integer.class,"p"));
  paths.add(new SetPath(String.class, StringPath.class, "p"));
  paths.add(new SimplePath(String.class,"p"));
  paths.add(new StringPath("p"));
  paths.add(new TimePath(Time.class,"p"));
  for (Path<?> path : paths) {
    Path other = ExpressionUtils.path(path.getType(), "p");
    assertEquals(path.toString(), path.accept(ToStringVisitor.DEFAULT, null));
    assertEquals(path.hashCode(), other.hashCode());
    assertEquals(path, other);
    assertNotNull(path.getMetadata());
    assertNotNull(path.getType());
    assertEquals(path, path.getRoot());
  }
}

@SuppressWarnings("unchecked")
@Test
public void various() {
  List<DslExpression<?>> paths = new ArrayList<DslExpression<?>>();
  paths.add(new ArrayPath(String[].class, "p"));
  paths.add(new BeanPath(Object.class, "p"));
  paths.add(new BooleanPath("p"));
  paths.add(new CollectionPath(String.class, StringPath.class, "p"));
  paths.add(new ComparablePath(String.class,"p"));
  paths.add(new DatePath(Date.class,"p"));
  paths.add(new DateTimePath(Date.class,"p"));
  paths.add(new EnumPath(ExampleEnum.class,"p"));
  paths.add(new ListPath(String.class, StringPath.class, "p"));
  paths.add(new MapPath(String.class, String.class, StringPath.class, "p"));
  paths.add(new NumberPath(Integer.class,"p"));
  paths.add(new SetPath(String.class, StringPath.class, "p"));
  paths.add(new SimplePath(String.class,"p"));
  paths.add(new StringPath("p"));
  paths.add(new TimePath(Time.class,"p"));
  for (DslExpression<?> expr : paths) {
    Path<?> o = ExpressionUtils.path(expr.getType(), "o");
    assertEquals(ExpressionUtils.operation(expr.getType(), Ops.ALIAS, expr, o), expr.as("o"));
    Path p = ExpressionUtils.path(expr.getType(), "p");
    assertEquals(ExpressionUtils.operation(expr.getType(), Ops.ALIAS, expr, p), expr.as(p));
  }
}

@SuppressWarnings("unchecked")
@Test
public void various_properties() {
  Path<?> parent = ExpressionUtils.path(Object.class, "parent");
  List<Path<?>> paths = new ArrayList<Path<?>>();
  paths.add(new ArrayPath(String[].class, parent, "p"));
  paths.add(new BeanPath(Object.class, parent, "p"));
  paths.add(new BooleanPath(parent, "p"));
  paths.add(new CollectionPath(String.class, StringPath.class, parent, "p"));
  paths.add(new ComparablePath(String.class, parent, "p"));
  paths.add(new DatePath(Date.class, parent, "p"));
  paths.add(new DateTimePath(Date.class, parent, "p"));
  paths.add(new EnumPath(ExampleEnum.class, parent, "p"));
  paths.add(new ListPath(String.class, StringPath.class, parent, "p"));
  paths.add(new MapPath(String.class, String.class, StringPath.class, parent, "p"));
  paths.add(new NumberPath(Integer.class, parent, "p"));
  paths.add(new SetPath(String.class, StringPath.class, parent, "p"));
  paths.add(new SimplePath(String.class, parent, "p"));
  paths.add(new StringPath(parent, "p"));
  paths.add(new TimePath(Time.class, parent, "p"));
  for (Path<?> path : paths) {
    Path other = ExpressionUtils.path(path.getType(), PathMetadataFactory.forProperty(parent, "p"));
    assertEquals(path.toString(), path.accept(ToStringVisitor.DEFAULT, Templates.DEFAULT));
    assertEquals(path.hashCode(), other.hashCode());
    assertEquals(path, other);
    assertNotNull(path.getMetadata());
    assertNotNull(path.getType());
    assertEquals(parent, path.getRoot());
  }
}

@SuppressWarnings("unchecked")
@Test
public void equals() {
  assertEquals(new StringPath("s"),  new StringPath("s"));
  assertEquals(new BooleanPath("b"), new BooleanPath("b"));
  assertEquals(new NumberPath<Integer>(Integer.class,"n"), new NumberPath<Integer>(Integer.class,"n"));
  assertEquals(new ArrayPath(String[].class, "p"), ExpressionUtils.path(String.class, "p"));
  assertEquals(new BooleanPath("p"), ExpressionUtils.path(Boolean.class, "p"));
  assertEquals(new ComparablePath(String.class,"p"), ExpressionUtils.path(String.class, "p"));
  assertEquals(new DatePath(Date.class,"p"), ExpressionUtils.path(Date.class, "p"));
  assertEquals(new DateTimePath(Date.class,"p"), ExpressionUtils.path(Date.class, "p"));
  assertEquals(new EnumPath(ExampleEnum.class,"p"), ExpressionUtils.path(ExampleEnum.class, "p"));
  assertEquals(new NumberPath(Integer.class,"p"), ExpressionUtils.path(Integer.class, "p"));
  assertEquals(new StringPath("p"), ExpressionUtils.path(String.class, "p"));
  assertEquals(new TimePath(Time.class,"p"), ExpressionUtils.path(Time.class, "p"));
}

/**
 * Create a new Path expression
 *
 * @param type type of expression
 * @param metadata path metadata
 * @param <T> type of expression
 * @return path expression
 */
public static <T extends Comparable<?>> ComparablePath<T> comparablePath(Class<? extends T> type,
                                     PathMetadata metadata) {
  return new ComparablePath<T>(type, metadata);
}

/**
 * Create a new Path expression
 *
 * @param type type of expression
 * @param parent parent path
 * @param property property path
 * @return path expression
 */
public static <T extends Comparable<?>> ComparablePath<T> comparablePath(Class<? extends T> type,
    Path<?> parent, String property) {
  return new ComparablePath<T>(type, PathMetadataFactory.forProperty(parent, property));
}

/**
 * Create a new Path expression
 *
 * @param type type of expression
 * @param variable variable name
 * @return path expression
 */
public static <T extends Comparable<?>> ComparablePath<T> comparablePath(Class<? extends T> type,
    String variable) {
  return new ComparablePath<T>(type, PathMetadataFactory.forVariable(variable));
}

/**
 * Create a new Comparable typed path
 *
 * @param <A>
 * @param property property name
 * @param type property type
 * @return property path
 */
@SuppressWarnings("unchecked")
protected <A extends Comparable> ComparablePath<A> createComparable(String property, Class<? super A> type) {
  return add(new ComparablePath<A>((Class) type, forProperty(property)));
}

/**
 * Create a new ComparableExpression
 *
 * @param expr Expression of type Comparable
 * @return new ComparableExpression
 */
public static <T extends Comparable<?>> ComparableExpression<T> asComparable(Expression<T> expr) {
  Expression<T> underlyingMixin = ExpressionUtils.extract(expr);
  if (underlyingMixin instanceof PathImpl) {
    return new ComparablePath<T>((PathImpl<T>) underlyingMixin);
  } else if (underlyingMixin instanceof OperationImpl) {
    return new ComparableOperation<T>((OperationImpl<T>) underlyingMixin);
  } else if (underlyingMixin instanceof TemplateExpressionImpl) {
    return new ComparableTemplate<T>((TemplateExpressionImpl<T>) underlyingMixin);
  } else {
    return new ComparableExpression<T>(underlyingMixin) {
      private static final long serialVersionUID = 389920618099394430L;
      @Override
      public <R, C> R accept(Visitor<R, C> v, C context) {
        return this.mixin.accept(v, context);
      }
    };
  }
}