source: java/main/src/main/java/com/framsticks/params/ParamCandidate.java @ 90

package com.framsticks.params;

import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.GenericArrayType;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import com.framsticks.params.annotations.FramsClassAnnotation;
import com.framsticks.params.annotations.ParamAnnotation;
import com.framsticks.params.types.ProcedureParam;

public class ParamCandidate {

        public class OneTime<T> {
                protected final String name;
                T value;

                /**
                 * @param name
                 */
                public OneTime(String name) {
                        this.name = name;
                }

                final void set(T value) {
                        if (this.value == null) {
                                this.value = value;
                                return;
                        }
                        if (!this.value.equals(value)) {
                                throw new ConstructionException().msg("already set")
                                        .arg("name", name)
                                        .arg("in", ParamCandidate.this)
                                        .arg("already", this.value)
                                        .arg("now", value);
                        }
                }

                public final T get() {
                        return value;
                }

                public final boolean has() {
                        return value != null;
                }

                @Override
                public String toString() {
                        return value == null ? "<null>" : value.toString();
                }


        }

        protected final String id;
        protected final OneTime<String> name = new OneTime<>("name");
        protected final OneTime<Type> type = new OneTime<>("type");
        protected final OneTime<Field> field = new OneTime<>("field");
        protected final OneTime<Method> setter = new OneTime<>("setter");
        protected final OneTime<Method> getter = new OneTime<>("getter");
        protected final OneTime<Method> caller = new OneTime<>("caller");

        protected final List<ParamAnnotation> annotations = new LinkedList<>();

        /**
         * @param id
         */
        public ParamCandidate(String id) {
                this.id = id;
        }

        /**
         * @return the id
         */
        public String getId() {
                return id;
        }

        /**
         * @return the name
         */
        public String getName() {
                return name.get();
        }

        /**
         * @return the type
         */
        public Type getType() {
                return type.get();
        }

        public Class<?> getRawType() {
                return getRawClass(type.get());
        }

        void setType(Type type) {
                this.type.set(type);
        }


        /**
         * @return the field
         */
        public Field getField() {
                return field.get();
        }

        /**
         * @return the setter
         */
        public Method getSetter() {
                return setter.get();
        }

        /**
         * @return the getter
         */
        public Method getGetter() {
                return getter.get();
        }

        /**
         * @return the getter
         */
        public Method getCaller() {
                return caller.get();
        }

        /**
         * @return the annotations
         */
        public List<ParamAnnotation> getAnnotations() {
                return Collections.unmodifiableList(annotations);
        }

        void validate() throws ConstructionException {
                try {
                        if (caller.has()) {
                                if (!isPublic(caller)) {
                                        throw new ConstructionException().msg("method is not public");
                                }
                                if (getter.has() || setter.has()) {
                                        throw new ConstructionException().msg("getter or setter coexist with caller");
                                }
                                return;
                        }
                        if (isPublic(field)) {
                                if (getter.has()) {
                                        throw new ConstructionException().msg("getter and public field coexist");
                                }
                                return;
                        }
                        if (isPublic(field)) {
                                if (setter.has()) {
                                        throw new ConstructionException().msg("setter and field coexist");
                                }
                        }

                        if (!getter.has() && !field.has()) {
                                throw new ConstructionException().msg("missing getter or field");
                        }
                } catch (ConstructionException e) {
                        throw e.arg("in", this);
                }
        }

        boolean isFinal() {
                if (caller.has()) {
                        return false;
                }
                if (Collection.class.isAssignableFrom(getRawType())) {
                        return false;
                }
                if (setter.has()) {
                        return false;
                }
                if (field.has()) {
                        return Modifier.isFinal(field.get().getModifiers());
                }
                return true;
        }

        boolean isReadOnly() {
                if (caller.has()) {
                        return false;
                }
                if (Collection.class.isAssignableFrom(getRawType())) {
                        return false;
                }
                if (isPublic(setter)) {
                        return false;
                }
                if (isPublic(field)) {
                        return Modifier.isFinal(field.get().getModifiers());
                }
                return true;
        }

        void add(ParamAnnotation paramAnnotation, Member member, String name) {
                this.name.set(name);
                annotations.add(paramAnnotation);
                if (member instanceof Field) {
                        field.set((Field) member);
                        setType(field.get().getGenericType());
                        return;
                }
                if (member instanceof Method) {
                        Method m = (Method) member;
                        if (!paramAnnotation.paramType().equals(Param.class)) {
                                if (paramAnnotation.paramType().equals(ProcedureParam.class)) {
                                        caller.set(m);
                                        return;
                                }
                                throw new ConstructionException().msg("explicit set of paramType different than ProcedureParam is not yet supported").arg("name", name).arg("method", m).arg("in", this);
                        }
                        Type[] ps = m.getGenericParameterTypes();
                        if (ps.length == 0) {
                                getter.set(m);
                                setType(m.getGenericReturnType());
                                return;
                        }
                        if (ps.length == 1) {
                                setter.set(m);
                                setType(ps[0]);
                                return;
                        }
                        throw new ConstructionException().msg("invalid number of arguments").arg("method", m).arg("in", this);
                }
                throw new ConstructionException().msg("invalid kind of member").arg("member", member).arg("in", this);
        }

        public boolean isPrimitive() {
                return getRawType().isPrimitive();
        }

        public int getFlags() {
                int f = 0;
                if (isReadOnly()) {
                        f |= Flags.READONLY;
                }
                return f;
        }

        @Override
        public String toString() {
                return id + "(" + type.toString() + ")";
        }

        public static boolean isPublic(Member member) {
                return Modifier.isPublic(member.getModifiers());
        }

        public static boolean isPublic(OneTime<? extends Member> v) {
                return v.has() ? isPublic(v.get()) : false;
        }

        public static <M extends Member & AnnotatedElement> void filterParamsCandidates(Set set, M[] members) {
                for (M m : members) {
                        ParamAnnotation pa = m.getAnnotation(ParamAnnotation.class);
                        if (pa == null) {
                                continue;
                        }
                        String id = FramsClassBuilder.getId(pa, m);
                        ParamCandidate pc = null;
                        if (set.getCandidates().containsKey(id)) {
                                pc = set.getCandidates().get(id);
                        } else {
                                pc = new ParamCandidate(id);
                                set.getCandidates().put(id, pc);
                                set.getOrder().add(pc);
                        }
                        pc.add(pa, m, FramsClassBuilder.getName(pa, m));
                }
        }

        public static class Set {
                protected final Map<String, ParamCandidate> candidates;
                protected final List<ParamCandidate> order;

                /**
                 * @param candidates
                 * @param order
                 */
                public Set(Map<String, ParamCandidate> candidates, List<ParamCandidate> order) {
                        this.candidates = candidates;
                        this.order = order;
                }

                /**
                 * @return the candidates
                 */
                public Map<String, ParamCandidate> getCandidates() {
                        return candidates;
                }

                /**
                 * @return the order
                 */
                public List<ParamCandidate> getOrder() {
                        return order;
                }
        }

        public static Set getAllCandidates(Class<?> javaClass) throws ConstructionException {

                List<Class<?>> javaClasses = new LinkedList<>();
                while (javaClass != null) {
                        javaClasses.add(0, javaClass);
                        javaClass = javaClass.getSuperclass();
                }

                Set resultSet = new Set(new HashMap<String, ParamCandidate>(), new LinkedList<ParamCandidate>());

                for (Class<?> j : javaClasses) {
                        Set set = new Set(resultSet.getCandidates(), new LinkedList<ParamCandidate>());
                        filterParamsCandidates(set, j.getDeclaredFields());
                        filterParamsCandidates(set, j.getDeclaredMethods());

                        FramsClassAnnotation fa = j.getAnnotation(FramsClassAnnotation.class);
                        if (fa != null) {
                                final List<String> order = Arrays.asList(fa.order());
                                Collections.sort(set.getOrder(), new Comparator<ParamCandidate>() {
                                        @Override
                                        public int compare(ParamCandidate pc0, ParamCandidate pc1) {
                                                int u0 = order.indexOf(pc0.getId());
                                                int u1 = order.indexOf(pc1.getId());
                                                if (u0 == -1 || u1 == -1) {
                                                        return 0;
                                                }
                                                return u0 - u1;
                                        }
                                });
                        }
                        resultSet.getOrder().addAll(0, set.getOrder());
                }

                for (ParamCandidate pc : resultSet.getOrder()) {
                        pc.validate();
                }

                return resultSet;
        }

        public static Class<?> getRawClass(final Type type) {
                if (type == null) {
                        throw new IllegalArgumentException();
                }
                if (Class.class.isInstance(type)) {
                        return Class.class.cast(type);
                }
                if (ParameterizedType.class.isInstance(type)) {
                        final ParameterizedType parameterizedType = ParameterizedType.class.cast(type);
                        return getRawClass(parameterizedType.getRawType());
                } else if (GenericArrayType.class.isInstance(type)) {
                        GenericArrayType genericArrayType = GenericArrayType.class.cast(type);
                        Class<?> c = getRawClass(genericArrayType.getGenericComponentType());
                        return Array.newInstance(c, 0).getClass();
                } else {
                        return null;
                }
        }

};