source: java/main/src/main/java/com/framsticks/core/Path.java @ 85

package com.framsticks.core;

import com.framsticks.params.AccessInterface;
import com.framsticks.params.CompositeParam;
import com.framsticks.params.Param;
import com.framsticks.util.dispatching.Dispatching;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

import javax.annotation.concurrent.Immutable;
import javax.annotation.Nonnull;

import org.apache.commons.collections.ListUtils;

/**
 * @author Piotr Sniegowski
 */
@Immutable
public class Path {
        // private final static Logger log = Logger.getLogger(Path.class.getName());

        final LinkedList<Node> nodes = new LinkedList<Node>();
        String textual;
        Instance instance;

        protected Object getKnownChild(AccessInterface access, CompositeParam param) {
                Object child = access.get(param, Object.class);
                if (child == null) {
                        return null;
                }
                return (instance.registry.prepareAccess(param) != null) ? child : null;
        }

        // public Path constructPath(Instance instance, String textual) {
        //      assert instance.isActive();

        // }

        Path(Instance instance, String textual) {
                assert instance.isActive();
                this.instance = instance;

                nodes.add(instance.root);
                Node current = instance.root;

                StringBuilder b = new StringBuilder();
                Iterator<String> i = Instance.splitPath(textual);
                while (i.hasNext() && current.getObject() != null) {
                        AccessInterface access = instance.registry.prepareAccess(current.getParam());
                        if (access == null) {
                                break;
                        }
                        String e = i.next();
                        Param p = access.getParam(e);
                        if (!(p instanceof CompositeParam)) {
                                //entries.add(new Entry());
                                break;
                        }
                        CompositeParam c = (CompositeParam)p;
                        b.append("/").append(e);
                        access.select(current.getObject());
                        current = new Node(c, getKnownChild(access, c));
                        nodes.add(current);
                }
                this.textual = (size() == 1) ? "/" : b.toString();
        }

        public Path(@Nonnull Instance instance, List<Node> nodes, Node node) {
                this.instance = instance;
                StringBuilder b = new StringBuilder();
                boolean add = false;
                for (Node n : nodes) {
                        this.nodes.add(n);
                        if (add) {
                                b.append("/").append(n.getParam().getId());
                        }
                        add = true;
                        if (n == node) {
                                break;
                        }
                }
                this.textual = (size() == 1) ? "/" : b.toString();
        }

        protected Path() {

        }

        public Path appendNode(Node node) {
                assert isResolved();
                Path result = new Path();
                result.textual = textual + ((size() == 1) ? "" : "/") + node.getParam().getId();
                result.instance = instance;
                result.nodes.addAll(nodes);
                result.nodes.add(node);
                return result;
        }

        public Path appendParam(CompositeParam param) {
                assert isResolved();
                return appendNode(new Node(param, null));
        }

        public Path appendResolution(Object object) {
                assert !isResolved();
                Path result = new Path();
                result.textual = textual;
                result.instance = instance;
                result.nodes.addAll(nodes);
                result.nodes.add(new Node(result.nodes.pollLast().getParam(), object));
                return result;
        }

        public final Object getTopObject() {
                return getTop().getObject();
        }

        public final Node getTop() {
                return nodes.getLast();
        }

        public final Node getUnder() {
                assert nodes.size() >= 2;
                return nodes.get(nodes.size() - 2);
        }

        public final String getTextual() {
                return textual;
        }

        public String toString() {
                return instance + textual + (!isResolved() ? "!" : "");
        }

        public final int size() {
                assert Dispatching.isThreadSafe();
                return nodes.size();
        }

        public final boolean isResolved() {
                assert Dispatching.isThreadSafe();
                return getTop().getObject() != null;
        }

        public final boolean isResolved(String textual) {
                assert Dispatching.isThreadSafe();
                return isTheSame(textual) && isResolved();
        }

        public final boolean isTheSame(String textual) {
                assert Dispatching.isThreadSafe();
                return this.textual.equals(textual);
        }

        public final Instance getInstance() {
                assert Dispatching.isThreadSafe();
                return instance;
        }


        /** Attach resolution at end, if available.
         *
         * @return Modified path, if resolution was available, this otherwise.
         */
        public Path tryFindResolution() {
                assert instance.isActive();
                assert !isResolved();
                if (size() == 1) {
                        return new Path(instance, "/");//appendResolution(instance.root.object);
                }
                Object child = getKnownChild(instance.bindAccess(getUnder()), getTop().getParam());
                if (child == null) {
                        return this;
                }
                return appendResolution(child);
        }

        public boolean matches(Path p) {
                assert Dispatching.isThreadSafe();
                assert instance == p.instance;
                Iterator<Node> a = nodes.iterator();
                Iterator<Node> b = p.nodes.iterator();
                while (a.hasNext() && b.hasNext()) {
                        Node an = a.next();
                        Node bn = b.next();
                        if (an.object != bn.object) {
                                return false;
                        }
                }
                return a.hasNext() == b.hasNext();
        }

        public String getLastElement() {
                return getTop().getParam().getId();
        }

        public final boolean isOwner(Instance instance) {
                return this.instance == instance;
        }

        public void setInstance(Instance instance) {
                this.instance = instance;
        }

        @SuppressWarnings("unchecked")
        public
        List<Node> getNodes() {
                return ListUtils.unmodifiableList(nodes);
        }
}