Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.cantaa.util.wicket;
  
  import java.sql.Timestamp;
  import java.util.HashMap;
  import java.util.List;
 import java.util.Map;
 
 
To create type safe bean string-paths and wicket Property-Models

Author(s):
Hans Lesmeister
 
 public class SafeModel {
     private static final Logger log = LoggerFactory.getLogger(SafeModel.class);
 
     private static final ThreadLocal<List<String>> PATH = new ThreadLocal<List<String>>();
     private static final ThreadLocal<ObjectTARGET = new ThreadLocal<Object>();
     private static final ThreadLocal<Class<?>> LASTTYPE = new ThreadLocal<Class<?>>();
 
     private static final Map<Class<?>, ObjecttypeMap;
 
 
     private static final NullType nullType = new NullType();
 
     private static final class NullType {
     }
 
     static {
          = new HashMap<Class<?>, Object>();
         .put(boolean.class.);
         .put(int.class, Integer.valueOf(0));
         .put(long.class, Long.valueOf(0));
         .put(BigDecimal.class);
         .put(Timestamp.class);
         .put(List.class);
     }
 
 
     @SuppressWarnings("unchecked")
     public static <T> T from(T object) {
         if (object == null) {
             throw new IllegalArgumentException("object is null");
         }
 
         setTarget(object);
         return (T) from(object.getClass());
     }
 
     public static <T> T from(Class<T> clazz) {
         if (clazz == null) {
             throw new IllegalArgumentException("clazz is null");
         }
 
         T proxy = createProxy(clazz);
         return proxy;
     }
 
     public static <T, K> IModel<T> model(@SuppressWarnings("UnusedParameters") K proxy) {
         PropertyModel<T> propertyModel = new PropertyModel<T>(.get(), buildPath());
         clearPath();
         return propertyModel;
     }
 
     public static <T, K> IModel<K> model(IModel<T> model, @SuppressWarnings("UnusedParameters") K proxy) {
         PropertyModel<K> propertyModel = new PropertyModel<K>(modelbuildPath());
         clearPath();
         return propertyModel;
     }
 
     public static String path(@SuppressWarnings("UnusedParameters"Object proxy) {
         String path = buildPath();
         clearPath();
         return path;
     }
 
     private static <T> void setLastType(Class<T> lastType) {
         .set(lastType);
     }
 
     private static <T> void setTarget(T object) {
         .set(object);
     }
 
     private static void clearPath() {
         List<Stringlist = .get();
         if (list != null) {
            list.clear();
        }
        .remove();
    }
    private static void addToPath(String propName) {
        List<Stringlist = .get();
        if (list == null) {
            list = new ArrayList<String>();
            .set(list);
        }
        list.add(propName);
    }
    @SuppressWarnings("unchecked")
    private static <T> T createProxy(Class<T> clazz) {
        ProxyFactory factory = new ProxyFactory();
        if (clazz.isInterface()) {
            factory.setInterfaces(new Class[] {clazz});
        }
        else {
            factory.setSuperclass(clazz);
        }
        factory.setFilter(
                new MethodFilter() {
                    @Override
                    public boolean isHandled(Method method) {
                        String methodName = method.getName();
                        if (methodName.startsWith("get")) {
                            return true;
                        }
                        if (methodName.startsWith("is")) {
                            return true;
                        }
                        return false;
                    }
                }
        );//      return (T) Proxy.newProxyInstance(clazz.getClassLoader(), new Class<?>[]{clazz}, HANDLER);
        MethodHandler handler = new MethodHandler() {
            @Override
            public Object invoke(Object selfMethod thisMethodMethod proceedObject[] argsthrows Throwable {
                String methodName = thisMethod.getName();
                int pos = methodName.startsWith("get") ? 3 : 2; // getXXX or isXXX
                String propName = StringUtil.lowerFirstCharacter(methodName.substring(pos));
                addToPath(propName);
                Class<T> methodType = (Class<T>) thisMethod.getReturnType();
                setLastType(methodType);
                if (methodType.isPrimitive()) {
                    Object retVal = mapType(methodType);
                    if (retVal == null) {
                        throw new RuntimeException("Primitive type " + methodType + " is not supported");
                    }
                    return retVal;
                }
                if (Modifier.isFinal(methodType.getModifiers())) {
                    return null;
                }
                .debug("MethodType to analyse: {}"methodType);
                Object retVal = mapType(methodType);
                if (retVal == null) {
                    .debug("Mapping returned null, so create proxy");
                    return createProxy(methodType);
                }
                if (retVal instanceof NullType) {
                    .debug("Mapping returned NullType");
                    return null;
                }
                else {
                    .debug("Mapping returned: {}"retVal);
                    return retVal;
                }
            }
        };
        try {
            return (T) factory.create(new Class<?>[0], new Object[0], handler);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    private static <T> Object mapType(Class<T> type) {
        return .get(type);
    }
    private static String buildPath() {
        List<Stringlist = .get();
        if (list == null) {
            throw new IllegalStateException("No current path available");
        }
        StringBuilder b = new StringBuilder();
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            if (i > 0) {
                b.append(".");
            }
            b.append(s);
        }
        return b.toString();
    }
New to GrepCode? Check out our FAQ X