How to use

wrap

method

in

com.mysema.query.types.FactoryExpressionUtils

@SuppressWarnings("unchecked")
private <T> Expression<T> normalize(Expression<T> expr) {
  if (expr instanceof FactoryExpression<?>) {
    return (Expression<T>) FactoryExpressionUtils.wrap((FactoryExpression<?>) expr);
  } else {
    return expr;
  }
}

/**
 * @param projection
 * @return
 */
public static FactoryExpression<?> wrap(List<? extends Expression<?>> projection) {
  boolean usesFactoryExpressions = false;
  for (Expression<?> e : projection) {
    usesFactoryExpressions |= e instanceof FactoryExpression;
  }
  if (usesFactoryExpressions) {
    return wrap(new ArrayConstructorExpression(
        projection.toArray(new Expression[projection.size()])));
  } else {
    return null;
  }
}

@Override
public Expression<?> visit(FactoryExpression<?> expr, @Nullable Void context) {
  List<Expression<?>> args = visit(expr.getArgs());
  if (args.equals(expr.getArgs())) {
    return expr;
  } else {
    return FactoryExpressionUtils.wrap(expr, args);
  }
}

/**
 * Get the results as a list
 *
 * @param expression
 * @return
 */
public <V> ResultTransformer<List<V>> list(FactoryExpression<V> expression) {
  final FactoryExpression<?> transformation = FactoryExpressionUtils.wrap(expression);
  List<Expression<?>> args = transformation.getArgs();
  return new GroupByList<K, V>(key, args.toArray(new Expression<?>[args.size()])) {
    @Override
    protected V transform(Group group) {
      // XXX Isn't group.toArray() suitable here?
      List<Object> args = new ArrayList<Object>(groupExpressions.size() - 1);
      for (int i = 1; i < groupExpressions.size(); i++) {
        args.add(group.getGroup(groupExpressions.get(i)));
      }
      return (V)transformation.newInstance(args.toArray());
    }
  };
}

/**
 * Get the results as a closeable iterator
 *
 * @param expression
 * @return
 */
public <V> ResultTransformer<CloseableIterator<V>> iterate(FactoryExpression<V> expression) {
  final FactoryExpression<?> transformation = FactoryExpressionUtils.wrap(expression);
  List<Expression<?>> args = transformation.getArgs();
  return new GroupByIterate<K, V>(key, args.toArray(new Expression<?>[args.size()])) {
    @Override
    protected V transform(Group group) {
      // XXX Isn't group.toArray() suitable here?
      List<Object> args = new ArrayList<Object>(groupExpressions.size() - 1);
      for (int i = 1; i < groupExpressions.size(); i++) {
        args.add(group.getGroup(groupExpressions.get(i)));
      }
      return (V)transformation.newInstance(args.toArray());
    }
  };
}

/**
 * Get the results as a map
 *
 * @param expression
 * @return
 */
public <V> ResultTransformer<Map<K, V>> as(FactoryExpression<V> expression) {
  final FactoryExpression<?> transformation = FactoryExpressionUtils.wrap(expression);
  List<Expression<?>> args = transformation.getArgs();
  return new GroupByMap<K, V>(key, args.toArray(new Expression<?>[args.size()])) {
    @Override
    protected Map<K, V> transform(Map<K, Group> groups) {
      Map<K, V> results = new LinkedHashMap<K, V>((int) Math.ceil(groups.size()/0.75), 0.75f);
      for (Map.Entry<K, Group> entry : groups.entrySet()) {
        results.put(entry.getKey(), transform(entry.getValue()));
      }
      return results;
    }
    @SuppressWarnings("unchecked")
    protected V transform(Group group) {
      // XXX Isn't group.toArray() suitable here?
      List<Object> args = new ArrayList<Object>(groupExpressions.size() - 1);
      for (int i = 1; i < groupExpressions.size(); i++) {
        args.add(group.getGroup(groupExpressions.get(i)));
      }
      return (V)transformation.newInstance(args.toArray());
    }
  };
}

@SuppressWarnings("rawtypes")
public <RT> Expression<RT> convert(Expression<RT> expr, boolean forOrder) {
  if (expandAnyPaths) {
    if (expr instanceof Path) {
      expr = (Expression)normalizePath((Path)expr);
    } else if (expr != null) {
      if (replaceVisitor == null) {
        replaceVisitor = new ReplaceVisitor() {
          public Expression<?> visit(Path<?> expr, @Nullable Void context) {
            return normalizePath(expr);
          }
        };
      }
      expr = (Expression)expr.accept(replaceVisitor, null);
    }
  }
  if (expr instanceof ProjectionRole<?>) {
    return convert(((ProjectionRole) expr).getProjection(), forOrder);
  } else if (expr instanceof FactoryExpression<?> && !(expr instanceof FactoryExpressionAdapter<?>)) {
    return FactoryExpressionUtils.wrap((FactoryExpression<RT>)expr);
  } else {
    return expr;
  }
}

@Override
public Map<K, V> transform(Projectable projectable) {
  Map<K, Group> groups = new LinkedHashMap<K, Group>();
  // create groups
  FactoryExpression<Tuple> expr = FactoryExpressionUtils.wrap(new QTuple(expressions));
  boolean hasGroups = false;
  for (Expression<?> e : expr.getArgs()) {
    hasGroups |= e instanceof GroupExpression;
  }
  if (hasGroups) {
    expr = withoutGroupExpressions(expr);
  }
  CloseableIterator<Tuple> iter = projectable.iterate(expr);
  try {
    while (iter.hasNext()) {
      Object[] row = iter.next().toArray();
      K groupId = (K) row[0];
      GroupImpl group = (GroupImpl)groups.get(groupId);
      if (group == null) {
        group = new GroupImpl(groupExpressions, maps);
        groups.put(groupId, group);
      }
      group.add(row);
    }
  } finally {
    iter.close();
  }
  // transform groups
  return transform(groups);
}

@Override
public CloseableIterator<V> transform(Projectable projectable) {
  FactoryExpression<Tuple> expr = FactoryExpressionUtils.wrap(new QTuple(expressions));
  boolean hasGroups = false;
  for (Expression<?> e : expr.getArgs()) {

@Override
public List<V> transform(Projectable projectable) {
  FactoryExpression<Tuple> expr = FactoryExpressionUtils.wrap(new QTuple(expressions));
  boolean hasGroups = false;
  for (Expression<?> e : expr.getArgs()) {