source: java/main/src/main/java/com/framsticks/params/Registry.java @ 87

package com.framsticks.params;

import org.apache.log4j.Logger;

import com.framsticks.params.annotations.FramsClassAnnotation;

import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * Author: Piotr Śniegowski
 */
public class Registry {
        private static final Logger log = Logger.getLogger(Registry.class.getName());

        public static class DoubleSet<K1, K2, V> {
                protected final Map<K1, V> byId = new HashMap<>();
                protected final Map<K2, V> byName = new HashMap<>();
                protected final Set<V> values = new HashSet<>();

                public int size() {
                        return values.size();
                }

                public void put(K1 id, K2 name, V value) {
                        values.add(value);
                        if (id != null) {
                                byId.put(id, value);
                        }
                        if (name != null) {
                                byName.put(name, value);
                        }
                }

                public boolean containsValue(V value) {
                        return values.contains(value);

                }

                public boolean containsKey(String identifier) {
                        return byId.containsKey(identifier) || byName.containsKey(identifier);
                }

                public V get(String identifier) {
                        if (byId.containsKey(identifier)) {
                                return byId.get(identifier);
                        }
                        if (byName.containsKey(identifier)) {
                                return byName.get(identifier);
                        }
                        return null;
                }

                public Set<V> getValues() {
                        return Collections.unmodifiableSet(values);
                }
        }

        // protected void internalRegisterClass(FramsClass framsClass, @Nullable Class<?> javaClass) {
        //      assert framsClass.getName() != null;
        //      assert framsClass.getId() != null;
        //      infoCacheByName.put(framsClass.getName(), framsClass);
        //      infoCacheById.put(framsClass.getId(), framsClass);

        //      if (javaClass != null) {
        //              reflectedClasses.put(framsClass, javaClass);
        //              infoCacheByJavaName.put(javaClass.getCanonicalName(), framsClass);
        //      }
        // }
        protected final DoubleSet<String, String, Class<?>> javaClasses = new DoubleSet<>();
        protected final DoubleSet<String, String, FramsClass> framsClasses = new DoubleSet<>();

        public void registerReflectedClass(String name, String id, Class<?> reflectedClass) {
                javaClasses.put(id, name, reflectedClass);
        }

        public Registry register(Class<?> reflectedClass) {
                FramsClassAnnotation a = reflectedClass.getAnnotation(FramsClassAnnotation.class);
                if (a == null) {
                        log.error("class is not annotated: " + reflectedClass);
                        return this;
                }

                registerReflectedClass(FramsClassBuilder.getName(a, reflectedClass), FramsClassBuilder.getId(a, reflectedClass), reflectedClass);

                return this;
        }

        public AccessInterface createAccess(String name, FramsClass framsClass) throws ConstructionException {
                assert framsClasses.containsValue(framsClass);
                if (javaClasses.containsKey(name)) {
                        return new ReflectionAccess(javaClasses.get(name), framsClass);
                }
                return new PropertiesAccess(framsClass);
        }

        public void putInfoIntoCache(FramsClass framsClass) {
                log.debug("caching info for " + framsClass);
                framsClasses.put(framsClass.getId(), framsClass.getName(), framsClass);
        }

        public FramsClass getInfoFromCache(String identifier) {
                if (identifier == null) {
                        return null;
                }
                return framsClasses.get(identifier);
        }

        public static AccessInterface wrapAccessWithListIfNeeded(CompositeParam param, AccessInterface access) {
                if (access == null) {
                        return null;
                }
                return param.prepareAccessInterface(access);
        }

        public AccessInterface prepareAccess(CompositeParam param) throws ConstructionException {
                return wrapAccessWithListIfNeeded(param, createAccess(param.getContainedTypeName()));
        }

        public AccessInterface createAccess(String name) throws ConstructionException {
                if (name == null) {
                        return null;
                }
                FramsClass framsClass = getInfoFromCache(name);
                if (framsClass == null) {
                        return null;
                }

                return createAccess(name, framsClass);
        }

        public Set<Class<?>> getReflectedClasses() {
                return javaClasses.getValues();
        }

        public Set<FramsClass> getInfoCache() {
                return framsClasses.getValues();
        }

}