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

package com.framsticks.params;

import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;

import com.framsticks.params.annotations.FramsClassAnnotation;
import com.framsticks.params.annotations.ParamAnnotation;
import com.framsticks.util.DoubleMap;
import com.framsticks.util.FramsticksException;
import com.framsticks.util.lang.Casting;
import com.framsticks.util.lang.Strings;

import java.util.IdentityHashMap;
import java.util.Map;
import java.util.Set;

import javax.annotation.Nonnull;

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

        protected final DoubleMap<String, Class<?>> javaClasses = new DoubleMap<>();
        protected final DoubleMap<String, FramsClass> framsClasses = new DoubleMap<>();
        protected final Map<Class<?>, FramsClass> javaToFramsAssociation = new IdentityHashMap<>();

        /**
         *
         */
        public Registry() {
                // registerAndBuild(Registry.class);
                // registerAndBuild(FramsClass.class);
                // registerAndBuild(Param.class);
        }

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

        public void associate(Class<?> javaClass, FramsClass framsClass) {
                javaToFramsAssociation.put(javaClass, framsClass);
        }

        public Registry registerAndBuild(Class<?> javaClass) {
                if (javaToFramsAssociation.containsKey(javaClass)) {
                        return this;
                }
                register(javaClass);
                associate(javaClass, putFramsClass(FramsClass.build().forClass(javaClass)));
                for (Class<?> r : ParamCandidate.getAllCandidates(javaClass).getDependentClasses()) {
                        registerAndBuild(r);
                }

                for (String i : ParamCandidate.getAllCandidates(javaClass).getDependentClassesFromInfo()) {
                        putFramsClass(FramsClassBuilder.readFromStream(getClass().getResourceAsStream("/info/" + i + ".info")));
                }
                return this;
        }

        public FramsClass registerReflectedIfNeeded(Class<?> javaClass) {
                if (!javaToFramsAssociation.containsKey(javaClass)) {
                        registerAndBuild(javaClass);
                }
                return javaToFramsAssociation.get(javaClass);
        }

        public Registry register(Class<?> javaClass) {
                FramsClassAnnotation a = javaClass.getAnnotation(FramsClassAnnotation.class);
                if (a == null) {
                        throw new FramsticksException().msg("class is not annotated").arg("class", javaClass);
                }

                registerReflectedClass(FramsClassBuilder.getName(a, javaClass), FramsClassBuilder.getId(a, javaClass), javaClass);
                return this;
        }

        public @Nonnull ReflectionAccess createAccess(Class<?> javaClass) throws ConstructionException {
                try {
                        if (!javaClasses.containsValue(javaClass)) {
                                registerAndBuild(javaClass);
                        }

                        if (!javaClasses.containsValue(javaClass)) {
                                throw new FramsticksException().msg("java class is not registered");
                        }
                        if (!javaToFramsAssociation.containsKey(javaClass)) {
                                throw new FramsticksException().msg("java class is not associated with any frams class");
                        }
                        return new ReflectionAccess(javaClass, javaToFramsAssociation.get(javaClass));
                }
                catch (FramsticksException e) {
                        throw new FramsticksException().msg("failed to create access for java class").arg("class", javaClass).cause(e);
                }
        }

        public @Nonnull Access 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 FramsClass putFramsClass(FramsClass framsClass) {
                log.debug("caching info for {}", framsClass);
                framsClasses.put(framsClass.getId(), framsClass.getName(), framsClass);
                return framsClass;
        }

        public FramsClass getFramsClass(@Nonnull CompositeParam param) {
                return framsClasses.get(param.getContainedTypeName());
        }

        public FramsClass getFramsClass(@Nonnull String identifier) {
                return framsClasses.get(identifier);
        }

        public static @Nonnull Access wrapAccessWithListIfNeeded(@Nonnull CompositeParam param, @Nonnull Access access) {
                return param.prepareAccess(access);
        }

        public @Nonnull Access prepareAccess(CompositeParam param, boolean force) throws ConstructionException {
                return wrapAccessWithListIfNeeded(param, createAccess(param.getContainedTypeName(), force));
        }

        public @Nonnull Access createAccess(@Nonnull Object object) throws ConstructionException {
                if (object instanceof MapBasedObject) {
                        return createAccess(((MapBasedObject) object).getFramsTypeName());
                }
                return createAccess(object.getClass());
        }

        public @Nonnull Access createAccess(@Nonnull String name, boolean force) throws ConstructionException {
                try {
                        Strings.assureNotEmpty(name);
                        FramsClass framsClass = getFramsClass(name);
                        if (framsClass == null) {
                                if (!force) {
                                        throw new ConstructionException().msg("framsclass is missing");
                                }
                                return new FreeAccess(name);
                        }

                        return createAccess(name, framsClass);
                }
                catch (FramsticksException e) {
                        throw new FramsticksException().msg("failed to create access for name").arg("name", name).cause(e);
                }
        }

        public @Nonnull Access createAccess(@Nonnull String name) throws ConstructionException {
                return createAccess(name, false);
        }

        public FramsClass getFramsClassForJavaClass(Class<?> javaClass) {
                return javaToFramsAssociation.get(javaClass);
        }

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

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

        @ParamAnnotation
        public Map<String, FramsClass> getFramsClassesById() {
                return framsClasses.getValuesById();
        }

        public void takeAllFrom(Registry source) {
                for (Class<?> javaClass : source.getReflectedClasses()) {
                        register(javaClass);
                }
                for (FramsClass framsClass : source.getFramsClasses()) {
                        putFramsClass(framsClass);
                }

        }

        @Override
        public Access getAccess(String name) {
                return createAccess(name);
        }

        public Access bindAccessFor(Object object) {
                return createAccess(object).select(object);
        }

        public Registry register(ParamsPackage paramsPackage) {
                paramsPackage.register(this);
                return this;
        }

        public Registry registerAndBuild(ParamsPackage paramsPackage) {
                paramsPackage.setBuild(true);
                paramsPackage.register(this);
                return this;
        }

        public Access bindAccessFor(Access parent, String paramName) {
                CompositeParam childParam = Casting.throwCast(CompositeParam.class, parent.getParam(paramName));
                return prepareAccess(childParam, true).select(parent.get(childParam, Object.class));
        }


}