CodeCow/querydsl
1
0
Fork 0
mirror of https://github.com/querydsl/querydsl.git synced 2026-06-24 21:07:26 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

moved alias features to querydsl-core

Browse Source 
MiniApi extends now GrammarWithAlias
GrammarWithAlias provides alias factory methods and extends Grammar
Grammar provides only factory methods for operations
This commit is contained in:
Timo Westkämper 2009-01-16 13:59:02 +00:00
parent cb227fbe9c
commit 61b74e33dc
12 changed files with 5 additions and 952 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
querydsl-collections/pom.xml
View File

@ -22,16 +22,6 @@
<artifactId>querydsl-core</artifactId>
<version>${project.parent.version}</version>
</dependency>
<dependency>
<groupId>janino</groupId>
<artifactId>janino</artifactId>
<version>2.5.10</version>
</dependency>
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2</version>
</dependency>
<!-- test -->

47
querydsl-collections/src/main/java/com/mysema/query/collections/ExprFactory.java
View File

@ -1,47 +0,0 @@
/*
* Copyright (c) 2008 Mysema Ltd.
* All rights reserved.
*
*/
package com.mysema.query.collections;
import java.util.Collection;
import java.util.List;
import com.mysema.query.grammar.types.ColTypes.ExtString;
import com.mysema.query.grammar.types.Expr.EBoolean;
import com.mysema.query.grammar.types.Expr.EComparable;
import com.mysema.query.grammar.types.Expr.ESimple;
import com.mysema.query.grammar.types.Path.PBooleanArray;
import com.mysema.query.grammar.types.Path.PComparableArray;
import com.mysema.query.grammar.types.Path.PComponentCollection;
import com.mysema.query.grammar.types.Path.PComponentList;
import com.mysema.query.grammar.types.Path.PStringArray;
/**
* ExprFactory provides
*
* @author tiwe
* @version $Id$
*/
public interface ExprFactory {
EBoolean create(Boolean arg);
PBooleanArray create(Boolean[] args);
<D extends Comparable<D>> EComparable<D> create(D arg);
<D> ESimple<D> create(D arg);
<D> PComponentList<D> create(List<D> arg);
<D> PComponentCollection<D> create(Collection<D> arg);
<D extends Comparable<D>> PComparableArray<D> create(D[] args);
ExtString create(String arg);
PStringArray create(String[] args);
}

105
querydsl-collections/src/main/java/com/mysema/query/collections/MiniApi.java
View File

@ -1,105 +0,0 @@
/*
* Copyright (c) 2008 Mysema Ltd.
* All rights reserved.
*
*/
package com.mysema.query.collections;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import com.mysema.query.collections.alias.AliasAwareExprFactory;
import com.mysema.query.collections.alias.AliasFactory;
import com.mysema.query.grammar.Grammar;
import com.mysema.query.grammar.OrderSpecifier;
import com.mysema.query.grammar.types.Expr;
import com.mysema.query.grammar.types.Path;
import com.mysema.query.grammar.types.PathExtractor;
import com.mysema.query.grammar.types.PathMetadata;
import com.mysema.query.grammar.types.ColTypes.ExtString;
import com.mysema.query.grammar.types.Expr.EBoolean;
import com.mysema.query.grammar.types.Expr.EComparable;
import com.mysema.query.grammar.types.Expr.ESimple;
import com.mysema.query.grammar.types.Path.*;
/**
* MiniApi provides static convenience methods for query construction
*
* @author tiwe
* @version $Id$
*/
public class MiniApi {
private static final AliasFactory aliasFactory = new AliasFactory();
private static final ExprFactory exprFactory = new AliasAwareExprFactory(aliasFactory);
private static final PSimple<Object> it = new PSimple<Object>(Object.class,PathMetadata.forVariable("it"));
public static <A> A alias(Class<A> cl, String var){
return aliasFactory.createAliasForVar(cl, var);
}
public static <A> ColQuery<?> from(Expr<A> path, A... arr){
return from(path, Arrays.asList(arr));
}
@SuppressWarnings("unchecked")
public static <A> ColQuery<?> from(Expr<A> path, Iterable<A> col){
return new ColQuery().from((Path<?>)path, col);
}
@SuppressWarnings("unchecked")
public static <A> Iterable<A> select(Iterable<A> from, Expr.EBoolean where, OrderSpecifier<?>... order){
Path<A> path = (Path<A>) new PathExtractor().handle(where).getPath();
ColQuery query = new ColQuery().from(path, from).where(where).orderBy(order);
return query.iterate((Expr<A>)path);
}
public static <A> Iterable<A> reject(Iterable<A> from, Expr.EBoolean where, OrderSpecifier<?>...order){
return select(from, Grammar.not(where), order);
}
public static EBoolean $(Boolean arg){
return exprFactory.create(arg);
}
public static <D extends Comparable<D>> EComparable<D> $(D arg){
return exprFactory.create(arg);
}
public static ExtString $(String arg){
return exprFactory.create(arg);
}
public static PBooleanArray $(Boolean[] args){
return exprFactory.create(args);
}
public static <D extends Comparable<D>> PComparableArray<D> $(D[] args){
return exprFactory.create(args);
}
public static PStringArray $(String[] args){
return exprFactory.create(args);
}
public static <D> PComponentCollection<D> $(Collection<D> args){
return exprFactory.create(args);
}
public static <D> PComponentList<D> $(List<D> args){
return exprFactory.create(args);
}
public static <D> ESimple<D> $(D arg){
return exprFactory.create(arg);
}
@SuppressWarnings("unchecked")
public static <D> PSimple<D> $(){
return (PSimple<D>) it;
}
}

178
querydsl-collections/src/main/java/com/mysema/query/collections/SimpleExprFactory.java
View File

@ -1,178 +0,0 @@
/*
* Copyright (c) 2008 Mysema Ltd.
* All rights reserved.
*
*/
package com.mysema.query.collections;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.WeakHashMap;
import org.apache.commons.collections15.Transformer;
import org.apache.commons.collections15.map.LazyMap;
import org.apache.commons.lang.StringUtils;
import com.mysema.query.grammar.types.PathMetadata;
import com.mysema.query.grammar.types.ColTypes.ExtString;
import com.mysema.query.grammar.types.Expr.EBoolean;
import com.mysema.query.grammar.types.Expr.EComparable;
import com.mysema.query.grammar.types.Expr.ESimple;
import com.mysema.query.grammar.types.Path.*;
/**
* SimpleExprFactory is a factory implementation for the creation of Path instances
*
* @author tiwe
* @version $Id$
*/
// TODO : consider moving this later to querydsl-core
public class SimpleExprFactory implements ExprFactory {
private final ExtString strExt = new ExtString(PathMetadata.forVariable("str"));
private final PBoolean btrue = new PBoolean(md()), bfalse = new PBoolean(md());
private long counter = 0;
private final Map<Object,PBooleanArray> baToPath = new PathFactory<Object,PBooleanArray>(new Transformer<Object,PBooleanArray>(){
@SuppressWarnings("unchecked")
public PBooleanArray transform(Object arg) {
return new PBooleanArray(md());
}
});
private final Map<Object,PComparableArray<?>> caToPath = new PathFactory<Object,PComparableArray<?>>(new Transformer<Object,PComparableArray<?>>(){
@SuppressWarnings("unchecked")
public PComparableArray<?> transform(Object arg) {
return new PComparableArray(((List)arg).get(0).getClass(), md());
}
});
private final Map<Collection<?>,PComponentCollection<?>> ccToPath = new PathFactory<Collection<?>,PComponentCollection<?>>(new Transformer<Collection<?>,PComponentCollection<?>>(){
@SuppressWarnings("unchecked")
public PComponentCollection<?> transform(Collection<?> arg) {
if (!arg.isEmpty()){
return new PComponentCollection(((Collection)arg).iterator().next().getClass(), md());
}else{
return new PComponentCollection(null, md());
}
}
});
private final Map<List<?>,PComponentList<?>> clToPath = new PathFactory<List<?>,PComponentList<?>>(new Transformer<List<?>,PComponentList<?>>(){
@SuppressWarnings("unchecked")
public PComponentList<?> transform(List<?> arg) {
if (!arg.isEmpty()){
return new PComponentList(arg.get(0).getClass(), md());
}else{
return new PComponentList(null, md());
}
}
});
private final Map<Object,PComparable<?>> comToPath = new PathFactory<Object,PComparable<?>>(new Transformer<Object,PComparable<?>>(){
@SuppressWarnings("unchecked")
public PComparable<?> transform(Object arg) {
return new PComparable(arg.getClass(), md());
}
});
private final Map<Object,PStringArray> saToPath = new PathFactory<Object,PStringArray>(new Transformer<Object,PStringArray>(){
public PStringArray transform(Object arg) {
return new PStringArray(md());
}
});
private final Map<Object,PSimple<?>> simToPath = new PathFactory<Object,PSimple<?>>(new Transformer<Object,PSimple<?>>(){
@SuppressWarnings("unchecked")
public PSimple<?> transform(Object arg) {
return new PSimple(arg.getClass(), md());
}
});
private final Map<String,ExtString> strToExtPath = new PathFactory<String,ExtString>(new Transformer<String,ExtString>(){
public ExtString transform(String str) {
return new ExtString(md());
}
});
/* (non-Javadoc)
* @see com.mysema.query.collections.ExprFactory#create(java.lang.Boolean)
*/
public EBoolean create(Boolean arg){
return arg.booleanValue() ? btrue : bfalse;
}
/* (non-Javadoc)
* @see com.mysema.query.collections.ExprFactory#create(java.lang.Boolean[])
*/
public PBooleanArray create(Boolean[] args){
return baToPath.get(Arrays.asList(args));
}
@SuppressWarnings("unchecked")
public <D> PComponentCollection<D> create(Collection<D> arg) {
return (PComponentCollection<D>) ccToPath.get(arg);
}
/* (non-Javadoc)
* @see com.mysema.query.collections.ExprFactory#create(D)
*/
@SuppressWarnings("unchecked")
public <D extends Comparable<D>> EComparable<D> create(D arg){
return (EComparable<D>) comToPath.get(arg);
}
/* (non-Javadoc)
* @see com.mysema.query.collections.ExprFactory#create(D)
*/
@SuppressWarnings("unchecked")
public <D> ESimple<D> create(D arg){
return (ESimple<D>) simToPath.get(arg);
}
/* (non-Javadoc)
* @see com.mysema.query.collections.ExprFactory#create(D[])
*/
@SuppressWarnings("unchecked")
public <D extends Comparable<D>> PComparableArray<D> create(D[] args){
return (PComparableArray<D>) caToPath.get(Arrays.asList(args));
}
@SuppressWarnings("unchecked")
public <D> PComponentList<D> create(List<D> arg) {
return (PComponentList<D>) clToPath.get(arg);
}
/* (non-Javadoc)
* @see com.mysema.query.collections.ExprFactory#create(java.lang.String)
*/
public ExtString create(String arg){
return StringUtils.isEmpty(arg) ? strExt : strToExtPath.get(arg);
}
/* (non-Javadoc)
* @see com.mysema.query.collections.ExprFactory#create(java.lang.String[])
*/
public PStringArray create(String[] args){
return saToPath.get(Arrays.asList(args));
}
private PathMetadata<String> md(){
return PathMetadata.forVariable("v"+String.valueOf(++counter));
}
private static class PathFactory<K,V> extends LazyMap<K,V>{
private static final long serialVersionUID = -2443097467085594792L;
protected PathFactory(Transformer<K,V> transformer) {
super(new WeakHashMap<K,V>(), transformer);
}
}
}

110
querydsl-collections/src/main/java/com/mysema/query/collections/alias/AliasAwareExprFactory.java
View File

@ -1,110 +0,0 @@
/*
* Copyright (c) 2008 Mysema Ltd.
* All rights reserved.
*
*/
package com.mysema.query.collections.alias;
import java.util.Collection;
import java.util.List;
import com.mysema.query.collections.SimpleExprFactory;
import com.mysema.query.grammar.types.ColTypes.ExtString;
import com.mysema.query.grammar.types.Expr.EBoolean;
import com.mysema.query.grammar.types.Expr.EComparable;
import com.mysema.query.grammar.types.Expr.ESimple;
import com.mysema.query.grammar.types.Path.*;
/**
* AliasAwareExprFactory provides
*
* @author tiwe
* @version $Id$
*/
public class AliasAwareExprFactory extends SimpleExprFactory{
private final AliasFactory aliasFactory;
public AliasAwareExprFactory(AliasFactory aliasFactory){
this.aliasFactory = aliasFactory;
}
public EBoolean create(Boolean arg){
try{
return aliasFactory.hasCurrent() ? aliasFactory.<PBoolean>getCurrent() : super.create(arg);
}finally{
aliasFactory.setCurrent(null);
}
}
public PBooleanArray create(Boolean[] args){
try{
return aliasFactory.hasCurrent() ? aliasFactory.<PBooleanArray>getCurrent() : super.create(args);
}finally{
aliasFactory.setCurrent(null);
}
}
public <D> PComponentCollection<D> create(Collection<D> arg) {
try{
return aliasFactory.hasCurrent() ? aliasFactory.<PComponentCollection<D>>getCurrent() : super.create(arg);
}finally{
aliasFactory.setCurrent(null);
}
}
public <D extends Comparable<D>> EComparable<D> create(D arg){
try{
return aliasFactory.hasCurrent() ? aliasFactory.<EComparable<D>>getCurrent() : super.create(arg);
}finally{
aliasFactory.setCurrent(null);
}
}
@SuppressWarnings("unchecked")
public <D> ESimple<D> create(D arg){
try{
if (arg instanceof ManagedObject){
PSimple<D> path = (PSimple<D>) aliasFactory.pathForAlias(arg);
return path != null ? path : super.create(arg);
}else{
return super.create(arg);
}
}finally{
aliasFactory.setCurrent(null);
}
}
public <D extends Comparable<D>> PComparableArray<D> create(D[] args){
try{
return aliasFactory.hasCurrent() ? aliasFactory.<PComparableArray<D>>getCurrent() : super.create(args);
}finally{
aliasFactory.setCurrent(null);
}
}
public <D> PComponentList<D> create(List<D> arg) {
try{
return aliasFactory.hasCurrent() ? aliasFactory.<PComponentList<D>>getCurrent() : super.create(arg);
}finally{
aliasFactory.setCurrent(null);
}
}
public ExtString create(String arg){
try{
return aliasFactory.hasCurrent() ? aliasFactory.<ExtString>getCurrent() : super.create(arg);
}finally{
aliasFactory.setCurrent(null);
}
}
public PStringArray create(String[] args){
try{
return aliasFactory.hasCurrent() ? aliasFactory.<PStringArray>getCurrent() : super.create(args);
}finally{
aliasFactory.setCurrent(null);
}
}
}

95
querydsl-collections/src/main/java/com/mysema/query/collections/alias/AliasFactory.java
View File

@ -1,95 +0,0 @@
/*
* Copyright (c) 2008 Mysema Ltd.
* All rights reserved.
*
*/
package com.mysema.query.collections.alias;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import com.mysema.query.grammar.types.Expr;
import com.mysema.query.grammar.types.Path;
import com.mysema.query.grammar.types.PathMetadata;
import com.mysema.query.grammar.types.Path.PSimple;
import com.mysema.query.util.FactoryMap;
/**
* AliasFactory provides
*
* @author tiwe
* @version $Id$
*/
public class AliasFactory {
private final ThreadLocal<WeakIdentityHashMap<Object, Expr<?>>> bindings = new ThreadLocal<WeakIdentityHashMap<Object, Expr<?>>>() {
@Override
protected WeakIdentityHashMap<Object, Expr<?>> initialValue() {
return new WeakIdentityHashMap<Object, Expr<?>>();
}
};
private final ThreadLocal<Expr<?>> current = new ThreadLocal<Expr<?>>();
// caches top level paths (class/var as key)
private FactoryMap<PSimple<?>> pathCache = new FactoryMap<PSimple<?>>(){
public <A> PSimple<A> create(Class<A> cl, String var){
return new Path.PSimple<A>(cl, PathMetadata.forVariable(var));
}
};
// cahces top level proxies (class/var as key)
private FactoryMap<ManagedObject> proxyCache = new FactoryMap<ManagedObject>(){
public ManagedObject create(Class<?> cl, Expr<?> path){
return (ManagedObject) createProxy(cl, path);
}
};
public <A> A createAliasForProp(Class<A> cl, Object parent, Expr<?> path){
A proxy = createProxy(cl, path);
return proxy;
}
@SuppressWarnings("unchecked")
public <A> A createAliasForVar(Class<A> cl, String var){
Expr<?> path = pathCache.get(cl,var);
A proxy = (A) proxyCache.get(cl,path);
return proxy;
}
@SuppressWarnings("unchecked")
private <A> A createProxy(Class<A> cl, Expr<?> path) {
Enhancer enhancer = new Enhancer();
enhancer.setClassLoader(AliasFactory.class.getClassLoader());
if (cl.isInterface()){
enhancer.setInterfaces(new Class[]{cl,ManagedObject.class});
}else{
enhancer.setSuperclass(cl);
enhancer.setInterfaces(new Class[]{ManagedObject.class});
}
// creates one handler per proxy
MethodInterceptor handler = new PropertyAccessInvocationHandler(path,this);
enhancer.setCallback(handler);
A rv = (A)enhancer.create();
bindings.get().put(rv, path);
return rv;
}
@SuppressWarnings("unchecked")
public <A extends Expr<?>> A getCurrent() {
return (A) current.get();
}
public boolean hasCurrent() {
return current.get() != null;
}
public Expr<?> pathForAlias(Object key){
return bindings.get().get(key);
}
public void setCurrent(Expr<?> path){
current.set(path);
}
}

23
querydsl-collections/src/main/java/com/mysema/query/collections/alias/ManagedObject.java
View File

@ -1,23 +0,0 @@
/*
* Copyright (c) 2008 Mysema Ltd.
* All rights reserved.
*
*/
package com.mysema.query.collections.alias;
/**
* MagagedObject provides
*
* @author tiwe
* @version $Id$
*/
public interface ManagedObject {
void setElementType(Class<?> type);
void setKeyType(Class<?> type);
void setValueType(Class<?> type);
}

270
querydsl-collections/src/main/java/com/mysema/query/collections/alias/PropertyAccessInvocationHandler.java
View File

@ -1,270 +0,0 @@
/*
* Copyright (c) 2008 Mysema Ltd.
* All rights reserved.
*
*/
package com.mysema.query.collections.alias;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import org.apache.commons.lang.StringUtils;
import com.mysema.query.grammar.Grammar;
import com.mysema.query.grammar.JavaOps;
import com.mysema.query.grammar.JavaSerializer;
import com.mysema.query.grammar.types.CollectionType;
import com.mysema.query.grammar.types.Expr;
import com.mysema.query.grammar.types.Path;
import com.mysema.query.grammar.types.PathMetadata;
import com.mysema.query.grammar.types.ColTypes.ExtString;
import com.mysema.query.grammar.types.Path.PCollection;
import com.mysema.query.grammar.types.Path.PList;
/**
* PropertyAccessInvocationHandler provides
*
* @author tiwe
* @version $Id$
*/
class PropertyAccessInvocationHandler implements MethodInterceptor{
private final Expr<?> path;
private final AliasFactory aliasFactory;
private final JavaSerializer serializer = new JavaSerializer(new JavaOps());
private String toString;
private Class<?> elementType, keyType, valueType;
private final Map<String,Expr<?>> propToExpr = new HashMap<String,Expr<?>>();
private final Map<String,Object> propToObj = new HashMap<String,Object>();
public PropertyAccessInvocationHandler(Expr<?> path, AliasFactory aliasFactory){
this.path = path;
this.aliasFactory = aliasFactory;
}
private Class<?> get1stTypeParameter(Type type) {
if (type instanceof ParameterizedType){
return (Class<?>)((ParameterizedType)type).getActualTypeArguments()[0];
}else{
return null;
}
}
private Class<?> get2ndTypeParameter(Type type) {
if (type instanceof ParameterizedType){
return (Class<?>)((ParameterizedType)type).getActualTypeArguments()[1];
}else{
return null;
}
}
public Object intercept(Object proxy, Method method, Object[] args,
MethodProxy methodProxy) throws Throwable {
Object rv = null;
if (isGetter(method)){
String ptyName = propertyNameForGetter(method);
Class<?> ptyClass = method.getReturnType();
if (propToObj.containsKey(ptyName)){
rv = propToObj.get(ptyName);
}else{
PathMetadata<String> pm = PathMetadata.forProperty((Path<?>) path, ptyName);
rv = newInstance(ptyClass, proxy, ptyName, pm);
if (Collection.class.isAssignableFrom(ptyClass)){
((ManagedObject)rv).setElementType(get1stTypeParameter(method.getGenericReturnType()));
}else if (Map.class.isAssignableFrom(ptyClass)){
((ManagedObject)rv).setKeyType(get1stTypeParameter(method.getGenericReturnType()));
((ManagedObject)rv).setValueType(get2ndTypeParameter(method.getGenericReturnType()));
}
}
aliasFactory.setCurrent(propToExpr.get(ptyName));
}else if (isSizeAccessor(method)){
String ptyName = "_size";
if (propToObj.containsKey(ptyName)){
rv = propToObj.get(ptyName);
}else{
PathMetadata<Integer> pm = PathMetadata.forSize((PCollection<?>) path);
rv = newInstance(Integer.class, proxy, ptyName, pm);
}
aliasFactory.setCurrent(propToExpr.get(ptyName));
}else if (isListElementAccess(method)){
String ptyName = "_get" + args[0];
if (propToObj.containsKey(ptyName)){
rv = propToObj.get(ptyName);
}else{
PathMetadata<Integer> pm = PathMetadata.forListAccess((PList<?>)path, (Integer)args[0]);
if (elementType != null){
rv = newInstance(elementType, proxy, ptyName, pm);
}else{
rv = newInstance(method.getReturnType(), proxy, ptyName, pm);
}
}
aliasFactory.setCurrent(propToExpr.get(ptyName));
}else if (isMapElementAccess(method)){
// TODO
}else if (isContains(method)){
rv = false;
aliasFactory.setCurrent(Grammar.in(args[0], (CollectionType<Object>)path));
}else if (isToString(method)){
if (toString == null) toString = serializer.handle(path).toString();
rv = toString;
}else if (method.getName().equals("setElementType")){
elementType = (Class<?>) args[0];
}else if (method.getName().equals("setKeyType")){
keyType = (Class<?>) args[0];
}else if (method.getName().equals("setValueType")){
valueType = (Class<?>) args[0];
}else{
// rv = methodProxy.invokeSuper(proxy, args);
throw new IllegalArgumentException("Invocation of " + method.getName() + " not supported");
}
return rv;
}
private boolean isToString(Method method){
return method.getName().equals("toString")
&& method.getParameterTypes().length == 0
&& method.getReturnType().equals(String.class);
}
private boolean isContains(Method method){
return method.getName().equals("contains")
&& method.getParameterTypes().length == 1
&& method.getReturnType().equals(boolean.class);
}
private boolean isListElementAccess(Method method) {
return method.getName().equals("get")
&& method.getParameterTypes().length == 1
&& method.getParameterTypes()[0].equals(int.class);
}
private boolean isMapElementAccess(Method method) {
return method.getName().equals("get")
&& method.getParameterTypes().length == 1
&& method.getParameterTypes()[0].equals(Object.class);
}
private boolean isGetter(Method method){
return method.getParameterTypes().length == 0
&& (method.getName().startsWith("is")
|| method.getName().startsWith("get"));
}
private boolean isSizeAccessor(Method method) {
return method.getName().equals("size")
&& method.getParameterTypes().length == 0
&& method.getReturnType().equals(int.class);
}
@SuppressWarnings("unchecked")
private <T> T newInstance(Class<T> type, Object parent, String prop, PathMetadata<?> pm) {
Expr<?> path;
T rv;
if (String.class.equals(type)) {
path = new ExtString(pm);
rv = (T) new String();
// primitive types
} else if (Integer.class.equals(type) || int.class.equals(type)) {
path = new Path.PComparable<Integer>(Integer.class,pm);
rv = (T) Integer.valueOf(42);
} else if (Date.class.equals(type)) {
path = new Path.PComparable<Date>(Date.class,pm);
rv = (T) new Date();
} else if (Long.class.equals(type) || long.class.equals(type)) {
path = new Path.PComparable<Long>(Long.class,pm);
rv = (T) Long.valueOf(42l);
} else if (Short.class.equals(type) || short.class.equals(type)) {
path = new Path.PComparable<Short>(Short.class,pm);
rv = (T) Short.valueOf((short)42);
} else if (Double.class.equals(type) || double.class.equals(type)) {
path = new Path.PComparable<Double>(Double.class,pm);
rv = (T) Double.valueOf(42d);
} else if (Float.class.equals(type) || float.class.equals(type)) {
path = new Path.PComparable<Float>(Float.class,pm);
rv = (T) Float.valueOf(42f);
} else if (BigInteger.class.equals(type)) {
path = new Path.PComparable<BigInteger>(BigInteger.class,pm);
rv = (T) BigInteger.valueOf(42l);
} else if (BigDecimal.class.equals(type)) {
path = new Path.PComparable<BigDecimal>(BigDecimal.class,pm);
rv = (T) BigDecimal.valueOf(42d);
} else if (Boolean.class.equals(type) || boolean.class.equals(type)) {
path = new Path.PBoolean(pm);
rv = (T) Boolean.TRUE;
// Collection API types
} else if (List.class.isAssignableFrom(type)) {
path = new Path.PComponentList(elementType,pm);
rv = (T) aliasFactory.createAliasForProp(type, parent, path);
} else if (Set.class.isAssignableFrom(type)) {
path = new Path.PComponentCollection(elementType,pm);
rv = (T) aliasFactory.createAliasForProp(type, parent, path);
} else if (Collection.class.isAssignableFrom(type)) {
path = new Path.PComponentCollection(elementType,pm);
rv = (T) aliasFactory.createAliasForProp(type, parent, path);
} else if (Map.class.isAssignableFrom(type)) {
path = new Path.PComponentMap(keyType,valueType,pm);
rv = (T) aliasFactory.createAliasForProp(type, parent, path);
// enums
} else if (Enum.class.isAssignableFrom(type)) {
path = new Path.PSimple<T>(type, pm);
rv = type.getEnumConstants()[0];
} else {
path = new Path.PSimple<T>((Class<T>)type, pm);
rv = (T) aliasFactory.createAliasForProp(type, parent, path);
}
propToObj.put(prop, rv);
propToExpr.put(prop, path);
return rv;
}
private String propertyNameForGetter(Method method) {
String name = method.getName();
name = name.startsWith("is") ? name.substring(2) : name.substring(3);
return StringUtils.uncapitalize(name);
}
}

107
querydsl-collections/src/main/java/com/mysema/query/collections/alias/WeakIdentityHashMap.java
View File

@ -1,107 +0,0 @@
/*
* Copyright (C) 2008 Eric Bottard
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.mysema.query.collections.alias;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.Map;
import java.util.WeakHashMap;
/**
* Quick and dirty mix of {@link WeakHashMap} and {@link IdentityHashMap}. This
* class does not implement {@link Map} <i>per se</i> but provides the methods
* we need.
*/
/* default */class WeakIdentityHashMap<K, V> {
private Map<WeakReference<K>, V> map = new HashMap<WeakReference<K>, V>();
private ReferenceQueue<K> referenceQueue = new ReferenceQueue<K>();
private void expunge() {
Reference<? extends K> ref;
while ((ref = referenceQueue.poll()) != null) {
map.remove(ref);
}
}
public V get(K key) {
expunge();
WeakReference<K> keyref = makeReference(key);
return map.get(keyref);
}
private WeakReference<K> makeReference(K referent) {
return new IdentityWeakReference<K>(referent);
}
private WeakReference<K> makeReference(K referent, ReferenceQueue<K> q) {
return new IdentityWeakReference<K>(referent, q);
}
public V put(K key, V value) {
expunge();
if (key == null) {
throw new NullPointerException("Null key");
}
WeakReference<K> keyref = makeReference(key, referenceQueue);
return map.put(keyref, value);
}
public V remove(K key) {
expunge();
WeakReference<K> keyref = makeReference(key);
return map.remove(keyref);
}
/**
* Considers that two objects are equal when they both reference the same
* (with <tt>==</tt> semantics) referent.
*/
private static class IdentityWeakReference<T> extends WeakReference<T> {
private final int hashCode;
IdentityWeakReference(T o) {
this(o, null);
}
IdentityWeakReference(T o, ReferenceQueue<T> q) {
super(o, q);
this.hashCode = (o == null) ? 0 : System.identityHashCode(o);
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof IdentityWeakReference)) {
return false;
}
IdentityWeakReference<T> wr = (IdentityWeakReference<T>) o;
T got = get();
return (got != null && got == wr.get());
}
@Override
public int hashCode() {
return hashCode;
}
}
}

2
querydsl-collections/src/main/java/com/mysema/query/grammar/JavaSerializer.java
View File

@ -24,7 +24,7 @@ import org.slf4j.LoggerFactory;
import com.mysema.query.grammar.types.Expr;
import com.mysema.query.grammar.types.Path;
import com.mysema.query.grammar.types.ColTypes.ExtString;
import com.mysema.query.grammar.types.ExtTypes.ExtString;
import com.mysema.query.grammar.types.PathMetadata.PathType;
import com.mysema.query.serialization.BaseSerializer;
import com.mysema.query.serialization.OperationPatterns;

8
querydsl-collections/src/test/java/com/mysema/query/collections/MiniApiTest.java
View File

@ -6,11 +6,7 @@
package com.mysema.query.collections;
import static com.mysema.query.collections.MiniApi.$;
import static com.mysema.query.collections.MiniApi.alias;
import static com.mysema.query.collections.MiniApi.from;
import static com.mysema.query.collections.MiniApi.reject;
import static com.mysema.query.collections.MiniApi.select;
import static com.mysema.query.collections.MiniApi.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
@ -193,7 +189,9 @@ public class MiniApiTest {
}
@Test
@Ignore
public void testAliasToString(){
// NOTE : temporarily commented out, since alias features have been moved to querydsl-core
Cat c = alias(Cat.class, "c");
assertEquals("c", c.toString());

2
querydsl-collections/src/test/java/com/mysema/query/grammar/types/ColTypesTest.java
View File

@ -10,7 +10,7 @@ import static org.junit.Assert.assertTrue;
import org.junit.Test;
import com.mysema.query.collections.MiniApi;
import com.mysema.query.grammar.types.ColTypes.ExtString;
import com.mysema.query.grammar.types.ExtTypes.ExtString;
/**