cn.featherfly.common.structure.tree.SimpleTreeNode Maven / Gradle / Ivy
/**
* @author 钟冀 - yufei
* Mar 19, 2009
*/
package cn.featherfly.common.structure.tree;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import cn.featherfly.common.lang.LangUtils;
import cn.featherfly.common.structure.tree.matcher.TreeNodeEqualsMatcher;
/**
*
* 树节点
*
*
*
* - 修改人 钟冀 构造参数已经确定必须有id，去掉setId()方法
*
- 修改人 钟冀 去掉childNodes的setter方法，用appendChildNodes()来代替
*
- 修改人 钟冀 去掉isLeafNode属性，通过childsize来判断
*
- 修改人 钟冀 加入clone方法，实现深度复制
*
*
* @param 树节点存放的类型
* @author 钟冀
*/
public class SimpleTreeNode implements Cloneable, TreeNode{
private static final Logger LOGGER = LoggerFactory.getLogger(TreeNode.class);
/**
* 根节点的层级
*/
protected static final int ROOT_DEPTH = 0;
private String id;
private TreeNode parentNode;
private E nodeObject;
private int depth = ROOT_DEPTH;
private List> childNodes = new ArrayList>();
// ********************************************************************
// constractor
// ********************************************************************
/**
* @param id 节点ID
*/
public SimpleTreeNode(String id) {
this.id = id;
}
// ********************************************************************
// TreeNode method 整个节点范围
// ********************************************************************
/**
* {@inheritDoc}
*/
@Override
public List> getAncestors() {
return getAncestors(new ArrayList>(), this);
}
private List> getAncestors(List> ancestor,
TreeNode node) {
TreeNode parentNode = node.getParent();
if (parentNode != null) {
ancestor.add(parentNode);
return getAncestors(ancestor, parentNode);
} else {
return ancestor;
}
}
/**
* {@inheritDoc}
*/
@Override
public boolean hasAncestor(TreeNode ancestor) {
TreeNode parentNode = this.getParent();
if (parentNode == null || ancestor == null) {
return false;
} else {
boolean is = parentNode.equals(ancestor);
if (is) {
return true;
} else {
return parentNode.hasAncestor(ancestor);
}
}
}
/**
* {@inheritDoc}
*/
@Override
public boolean isProgeny(TreeNode ancestor) {
return hasAncestor(ancestor);
}
/**
* {@inheritDoc}
*/
@Override
public List> getEveryNode() {
List> nodeList = new ArrayList>();
nodeList.add(this);
getProgenys(nodeList, this);
return nodeList;
}
/**
* {@inheritDoc}
*/
@Override
public List> getProgenys() {
List> nodeList = new ArrayList>();
getProgenys(nodeList, this);
return nodeList;
}
private void getProgenys(List> nodeList, TreeNode node) {
if (!node.isLeaf()) {
Iterator> iter = node.getChildNodes().iterator();
while (iter.hasNext()) {
TreeNode childNode = iter.next();
nodeList.add(childNode);
getProgenys(nodeList, childNode);
}
}
}
/**
* {@inheritDoc}
*/
@Override
public boolean hasProgeny(TreeNode progeny) {
if (progeny == null) {
return false;
}
List> childs = this.getChildNodes();
Iterator> iter = childs.iterator();
while (iter.hasNext()) {
TreeNode child = iter.next();
boolean is = progeny.equals(child);
if (is) {
return true;
} else {
is = child.hasProgeny(progeny);
}
if (is) {
return true;
}
}
return false;
}
/**
* {@inheritDoc}
*/
@Override
public boolean isAncestor(TreeNode progeny) {
return hasProgeny(progeny);
}
/**
* {@inheritDoc}
*/
@Override
public TreeNode findProgeny(TreeNode progeny) {
if (progeny == null) {
return null;
}
// TODO 使用matcher重写
TreeNodeMatcher> matcher = new TreeNodeEqualsMatcher>(progeny);
return findTreeNode(matcher, this.getChildNodes());
// return findProgeny(progeny.getId());
}
/**
* {@inheritDoc}
*/
@Override
public TreeNode findProgeny(String progenyId) {
Iterator> it = this.getChildNodes().iterator();
while (it.hasNext()) {
TreeNode node = it.next().findTreeNode(progenyId);
if (node != null) {
return node;
}
}
return null;
}
/**
* {@inheritDoc}
*/
@Override
public TreeNode findTreeNode(TreeNodeMatcher> matcher) {
if (matcher == null) {
return null;
}
return findTreeNode(matcher, this);
}
private TreeNode findTreeNode(TreeNodeMatcher> matcher, TreeNode treeNode) {
if (matcher.match(treeNode)) {
return treeNode;
} else {
findTreeNode(matcher, treeNode.getChildNodes());
// List> childs = treeNode.getChildNodes();
// Iterator> iter = childs.iterator();
// while (iter.hasNext()) {
// TreeNode child = iter.next();
// TreeNode result = null;
// result = ((SimpleTreeNode) child).findTreeNode(matcher, child);
// if (result != null) {
// return result;
// }
// }
}
return null;
}
private TreeNode findTreeNode(TreeNodeMatcher> matcher, Collection> treeNodes) {
if (LangUtils.isNotEmpty(treeNodes)) {
Iterator> iter = treeNodes.iterator();
while (iter.hasNext()) {
TreeNode child = iter.next();
TreeNode result = null;
result = ((SimpleTreeNode) child).findTreeNode(matcher, child);
if (result != null) {
return result;
}
}
}
return null;
}
/**
* {@inheritDoc}
*/
@Override
public TreeNode findTreeNode(TreeNode node) {
if (node == null) {
return null;
}
// TODO 使用matcher重写，写死的matcher
TreeNodeMatcher> matcher = new TreeNodeEqualsMatcher>(node);
return findTreeNode(matcher);
// return findTreeNode(node.getId());
}
/**
* {@inheritDoc}
*/
@Override
public TreeNode findTreeNode(String nodeId) {
// TODO 这种基于ID的方法是否需要删除
if (nodeId == null || "".equals(nodeId)) {
return null;
}
if (nodeId.equals(this.getId())) {
return this;
} else {
List> childs = this.getChildNodes();
Iterator> iter = childs.iterator();
while (iter.hasNext()) {
TreeNode child = iter.next();
TreeNode result = null;
result = child.findTreeNode(nodeId);
if (result != null) {
return result;
}
}
}
return null;
}
/**
* {@inheritDoc}
*/
@Override
public void each(NodeExecutor> executor) {
executor.execute(this);
if (!this.isLeaf()) {
Iterator> iter = this.getChildNodes().iterator();
while (iter.hasNext()) {
iter.next().each(executor);
}
}
}
/**
* 改变当前节点的depth，级联改变子孙节点
* @param depth 层级
*/
public void changeDepth(int depth) {
this.depth = depth;
if (!this.isLeaf()) {
Iterator> it = getChildNodes().iterator();
while (it.hasNext()) {
TreeNode node = it.next();
((SimpleTreeNode) node).changeDepth(depth + 1);
}
}
}
// ********************************************************************
// TreeNode method 上下级节点范围
// ********************************************************************
/**
* {@inheritDoc}
*/
@Override
public int indexOf(TreeNode childNode) {
return getChildNodes().indexOf(childNode);
}
/**
* {@inheritDoc}
*/
@Override
public int getPosition() {
if (this.getParent() == null || this.getParent().getChildSize() < 2) {
return 0;
}
return this.getParent().indexOf(this);
}
/**
* {@inheritDoc}
*/
@Override
public boolean hasChildNode(TreeNode childNode) {
return indexOf(childNode) != -1;
}
/**
* {@inheritDoc}
*/
@Override
public boolean isParent(TreeNode childNode) {
return this.equals(childNode.getParent());
}
/**
* {@inheritDoc}
*/
@Override
public boolean isChildNode(TreeNode parentNode) {
if (parentNode == null) {
return false;
}
return parentNode.hasChildNode(this);
}
/**
* {@inheritDoc}
*/
@Override
public int getChildSize() {
return getChildNodes().size();
}
/**
* {@inheritDoc}
*/
@Override
public void addChildNode(TreeNode childNode) {
readyForAddChild(childNode);
getChildNodes().add(childNode);
}
/**
* {@inheritDoc}
*/
@Override
public void addChildNodes(@SuppressWarnings("unchecked") TreeNode...childNodes) {
if (childNodes == null) {
throw new IllegalArgumentException("传入参数childNodes不能为null");
}
for (TreeNode childNode : childNodes) {
readyForAddChild(childNode);
getChildNodes().add(childNode);
}
}
/**
* {@inheritDoc}
*/
@Override
public void addChildNodes(List> childNodes) {
if (childNodes == null) {
throw new IllegalArgumentException("传入参数childNodes不能为null");
}
for (TreeNode childNode : childNodes) {
readyForAddChild(childNode);
getChildNodes().add(childNode);
}
}
/**
* {@inheritDoc}
*/
@Override
public void insertChildNode(TreeNode childNode, int index) {
int size = getChildNodes().size();
readyForAddChild(childNode);
if (index > -1 && index < size) {
getChildNodes().add(index, childNode);
} else {
getChildNodes().add(childNode);
}
}
/**
* {@inheritDoc}
*/
@Override
public void insertChildNodeBefore(TreeNode childNode, TreeNode refChildNode) {
readyForAddChild(childNode);
int index = indexOf(refChildNode);
insertChildNode(childNode, index);
}
/**
* {@inheritDoc}
*/
@Override
public void insertChildNodeAfter(TreeNode childNode, TreeNode refChildNode) {
readyForAddChild(childNode);
int index = indexOf(refChildNode);
insertChildNode(childNode, index);
}
/**
* {@inheritDoc}
*/
@Override
public void removeChildNode(TreeNode childNode) {
readyForRemoveChild(childNode);
getChildNodes().remove(childNode);
}
/**
* {@inheritDoc}
*/
@Override
public void removeChildNodes() {
Iterator> iter = getChildNodes().iterator();
while (iter.hasNext()) {
readyForRemoveChild(
iter.next());
}
getChildNodes().clear();
}
/**
* {@inheritDoc}
*/
@Override
public void replaceChild(TreeNode newChild, TreeNode oldChild) {
int index = indexOf(oldChild);
if (index != -1) {
removeChildNode(oldChild);
insertChildNode(newChild, index);
}
}
/**
* {@inheritDoc}
*/
@Override
public void mergeChild(TreeNode child) {
int index = indexOf(child);
if (index != -1) {
LOGGER.debug("node[{}].mergeChild(node[{}]) as replace",
this.getId(), child.getId());
removeChildNode(child);
insertChildNode(child, index);
} else {
addChildNode(child);
}
}
/**
* {@inheritDoc}
*/
@Override
public void remove() {
TreeNode parent = this.getParent();
if (parent != null) {
parent.removeChildNode(this);
}
}
/**
* {@inheritDoc}
*/
@Override
public TreeNode getFirstChild() {
if (getChildSize() > 0) {
return getChildNodes().get(0);
}
return null;
}
/**
* {@inheritDoc}
*/
@Override
public TreeNode getLastChild() {
if (getChildSize() > 0) {
return getChildNodes().get(getChildSize() - 1);
}
return null;
}
/**
* {@inheritDoc}
*/
@Override
public TreeNode getNextSibling() {
TreeNode parentNode = getParent();
if (parentNode != null) {
int size = parentNode.getChildSize();
int index = parentNode.indexOf(this);
if (size > 0 && size > index + 1) {
return parentNode.getChildNodes().get(index + 1);
}
}
return null;
}
/**
* {@inheritDoc}
*/
@Override
public TreeNode getPreviousSibling() {
TreeNode parentNode = getParent();
if (parentNode != null) {
int size = parentNode.getChildSize();
int index = parentNode.indexOf(this);
if (size > 0 && index > 0) {
return parentNode.getChildNodes().get(index - 1);
}
}
return null;
}
/**
* {@inheritDoc}
*/
@Override
public boolean isFirst() {
return getPreviousSibling() == null;
}
/**
* {@inheritDoc}
*/
@Override
public boolean isLast() {
return getNextSibling() == null;
}
/**
* {@inheritDoc}
*/
@Override
public void sort(Comparator> comparator) {
Collections.sort(getChildNodes(), comparator);
}
/**
* {@inheritDoc}
*/
@Override
public void sort(Comparator> comparator, boolean containProgeny) {
if (containProgeny) {
if (!this.isLeaf()) {
this.sort(comparator);
Iterator> iter = this.getChildNodes().iterator();
while (iter.hasNext()) {
iter.next().sort(comparator, containProgeny);
}
}
} else {
sort(comparator);
}
}
// ********************************************************************
// 判断关系的方法
// ********************************************************************
// ********************************************************************
// private method
// ********************************************************************
// 在添加儿子节点前的处理
private void readyForAddChild(TreeNode childNode) {
SimpleTreeNode stn = (SimpleTreeNode) childNode;
stn.depth = getDepth() + 1;
// childNode.setParentNode(this);
readyForSetParent(this, false);
}
// 在移除儿子节点前的处理
private void readyForRemoveChild(TreeNode childNode) {
SimpleTreeNode stn = (SimpleTreeNode) childNode;
stn.changeDepth(ROOT_DEPTH);
// childNode.changeDepth(ROOT_DEPTH);
// childNode.setParentNode(null);
readyForSetParent(null, false);
}
// 在设置父节点前的处理
private void readyForSetParent(TreeNode parentNode, boolean autoAppendToParent) {
// 如果当前父节点存在，从当前父节点中移除自己
if (this.parentNode != null) {
this.parentNode.removeChildNode(this);
}
this.parentNode = parentNode;
// 在传入的父节点中添加当前子节点
if (autoAppendToParent) {
parentNode.addChildNode(this);
}
}
// ********************************************************************
// override method
// ********************************************************************
/**
* 返回一个复制的节点，迭代复制所有节点
* @return 复制的节点
*/
@Override
public TreeNode clone() {
SimpleTreeNode node = new SimpleTreeNode(getId());
node.setNodeObject(getNodeObject());
if (!isLeaf()) {
Iterator> iter = getChildNodes().iterator();
while (iter.hasNext()) {
TreeNode cloneChild = ((SimpleTreeNode) iter.next()).clone();
node.addChildNode(cloneChild);
}
}
return node;
}
/**
* {@inheritDoc}
*/
@Override
public TreeNode cloneAsRoot() {
SimpleTreeNode node = (SimpleTreeNode) this.clone();
node.changeDepth(SimpleTreeNode.ROOT_DEPTH);
node.setParentNode(null);
return node;
}
@Override
public boolean equals(Object object) {
if (object == null || !(object instanceof TreeNode)) {
return false;
}
if (LangUtils.isEmpty(this.getId())) {
return false;
}
@SuppressWarnings("unchecked")
TreeNode treeNode = (TreeNode) object;
return this.getId().equals(treeNode.getId());
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public String toString() {
return this.getClass().getName() + "#" + this.getId().toString();
}
// ********************************************************************
// setter and getter
// ********************************************************************
/**
* {@inheritDoc}
*/
@Override
public E getNodeObject() {
return nodeObject;
}
/**
* {@inheritDoc}
*/
@Override
public void setNodeObject(E nodeObject) {
this.nodeObject = nodeObject;
}
/**
* {@inheritDoc}
*/
@Override
public boolean isRoot() {
return getParent() == null;
}
/**
* {@inheritDoc}
*/
@Override
public boolean isLeaf() {
return getChildSize() == 0;
}
/**
* {@inheritDoc}
*/
@Override
public List> getChildNodes() {
return childNodes;
}
/**
* {@inheritDoc}
*/
@Override
public int getDepth() {
return depth;
}
/**
* {@inheritDoc}
*/
@Override
public String getId() {
return id;
}
/**
* {@inheritDoc}
*/
@Override
public TreeNode getParent() {
return parentNode;
}
/**
* 设置parentNode
* @param parentNode parentNode
*/
public void setParentNode(TreeNode parentNode) {
readyForSetParent(parentNode, true);
}
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy