Dépôt officiel du code source de l'ERP OpenConcerto

import org.openconcerto.utils.StringUtils;

import org.openconcerto.utils.cache.CacheResult;

import org.openconcerto.utils.cache.ICache;

import org.openconcerto.utils.cc.ExnTransformer;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.util.ArrayList;

import java.util.Stack;

    private static final ICache<Object, Method, Object> cache = new ICache<Object, Method, Object>(60, -1, "methods for " + XMLCodecUtils.class);

    private static final ICache<Object, Constructor<?>, Object> cacheCtor = new ICache<Object, Constructor<?>, Object>(60, -1, "constructors for " + XMLCodecUtils.class);

        final Element elem = (Element) javaElem.getChildren().get(0);

        try {

            return eval(elem, new Stack<Object>(), new HashMap<String, Object>());

        } catch (Exception e) {

            throw new IllegalStateException("error decoding " + JDOM2Utils.output(javaElem), e);

        }

    }

    private static final Object eval(Element elem, Stack<Object> context, final Map<String, Object> ids)

            throws ClassNotFoundException, InstantiationException, IllegalAccessException, InvocationTargetException {

        final String n = elem.getName();

        // Ordered from real world scenario

        // string : 80k

        // void : 53k

        // int : 18k

        // object : 9k

        // null : 6k

        if (n.equals("string")) {

            return elem.getText();

        } else if (n.equals("void") || n.equals("object")) {

            final String idref = elem.getAttributeValue("idref");

            if (idref != null) {

                if (!ids.containsKey(idref))

                    throw new IllegalStateException("id '" + idref + "' wasn't defined");

                return ids.get(idref);

            }

            final String id = elem.getAttributeValue("id");

            final String targetClass = elem.getAttributeValue("class");

            final Object target = targetClass == null ? context.peek() : Class.forName(targetClass);

            final String propAttr = elem.getAttributeValue("property");

            final String indexAttr = elem.getAttributeValue("index");

            final String methodAttr = elem.getAttributeValue("method");

            // statement or expression

            final Object res = evalContainer(elem, context, ids, new ExnTransformer<List<Object>, Object, Exception>() {

                @Override

                public Object transformChecked(List<Object> args) throws Exception {

                    // call the statement

                    final Object res;

                    if (propAttr != null) {

                        final String methodName = (args.size() == 0 ? "get" : "set") + StringUtils.firstUp(propAttr);

                        res = invoke(target, methodName, args);

                    } else if (indexAttr != null) {

                        final String methodName;

                        if (target instanceof List) {

                            methodName = args.size() == 0 ? "get" : "set";

                            // get(index) or set(index, value)

                            args.add(0, Integer.valueOf(indexAttr));

                            res = invoke(target, methodName, args);

                        } else if (target.getClass().isArray()) {

                            final Class<?> componentType = target.getClass().getComponentType();

                            // in Array there's set(array, int index, Object value) or

                            // setPrimitive(array, int index, primitive value)

                            methodName = (args.size() == 0 ? "get" : "set") + (componentType.isPrimitive() ? StringUtils.firstUp(componentType.getSimpleName()) : "");

                            args.add(0, target);

                            args.add(1, Integer.valueOf(indexAttr));

                            res = invoke(Array.class, methodName, args);

                        } else

                            throw new IllegalStateException("use index with neither List nor array: " + target);

                    } else if (methodAttr != null) {

                        res = invoke(target, methodAttr, args);

                    } else

                        res = getCtor((Class<?>) target, args).newInstance(args.toArray());

                    return res;

                }

            });

            // not very functional but it works

            if (id != null)

                ids.put(id, res);

            return res;

        } else if (n.equals("int")) {

            return Integer.valueOf(elem.getText());

        } else if (n.equals("null")) {

            return null;

        } else if (n.equals("boolean")) {

            return Boolean.valueOf(elem.getText());

        } else if (n.equals("byte")) {

            return Byte.valueOf(elem.getText());

        } else if (n.equals("char")) {

            return Character.valueOf(elem.getText().charAt(0));

        } else if (n.equals("short")) {

            return Short.valueOf(elem.getText());

        } else if (n.equals("long")) {

            return Long.valueOf(elem.getText());

        } else if (n.equals("float")) {

            return Float.valueOf(elem.getText());

        } else if (n.equals("double")) {

            return Double.valueOf(elem.getText());

        } else if (n.equals("array")) {

            final String classAttr = elem.getAttributeValue("class");

            final String lengthAttr = elem.getAttributeValue("length");

            final Class<?> componentClass = parseClassName(classAttr);

            if (lengthAttr != null) {

                context.push(Array.newInstance(componentClass, Integer.parseInt(lengthAttr)));

                for (final Object child : elem.getChildren()) {

                    eval((Element) child, context, ids);

                }

                return context.pop();

            } else {

                return evalContainer(elem, context, ids, new ExnTransformer<List<Object>, Object, RuntimeException>() {

                    @Override

                    public Object transformChecked(List<Object> args) {

                        final Object res = Array.newInstance(componentClass, args.size());

                        for (int j = 0; j < args.size(); j++) {

                            Array.set(res, j, args.get(j));

                        }

                        return res;

                    }

                });

            }

        } else if (n.equals("class")) {

            return Class.forName(elem.getText());

        } else

            throw new UnsupportedOperationException("doesn't yet support " + n);

    }

    private static final Object evalContainer(final Element parent, Stack<Object> context, final Map<String, Object> ids, final ExnTransformer<List<Object>, Object, ? extends Exception> transf)

            throws ClassNotFoundException, InstantiationException, IllegalAccessException, InvocationTargetException {

        final List<Object> args = new ArrayList<Object>();

        final List<?> children = parent.getChildren();

        int i = 0;

        boolean noVoid = true;

        final int size = children.size();

        while (i < size && noVoid) {

            final Element child = (Element) children.get(i);

            if (child.getName().equals("void"))

                noVoid = false;

            else {

                args.add(eval(child, context, ids));

                i++;

            }

        }

        // call the statement

        final Object res = transf.transformCheckedWithExn(args, false, InvocationTargetException.class, InstantiationException.class, IllegalAccessException.class);

        context.push(res);

        // now call the voids

        while (i < children.size()) {

            final Element child = (Element) children.get(i);

            eval(child, context, ids);

            i++;

        }

        return context.pop();

    }

    private static final Object invoke(final Object target, String methodName, final List<Object> args) throws IllegalAccessException, InvocationTargetException {

        // <object class="Cell" method="createEmpty" >

        // for static methods the target is already a class

        final Class clazz = target instanceof Class ? (Class) target : target.getClass();

        final Method m = getMethod(clazz, methodName, args);

    }

    private static final Method getMethod(Class<?> clazz, String name, List<Object> actualArgs) {

        final List<Class<?>> actualClasses = objectsToClasses(actualArgs);

        final List<Object> key = new ArrayList<Object>(3);

        key.add(clazz);

        key.add(name);

        key.add(actualClasses);

        final CacheResult<Method> cacheRes = cache.check(key);

        if (cacheRes.getState() == CacheResult.State.VALID)

            return cacheRes.getRes();

        final Method res = findMethod(clazz, name, actualClasses);

        cache.put(key, res);

        return res;

    }

    private static final Constructor getCtor(Class<?> clazz, List<Object> actualArgs) {

        final List<Class<?>> actualClasses = objectsToClasses(actualArgs);

        final List<Object> key = new ArrayList<Object>(3);

        key.add(clazz);

        key.add(actualClasses);

        final CacheResult<Constructor<?>> cacheRes = cacheCtor.check(key);

        if (cacheRes.getState() == CacheResult.State.VALID)

            return cacheRes.getRes();

        final Constructor res = findCtor(clazz, actualClasses);

        cacheCtor.put(key, res);

        return res;

    }

    private static final List<Class<?>> objectsToClasses(List<Object> actualArgs) {

        final List<Class<?>> actualClasses = new ArrayList<Class<?>>(actualArgs.size());

        for (final Object actualArg : actualArgs)

            actualClasses.add(actualArg == null ? null : actualArg.getClass());

        return actualClasses;

    }

    // TODO return the most specific matching method instead of the first one

    // (handle both Sub/Superclass and primitive/object type)

    private static final Method findMethod(Class<?> clazz, String name, List<Class<?>> actualArgs) {

        for (final Method m : clazz.getMethods()) {

            if (m.getName().equals(name) && callableWith(m.getParameterTypes(), actualArgs)) {

                return m;

            }

        }

        return null;

    }

    // TODO see findMethod()

    private static final Constructor findCtor(Class<?> clazz, List<Class<?>> actualArgs) {

        for (final Constructor m : clazz.getConstructors()) {

            if (callableWith(m.getParameterTypes(), actualArgs)) {

                return m;

            }

        }

        return null;

    }

    private static final boolean callableWith(Class<?>[] formalArgs, List<Class<?>> actualArgs) {

        if (formalArgs.length != actualArgs.size())

            return false;

        int i = 0;

        for (final Class<?> argClass : formalArgs) {

            final Class<?> actualArg = actualArgs.get(i);

            // null match everything

            if (actualArg != null && !argClass.isAssignableFrom(actualArg) && argClass != getPrimitive(actualArg))

                return false;

            i++;

        }

        return true;

    }

    private static Class<?> getPrimitive(Class<?> argClass) {

        if (argClass == Boolean.class)

            return Boolean.TYPE;

        else if (argClass == Character.class)

            return Character.TYPE;

        else if (argClass == Byte.class)

            return Byte.TYPE;

        else if (argClass == Short.class)

            return Short.TYPE;

        else if (argClass == Integer.class)

            return Integer.TYPE;

        else if (argClass == Long.class)

            return Long.TYPE;

        else if (argClass == Float.class)

            return Float.TYPE;

        else if (argClass == Double.class)

            return Double.TYPE;

        else

            return null;

    }

    private static final Map<String, Class> primitiveNames = new HashMap<String, Class>();

    static {

        primitiveNames.put("boolean", boolean.class);

        primitiveNames.put("byte", byte.class);

        primitiveNames.put("char", char.class);

        primitiveNames.put("short", short.class);

        primitiveNames.put("int", int.class);

        primitiveNames.put("long", long.class);

        primitiveNames.put("float", float.class);

        primitiveNames.put("double", double.class);

    }

    /**

     * Parse class names (including primitive).

     * 

     * @param className a class name, eg "java.lang.String" or "int".

     * @return the matching class, eg java.lang.String.class or Integer.TYPE.

     * @throws ClassNotFoundException if the passed name doesn't exist.

     */

    private static Class<?> parseClassName(String className) throws ClassNotFoundException {

        final Class<?> primitive = primitiveNames.get(className);

        if (primitive != null)

            return primitive;

        else

            return Class.forName(className);