source: java/main/src/main/java/com/framsticks/core/TreeOperations.java @ 97

package com.framsticks.core;

import java.util.List;

import javax.annotation.Nonnull;

import org.apache.log4j.Logger;

import com.framsticks.communication.File;
import com.framsticks.params.AccessInterface;
import com.framsticks.params.CompositeParam;
import com.framsticks.params.FramsClass;
import com.framsticks.params.ListAccess;
import com.framsticks.params.Param;
import com.framsticks.params.PrimitiveParam;
import com.framsticks.params.ValueParam;
import com.framsticks.params.types.ObjectParam;
import com.framsticks.params.types.ProcedureParam;
import com.framsticks.parsers.Loaders;
import com.framsticks.parsers.MultiParamLoader;
import com.framsticks.util.FramsticksException;
import com.framsticks.util.dispatching.Future;
import com.framsticks.util.dispatching.FutureHandler;
import com.framsticks.util.dispatching.RunAt;

import static com.framsticks.util.dispatching.Dispatching.*;

public final class TreeOperations {

        private static final Logger log = Logger.getLogger(TreeOperations.class.getName());

        private TreeOperations() {
        }

        public static @Nonnull FramsClass processFetchedInfo(Tree tree, File file) {
                assert tree.isActive();
                FramsClass framsClass = Loaders.loadFramsClass(file.getContent());
                if ("/".equals(file.getPath())) {
                        if (tree.getRoot().getParam().getContainedTypeName() == null) {
                                tree.setRoot(new Node(Param.build().name("Tree").id(tree.getName()).type("o " + framsClass.getId()).finish(CompositeParam.class), tree.getRoot().getObject()));
                        }
                }
                tree.putInfoIntoCache(framsClass);
                return framsClass;
        }

        public static FramsClass getInfo(Path path) {
                Tree tree = path.getTree();
                assert tree.isActive();
                final String name = path.getTop().getParam().getContainedTypeName();
                return tree.getInfoFromCache(name);
        }

        public static void findInfo(final Path path, final Future<FramsClass> future) {
                try {
                        Tree tree = path.getTree();
                        assert tree.isActive();
                        final FramsClass framsClass = getInfo(path);
                        if (framsClass != null) {
                                future.pass(framsClass);
                                return;
                        }
                        tree.info(path, future);
                } catch (FramsticksException e) {
                        future.handle(e);
                }
        }

        public static void processFetchedValues(Path path, List<File> files) {
                Tree tree = path.getTree();
                assert tree.isActive();
                assert files.size() == 1;
                assert path.isTheSame(files.get(0).getPath());
                Node node = path.getTop();
                MultiParamLoader loader = new MultiParamLoader();
                loader.setNewSource(files.get(0).getContent());
                loader.addBreakCondition(MultiParamLoader.Status.AfterObject);

                try {
                        if (node.getParam() instanceof ObjectParam) {
                                loader.addAccessInterface(TreeOperations.bindAccess(tree, node));
                                loader.go();
                                tree.notifyOfFetch(path);
                                return;
                        }

                        ListAccess listAccess = ((ListAccess) TreeOperations.bindAccess(tree, node));
                        assert listAccess != null;
                        listAccess.clearValues();

                        AccessInterface elementAccess = listAccess.getElementAccess();
                        loader.addAccessInterface(elementAccess);
                        MultiParamLoader.Status status;
                        while ((status = loader.go()) != MultiParamLoader.Status.Finished) {
                                if (status == MultiParamLoader.Status.AfterObject) {
                                        AccessInterface accessInterface = loader.getLastAccessInterface();

                                        String id = listAccess.computeIdentifierFor(accessInterface.getSelected());
                                        //TODO listAccessParam
                                        Param param = Param.build().forAccess(accessInterface).id(id).finish();
                                        Object child = accessInterface.getSelected();
                                        accessInterface.select(null);
                                        assert child != null;
                                        TreeOperations.bindAccess(tree, node).set((ValueParam) param, child);
                                }
                        }

                        tree.notifyOfFetch(path);
                } catch (Exception e) {
                        log.error("exception occurred while loading: " + e);
                }

        }

        public static void resolveAndGet(final Tree tree, final String targetPath, final Future<Path> future) {
                resolve(tree, targetPath, new FutureHandler<Path>(future) {
                        @Override
                        protected void result(final Path path) {
                                assert path.isResolved(targetPath);
                                //TODO Future
                                tree.get(path, Mode.FETCH, new FutureHandler<Object>(future) {
                                        @Override
                                        protected void result(Object object) {
                                                future.pass(path);
                                        }
                                });
                        }
                });
        }


        public static void resolve(final Path path, final Future<Path> future) {
                final Tree tree = path.getTree();
                assert tree.isActive();
                if (path.getTop().getObject() != null) {
                        if (getInfoFromCache(path) != null) {
                                future.pass(path);
                                return;
                        }
                        TreeOperations.findInfo(path, new FutureHandler<FramsClass>(future) {
                                @Override
                                protected void result(FramsClass result) {
                                        future.pass(path);
                                }
                        });
                        return;
                }
                TreeOperations.findInfo(path, new FutureHandler<FramsClass>(future) {
                        @Override
                        protected void result(FramsClass result) {
                                assert tree.isActive();
                                assert path.getTop().getParam().isMatchingContainedName(result.getId());
                                Path p = (path.getTop().getParam().getContainedTypeName() != null ? path : path.tryFindResolution());
                                future.pass(TreeOperations.createIfNeeded(p));
                        }
                });
        }

        public static Path createIfNeeded(Tree tree, String path) {
                assert tree.isActive();
                Path p;
                while (!(p = Path.to(tree, path)).isResolved(path)) {
                        tree.create(p);
                }
                return p;
        }

        public static Path createIfNeeded(Path path) {
                Tree tree = path.getTree();
                assert tree.isActive();
                if (path.isResolved()) {
                        return path;
                }
                return tree.create(path);
        }

        public static @Nonnull AccessInterface bindAccess(Tree tree, String path) {
                return bindAccess(Path.to(tree, path));
        }

        public static @Nonnull AccessInterface bindAccess(Tree tree, Node node) {
                assert tree.isActive();
                assert node.getObject() != null;

                try {
                        return tree.prepareAccess(node.getParam()).select(node.getObject());
                } catch (FramsticksException e) {
                        throw new FramsticksException().msg("failed to prepare access for param").arg("param", node.getParam()).cause(e);
                        // log.error("failed to bind access for " + node.getParam() + ": " + e);
                }
        }

        public static @Nonnull AccessInterface bindAccess(Path path) {
                assert path.getTree().isActive();
                path.assureResolved();
                return bindAccess(path.getTree(), path.getTop());
        }

        public static void set(final Path path, final PrimitiveParam<?> param, final Object value, final Future<Integer> future) {
                final Tree tree = path.getTree();

                dispatchIfNotActive(tree, new RunAt<Tree>(future) {
                        @Override
                        protected void runAt() {
                                tree.set(path, param, value, future);
                        }
                });
        }

        public static void call(final Path path, final ProcedureParam param, final Object[] arguments, final Future<Object> future) {
                final Tree tree = path.getTree();

                dispatchIfNotActive(tree, new RunAt<Tree>(future) {
                        @Override
                        protected void runAt() {
                                tree.call(path, param, arguments, future);
                        }
                });
        }

        /** This might not be correct. */
        public static void resolve(final Tree tree, final String targetPath, final Future<Path> future) {
                dispatchIfNotActive(tree, new RunAt<Tree>(future) {

                        @Override
                        protected void runAt() {
                                tree.resolve(Path.to(tree, targetPath), new FutureHandler<Path>(future) {
                                        @Override
                                        protected void result(Path result) {
                                                assert result.getTree().isActive();
                                                if (result.isResolved(targetPath)) {
                                                        future.pass(result);
                                                        return;
                                                }
                                                resolve(tree, targetPath, future);
                                        }
                                });
                        }
                });
        }

        public static FramsClass getInfoFromCache(Path path) {
                assert path.getTree().isActive();
                return path.getTree().getInfoFromCache(path.getTop().getParam().getContainedTypeName());
        }
}