main page modules namespaces classes files
Gecode/J home

Node.java

Go to the documentation of this file.

/* -*- indent-tabs-mode: nil -*- */
/*
 *  Main authors:
 *     Marco Kuhlmann <kuhlmann@ps.uni-sb.de>
 *     Guido Tack <tack@gecode.org>
 *
 *  Copyright:
 *     Marco Kuhlmann, 2005
 *     Guido Tack, 2006
 *
 *  Last modified:
 *     $Date: 2006-10-26 11:31:58 +0200 (Thu, 26 Oct 2006) $ by $Author: tack $
 *     $Revision: 3796 $
 *
 *  This file is part of Gecode, the generic constraint
 *  development environment:
 *     http://www.gecode.org
 *
 *  See the file "LICENSE" for information on usage and
 *  redistribution of this file, and for a
 *     DISCLAIMER OF ALL WARRANTIES.
 *
 */

package org.gecode.gist;

import java.util.*;


public class Node {
    
    public static final NodeStatus Undetermined = NodeStatus.UNDETERMINED;
    
    private static final ArrayList emptyList = new ArrayList(0);
    
    private Node parent;
    private Node nextSibling;
    private ArrayList children;
    private int nextChildIndex;
    
    public Node() {
        this.parent = null;
        this.nextSibling = null;
        this.children = null;
        this.nextChildIndex = 0;
    }
    
    public Node getParent() {
        return parent;
    }
    
    public Node getNextSibling() {
        return nextSibling;
    }
    
    public boolean isLastChild() {
        return (nextSibling == null);
    }
    
    public void setNumberOfChildren(int numberOfChildren) {
        children = new ArrayList(numberOfChildren);
        for (int i = 0; i < numberOfChildren; i++) {
            children.add(null);
        }
        nextChildIndex = 0;
    }
    
    public void setChildren(Collection theChildren) {
        children = new ArrayList(theChildren.size());
        nextChildIndex = 0;
        Node previousChild = null;
        Iterator theChildrenIterator = theChildren.iterator();
        while (theChildrenIterator.hasNext()) {
            Node nextChild = (Node) theChildrenIterator.next();
            nextChild.parent = this;
            if (previousChild != null) {
                previousChild.nextSibling = nextChild;
            }
            children.add(nextChild);
            previousChild = nextChild;
            nextChildIndex++;
        }
    }
    
    public void setNextChild(int index, Node childNode) {
        children.set(index, childNode);
        childNode.parent = this;
        if (index > 0) {
            ((Node) children.get(index - 1)).nextSibling = childNode;
        }
//        nextChildIndex++;
    }
    
    public int getNumberOfChildren() {
        if (children == null) {
            return -1;
        } else {
            return children.size();
        }
    }
    
    public Node getChild(int index) {
        return (Node) children.get(index);
    }
    
    public Node getFirstChild() {
        return (Node) children.get(0);
    }
    
    public Iterator childrenIterator() {
        if (children == null) {
            return emptyList.iterator();
        } else {
            return children.iterator();
        }
    }
    
    private class ReversedChildrenIterator implements Iterator {
        
        int currentIndex;
        
        public ReversedChildrenIterator () {
            this.currentIndex = children.size() - 1;
        }
        
        public boolean hasNext() {
            return (currentIndex >= 0);
        }
        
        public Object next() {
            try {
                currentIndex--;
                return children.get(currentIndex + 1);
            } catch (IndexOutOfBoundsException e) {
                throw new NoSuchElementException();
            }
        }
        
        public void remove() {
            throw new UnsupportedOperationException();
        }
        
    }
    
    public Iterator reversedChildrenIterator() {
        if (children == null) {
            return emptyList.iterator();
        } else {
            return new ReversedChildrenIterator();
        }
    }
        
    public boolean isRoot() {
        return (parent == null);
    }
    
    public int getDepth() {
        return isRoot() ? 1 : (parent.getDepth() + 1);
    }
}