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

package com.framsticks.core;

import com.framsticks.params.AccessInterface;
import com.framsticks.params.Param;
import com.framsticks.params.types.CompositeParam;
import com.framsticks.util.Dispatching;
import org.apache.log4j.Logger;

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

/**
 * @author Piotr Sniegowski
 */
public class Path {
    private final static Logger LOGGER = 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.prepareAccess(param) != null) ? child : null;
    }

    public Path(Instance instance, String textual) {
        assert instance.isActive();
        this.instance = instance;
        StringBuilder b = new StringBuilder();
        nodes.add(instance.root);
        Node current = instance.root;
        Iterator<String> i = Instance.splitPath(textual);
        while (i.hasNext() && current.getObject() != null) {
            AccessInterface access = instance.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();
    }

    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;
    }

    public Path findResolution() {
        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;
    }
}