tree.java

办公自动化项目

package hong.javanet.util.tree;

import java.io.*;
import java.util.*;

/**
 *
 * <p>Title: </p>
 *
 * <p>Description: </p>
 *
 * <p>Copyright: Copyright (c) 2006</p>
 *
 * <p>Company: </p>
 *
 * @author 洪桃李
 * @version 2.0
 */
public class Tree implements Serializable {
    private Map nodes = new HashMap();
    private boolean initialize;
    private boolean createNotExistParent;
    private boolean initInheritParentData;
    private boolean initIncludeChildrenData;

    public void addTreeNode(TreeNode treenode) {
        this.initialize = false;
        treenode.setTree(this);
        nodes.put(treenode.getKey(), treenode);
    }
    public TreeNode getNode(Object key) {
        if(!this.initialize) {
            this.initialize();
        }
        return (TreeNode)this.nodes.get(key);
    }

    public Iterator keyIterator() {
        return this.nodes.keySet().iterator();
    }

    public void initialize() {
        if(!this.initialize) {
            this.initParentAndChildren();
            if(this.initInheritParentData) {
                this.initInheritParentData();
            }
            if(this.initIncludeChildrenData) {
                this.initIncludeChildrenData();
            }
        }
    }

    private void initParentAndChildren() {
        List nodesList = new ArrayList(this.nodes.size());
        Iterator iter = this.nodes.entrySet().iterator();
        while (iter.hasNext()) {
            Map.Entry item = (Map.Entry) iter.next();
            nodesList.add(item.getValue());
        }
       for(int i=0;i<nodesList.size();i++) {
            TreeNode node = (TreeNode) nodesList.get(i);
            node.init();
            if(node.getParentKey()!=null) {
                TreeNode parent = (TreeNode)this.nodes.get(node.getParentKey());
                if(parent==null && this.createNotExistParent) {
                    parent = node.cloneNode(node.getParentKey());
                    parent.init();
                    nodesList.add(parent);
                    this.nodes.put(parent.getKey(),parent);
                }
                node.parent = parent;
                if(parent!=null) {
                    parent.children.add(node);
                }
            }
        }
    }

    private void initInheritParentData() {
        Iterator iter = this.nodes.entrySet().iterator();
        while (iter.hasNext()) {
            Map.Entry item = (Map.Entry) iter.next();
            TreeNode node = (TreeNode)item.getValue();
            if(!node.initInheritParentData) {
                node.initInheritParentData();
                node.initInheritParentData = true;
            }
        }
    }

    private void initIncludeChildrenData() {
        Iterator iter = this.nodes.entrySet().iterator();
        while (iter.hasNext()) {
            Map.Entry item = (Map.Entry) iter.next();
            TreeNode node = (TreeNode)item.getValue();
            if(!node.initIncludeChildrenData) {
                node.initIncludeChildrenData();
                node.initIncludeChildrenData = true;
            }
        }
    }


    public void setCreateNotExistParent(boolean createNotExistParent) {
        this.createNotExistParent = createNotExistParent;
    }


    public void setInitInheritParentData(boolean initInheritParentData) {
        this.initInheritParentData = initInheritParentData;
    }

    public void setInitIncludeChildrenData(boolean initIncludeChildrenData) {
        this.initIncludeChildrenData = initIncludeChildrenData;
    }

    public boolean isCreateNotExistParent() {
        return createNotExistParent;
    }

    public boolean isInitInheritParentData() {
        return initInheritParentData;
    }

    public boolean isInitIncludeChildrenData() {
        return initIncludeChildrenData;
    }


}