source: java/main/src/main/java/com/framsticks/structure/AbstractTree.java @ 107

package com.framsticks.structure;

import java.util.Comparator;
import java.util.Iterator;
import java.util.Map;
import java.util.PriorityQueue;

import javax.annotation.Nonnull;

import org.apache.commons.collections.map.ReferenceIdentityMap;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;

import com.framsticks.communication.queries.NeedFile;
import com.framsticks.communication.queries.NeedFileAcceptor;
import com.framsticks.params.Access;
import com.framsticks.params.CompositeParam;
import com.framsticks.params.FramsClass;
import com.framsticks.params.ParamFlags;
import com.framsticks.params.ParamsPackage;
import com.framsticks.params.Registry;
import com.framsticks.params.annotations.AutoAppendAnnotation;
import com.framsticks.params.annotations.FramsClassAnnotation;
import com.framsticks.params.annotations.ParamAnnotation;
import com.framsticks.structure.messages.ListChange;
import com.framsticks.structure.messages.Message;
import com.framsticks.structure.messages.Result;
import com.framsticks.structure.messages.ValueChange;
import com.framsticks.util.ExceptionHandler;
import com.framsticks.util.FramsticksException;
import com.framsticks.util.Misc;
import com.framsticks.util.dispatching.AbstractJoinable;
import com.framsticks.util.dispatching.BufferedDispatcher;
import com.framsticks.util.dispatching.Dispatcher;
import com.framsticks.util.dispatching.Dispatching;
import com.framsticks.util.dispatching.Joinable;
import com.framsticks.util.dispatching.JoinableParent;
import com.framsticks.util.dispatching.JoinableState;
import com.framsticks.util.dispatching.RunAt;
import com.framsticks.util.dispatching.ThrowExceptionHandler;
import com.framsticks.util.lang.Pair;

/**
 * @author Piotr Sniegowski
 */
@FramsClassAnnotation
public abstract class AbstractTree extends AbstractJoinable implements Tree, JoinableParent, NeedFileAcceptor {

        private static final Logger log = LogManager.getLogger(AbstractTree.class);

        private Node root = null;
        private ExceptionHandler handler = ThrowExceptionHandler.getInstance();

        protected final BufferedDispatcher<Tree> bufferedDispatcher = new BufferedDispatcher<>(this);

        protected final Registry registry = new Registry();

        protected final PriorityQueue<Pair<Integer, NeedFileAcceptor>> needFileAcceptors = new PriorityQueue<>(32, new Comparator<Pair<Integer, NeedFileAcceptor>>() {

                @Override
                public int compare(Pair<Integer, NeedFileAcceptor> arg0, Pair<Integer, NeedFileAcceptor> arg1) {
                        if (arg0.first < arg1.first) {
                                return -1;
                        }
                        if (arg0.first > arg1.first) {
                                return 1;
                        }
                        return 0;
                }
        });

        @Override
        public void assignRootParam(CompositeParam param) {
                if (root != null) {
                        throw new FramsticksException().msg("root has already specified type");
                }
                root = new Node(this, param, null);
                log.debug("assigned root type: {}", root);
        }

        @Override
        public void assignRootObject(Object object) {
                if (root == null) {
                        throw new FramsticksException().msg("root has no type specified");
                }
                if (root.getObject() != null) {
                        throw new FramsticksException().msg("root has already object assigned").arg("current", root.getObject()).arg("candidate", object);
                }
                root = new Node(this, root.getParam(), object);
                log.debug("assigned root object: {}", root);
        }

        @Override
        public @Nonnull Node getAssignedRoot() {
                if (root == null) {
                        throw new FramsticksException().msg("root has no type specified yet").arg("in", this);
                }
                return root;
        }

        public boolean isRootAssigned() {
                // assert isActive();
                return root != null;
        }

        protected String name;

        public AbstractTree() {
                setName("tree");

                registry.registerAndBuild(Result.class);
                registry.registerAndBuild(ValueChange.class);
                registry.registerAndBuild(ListChange.class);
                registry.registerAndBuild(Message.class);
        }

        protected void tryRegisterOnChangeEvents(Path path) {

        }

        @Override
        public final FramsClass getInfoFromCache(String id) {
                assert isActive();
                return registry.getFramsClass(id);
        }


        @Override
        public @Nonnull Access prepareAccess(CompositeParam param) {
                return registry.prepareAccess(param, false);
        }

        @Override
        public void takeAllFrom(Registry source) {
                registry.takeAllFrom(source);
        }

        @AutoAppendAnnotation
        public void usePackage(ParamsPackage paramsPackage) {
                log.debug("using package {} in tree {}", paramsPackage, this);
                paramsPackage.register(registry);
        }

        @AutoAppendAnnotation
        public void takeFromRegistry(Registry registry) {
                log.debug("taking from registry {} in tree {}", registry, this);
                this.registry.takeAllFrom(registry);
        }


        @Override
        public void putInfoIntoCache(FramsClass framclass) {
                registry.putFramsClass(framclass);
        }


        /**
         * @return the handler
         */
        @Override
        public ExceptionHandler getExceptionHandler() {
                return handler;
        }

        /**
         * @param handler the handler to set
         */
        @Override
        public void setExceptionHandler(ExceptionHandler handler) {
                this.handler = handler;
        }

        @Override
        public void handle(FramsticksException exception) {
                handler.handle(exception);
        }

        /**
         * @return the dispatcher
         */
        @Override
        public Dispatcher<Tree> getDispatcher() {
                return bufferedDispatcher;
        }

        /**
         * @param dispatcher the dispatcher to set
         */
        @Override
        public void setDispatcher(Dispatcher<Tree> dispatcher) {
                bufferedDispatcher.setTargetDispatcher(dispatcher);
        }

        /**
         * @return the name
         */
        @ParamAnnotation(flags = ParamFlags.USERREADONLY)
        public String getName() {
                return name;
        }

        /**
         * @param name the name to set
         */
        @ParamAnnotation
        public void setName(String name) {
                this.name = name;
        }

        /**
         * @return the registry
         */
        @Override
        public Registry getRegistry() {
                return registry;
        }

        @Override
        protected void joinableStart() {
                bufferedDispatcher.createThreadIfNeeded();
                Dispatching.use(bufferedDispatcher, this);
        }

        @Override
        protected void joinableInterrupt() {
                Dispatching.drop(bufferedDispatcher, this);
        }

        @Override
        protected void joinableFinish() {

        }

        @Override
        protected void joinableJoin() throws InterruptedException {
                Dispatching.join(bufferedDispatcher);
        }

        @Override
        public void childChangedState(Joinable joinable, JoinableState state) {
                if (joinable == bufferedDispatcher) {
                        proceedToState(state);
                }
        }

        @Override
        public boolean isActive() {
                return bufferedDispatcher.isActive();
        }

        @Override
        public void dispatch(RunAt<? extends Tree> runnable) {
                bufferedDispatcher.dispatch(runnable);
        }


        @SuppressWarnings("unchecked")
        protected final Map<Object, Object> sideNotes = (Map<Object, Object>) new ReferenceIdentityMap(ReferenceIdentityMap.WEAK, ReferenceIdentityMap.HARD);

        @Override
        public <T> void putSideNote(Object object, SideNoteKey<T> key, T value) {
                assert isActive();
                Misc.throwIfNull(object);
                Misc.throwIfNull(key);
                Misc.throwIfNull(value);
                Object sideNote = sideNotes.get(object);
                if (sideNote == null) {
                        sideNote = new ReferenceIdentityMap(ReferenceIdentityMap.WEAK, ReferenceIdentityMap.HARD);
                        sideNotes.put(object, sideNote);
                }
                @SuppressWarnings("unchecked")
                Map<SideNoteKey<?>, Object> sideNotesMap = (Map<SideNoteKey<?>, Object>) sideNote;
                sideNotesMap.put(key, value);
        }

        @SuppressWarnings("unchecked")
        @Override
        public <T> T getSideNote(Object object, SideNoteKey<T> key) {
                assert isActive();
                Misc.throwIfNull(object);
                Misc.throwIfNull(key);
                Object sideNote = sideNotes.get(object);
                if (sideNote == null) {
                        return null;
                }
                Object value = ((Map<SideNoteKey<?>, Object>) sideNote).get(key);
                if (value == null) {
                        return null;
                }
                return (T) value;
        }

        @Override
        public boolean removeSideNote(Object object, SideNoteKey<?> key) {
                assert isActive();
                Object sideNote = sideNotes.get(object);
                if (sideNote == null) {
                        return false;
                }
                @SuppressWarnings("unchecked")
                Map<SideNoteKey<?>, Object> sideNotesMap = (Map<SideNoteKey<?>, Object>) sideNote;
                boolean result = (sideNotesMap.remove(key) != null);
                if (sideNotesMap.isEmpty()) {
                        sideNotes.remove(object);
                }
                return result;
        }

        @Override
        public void addNeedFileAcceptor(int priority, NeedFileAcceptor acceptor) {
                assert isActive();
                needFileAcceptors.add(Pair.make(priority, acceptor));
        }

        @Override
        public void removeNeedFileAcceptor(NeedFileAcceptor acceptor) {
                assert isActive();
                Iterator<Pair<Integer, NeedFileAcceptor>> i = needFileAcceptors.iterator();
                while (i.hasNext()) {
                        if (i.next().second == acceptor) {
                                i.remove();
                                break;
                        }
                }
        }

        @Override
        public boolean acceptNeed(final NeedFile needFile) {
                Dispatching.dispatchIfNotActive(this, new RunAt<AbstractTree>(needFile.getFuture()) {

                        @Override
                        protected void runAt() {
                                for (Pair<Integer, NeedFileAcceptor> acceptor : needFileAcceptors) {
                                        if (acceptor.second.acceptNeed(needFile)) {
                                                return;
                                        }
                                }
                                throw new FramsticksException().msg("failed to find need file acceptor in tree").arg("tree", AbstractTree.this).arg("needfile", needFile);
                        }
                });
                return true;
        }

}