source: java/main/src/main/java/com/framsticks/experiment/NetLoadSaveLogic.java @ 103

package com.framsticks.experiment;


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

import com.framsticks.core.ListChange;
import com.framsticks.core.Message;
import com.framsticks.params.EventListener;
import com.framsticks.params.MessageLogger;
import com.framsticks.params.annotations.FramsClassAnnotation;
import com.framsticks.params.annotations.ParamAnnotation;
import com.framsticks.util.dispatching.Future;
import com.framsticks.util.dispatching.FutureHandler;

@FramsClassAnnotation
public abstract class NetLoadSaveLogic<NF extends NetFile> extends AbstractExperimentLogic {
        private static final Logger log = LogManager.getLogger(NetLoadSaveLogic.class);

        protected String option = "an option";

        protected final Class<NF> netJavaClass;

        protected final MessageLogger messages = new MessageLogger(NetLoadSaveLogic.class);

        /**
         * @param experiment
         */
        public NetLoadSaveLogic(Experiment parentExperiment, Class<NF> netJavaClassArg) {
                super(parentExperiment);
                this.netJavaClass = netJavaClassArg;

                experiment.addSimulatorsListener(new EventListener<ListChange>() {

                        @Override
                        public void action(final ListChange change) {
                                assert experiment.isActive();
                                final Simulator simulator = experiment.getSimulators().get(change.getIdentifier());
                                log.debug("processing list change: {}", change);

                                if (change.getAction() == ListChange.Action.Add) {
                                        log.debug("registering in {}", simulator);
                                        simulator.getRemoteTree().getRegistry().registerAndBuild(netJavaClass);
                                }

                                if (!change.hasHint("stoped")) {
                                        issueNetloadIfReady(change, simulator);
                                        return;
                                }

                                log.debug("issuing netsave to: {}", simulator);
                                simulator.netsave(netJavaClass, new FutureHandler<NF>(simulator) {

                                        @Override
                                        protected void result(NF net) {
                                                log.debug("netsave of {} done: {}", simulator, net.getShortDescription());
                                                netsave(simulator, net);
                                                issueNetloadIfReady(change, simulator);
                                        }
                                });
                        }
                });
        }

        protected void issueNetloadIfReady(ListChange change, final Simulator simulator) {
                if (!change.hasHint("ready")) {
                        return;
                }
                log.debug("issuing netload to: {}", simulator);
                netload(simulator, new FutureHandler<NF>(simulator) {

                        @Override
                        protected void result(final NF net) {
                                if (net == null) {
                                        log.debug("no file for upload provided - leaving simulator idle");
                                        return;
                                }

                                simulator.netload(net, new FutureHandler<Object>(this) {

                                        @Override
                                        protected void result(Object result) {
                                                NetLoadSaveLogic.this.messages.info("netload", "done " + net.getShortDescription());
                                                log.debug("netload of {} done", net.getShortDescription());
                                                simulator.start();
                                        }
                                });
                        }
                });
        }

        public abstract void netload(Simulator simulator, Future<NF> net);

        public abstract void netsave(Simulator simulator, NF net);

        /**
         * @return the option
         */
        @ParamAnnotation
        public String getOption() {
                return option;
        }

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

        /**
         * @return the netJavaClass
         */
        @ParamAnnotation(name = "Java class representing netfile")
        public String getNetJavaClassName() {
                return netJavaClass.getCanonicalName();
        }

        @ParamAnnotation(id = "messages")
        public void addMessageListener(EventListener<Message> listener) {
                messages.add(listener);
        }

        @ParamAnnotation(id = "messages")
        public void removeMessageListener(EventListener<Message> listener) {
                messages.remove(listener);
        }

}