source: java/main/src/main/java/com/framsticks/experiment/Experiment.java @ 102

package com.framsticks.experiment;

import java.util.Map;

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

import com.framsticks.core.ListChange;
import com.framsticks.params.EventListener;
import com.framsticks.params.ParamFlags;
import com.framsticks.params.SimpleUniqueList;
import com.framsticks.params.annotations.AutoAppendAnnotation;
import com.framsticks.params.annotations.FramsClassAnnotation;
import com.framsticks.params.annotations.ParamAnnotation;
import com.framsticks.params.types.ProcedureParam;
import com.framsticks.remote.RemoteTree;
import com.framsticks.util.FramsticksException;
import com.framsticks.util.dispatching.AbstractJoinable;
import com.framsticks.util.dispatching.BufferedDispatcher;
import com.framsticks.util.dispatching.Dispatcher;
import com.framsticks.util.dispatching.DispatcherSetable;
import com.framsticks.util.dispatching.Dispatching;
import com.framsticks.util.dispatching.ExceptionResultHandler;
import com.framsticks.util.dispatching.Joinable;
import com.framsticks.util.dispatching.JoinableCollection;
import com.framsticks.util.dispatching.JoinableParent;
import com.framsticks.util.dispatching.JoinableState;
import com.framsticks.util.dispatching.RunAt;

@FramsClassAnnotation
public class Experiment extends AbstractJoinable implements Dispatcher<Experiment>, DispatcherSetable<Experiment>, JoinableParent, ExceptionResultHandler {
        private static final Logger log = LogManager.getLogger(Experiment.class);

        protected final JoinableCollection<Simulator> simulatorAsJoinables = new JoinableCollection<Simulator>().setObservableName("simulators");

        protected final JoinableCollection<RemoteTree> simulatorCandidates = new JoinableCollection<RemoteTree>().setObservableName("candidates");

        protected final SimpleUniqueList<Simulator> simulators = new SimpleUniqueList<>(Simulator.class, 's');

        protected final SimpleUniqueList<Simulator> oldSimulators = new SimpleUniqueList<>(Simulator.class, 's');

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

        protected String expdef;

        /**
         *
         */
        public Experiment() {
                super();
                bufferedDispatcher.setBuffer(false);

                Dispatching.dispatchLog(this, log, Level.DEBUG, "first task");


                simulators.addListener(new EventListener<ListChange>() {
                        @Override
                        public void action(ListChange argument) {
                                if (argument.getAction() == ListChange.Action.Add) {
                                        simulators.fireChildrenChange(argument, ListChange.Action.Modify, "ready");
                                }
                        }
                });

        }

        /**
         * @return the simulatorCandidates
         */
        public JoinableCollection<RemoteTree> getSimulatorCandidates() {
                return simulatorCandidates;
        }

        @ParamAnnotation
        public Map<String, Simulator> getSimulators() {
                return simulators.getView();
        }

        @ParamAnnotation(id = "old_simulators")
        public Map<String, Simulator> getOldSimulators() {
                return oldSimulators.getView();
        }

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

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

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

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

        @ParamAnnotation(id = "simulators_changed")
        public void addSimulatorsListener(EventListener<ListChange> listener) {
                simulators.addListener(listener);
        }

        @ParamAnnotation(id = "simulators_changed")
        public void removeSimulatorsListener(EventListener<ListChange> listener) {
                simulators.removeListener(listener);
        }

        @AutoAppendAnnotation
        public void addSimulator(Simulator simulator) {
                simulators.add(simulator);
                simulatorAsJoinables.add(simulator);





        }

        protected void removeSimulator(Simulator simulator) {
                simulatorAsJoinables.remove(simulator);
                simulators.remove(simulator);
                oldSimulators.add(simulator);
        }

        @ParamAnnotation(id = "old_simulators_changed")
        public void addOldSimulatorsListener(EventListener<ListChange> listener) {
                oldSimulators.addListener(listener);
        }

        @ParamAnnotation(id = "old_simulators_changed")
        public void removeOldSimulatorsListener(EventListener<ListChange> listener) {
                oldSimulators.removeListener(listener);
        }

        @Override
        public String getName() {
                return "experiment";
        }

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

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

                Dispatching.use(simulatorAsJoinables, this);
                Dispatching.use(simulatorCandidates, this);
        }

        @Override
        protected void joinableInterrupt() {

                Dispatching.drop(simulatorAsJoinables, this);
                Dispatching.drop(simulatorCandidates, this);

                finishJoinable();
        }

        @Override
        protected void joinableFinish() {
                log.debug("finishing experiment {}", this);
        }

        @Override
        protected void joinableJoin() throws InterruptedException {
                Dispatching.drop(bufferedDispatcher, this);

                Dispatching.join(simulatorAsJoinables);
                Dispatching.join(simulatorCandidates);
                Dispatching.join(bufferedDispatcher.getTargetDispatcher());
        }

        @Override
        public void handle(FramsticksException exception) {
                log.error("caught exception: ", exception);
        }

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

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

        @ParamAnnotation(paramType = ProcedureParam.class)
        public void connectToSimulator(String address) {
                SimulatorConnector connector = new SimulatorConnector();
                connector.setAddress(address);
                connector.attachTo(this);
        }

}