org.unlaxer.util.collection.TreeNodeImpl Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of japanese-address-parser Show documentation
a simplejapanese address parser
The newest version!
package org.unlaxer.util.collection;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Stream;


public class TreeNodeImpl implements TreeNode {
	
	private static final long serialVersionUID = -621543628695213362L;
	
	TreeNode parent;

	public final ID id;
	
	public T object;
	
	public final TreeNodeList children;
	
	public TreeNodeImpl(ID id, T object) {
		this(id,object,null);
	}

	public TreeNodeImpl(ID id, T object , TreeNode parent ) {
		super();
		this.id = id;
		this.parent = parent;
		this.object = object;
		children = new TreeNodeListImpl<>();
	}

	@Override
	public ID id() {
		return id;
	}

	@Override
	public T get() {
		return object;
	}

	@Override
	public boolean isRoot() {
		
		return parent == null;
	}

	@Override
	public boolean isLeaf() {
		return children.isEmpty();
	}

	@Override
	public Optional> parent() {
		return Optional.ofNullable(parent);
	}

	@Override
	public TreeNodeList children() {
		return children;
	}


	@Override
	public void setParent(TreeNode parent) {
		this.parent = parent;
	}

	@Override
	public void addChild(TreeNode child) {
		child.setParent(this);
		this.children.add(child);
	}

	@Override
	public TreeNode copy(TreeNode rootNode) {
		
		TreeNode clone = addChildrenWithClone(
				rootNode , 
				rootNode.parent().orElse(null) , 
				children);

		return clone;
	}

	TreeNode addChildrenWithClone(
			TreeNode target ,
			TreeNode parent , 
			List> children) {
		
		TreeNode clone = new TreeNodeImpl<>(target.id(), target.get() , parent );
		
		for (TreeNode child : children) {
			
			TreeNode copyOfChild = child.copy();
			
			TreeNode newChild = addChildrenWithClone(
					copyOfChild , 
					clone ,
					child.children());
			
			clone.addChild(newChild);
		}
		return clone;
	}

	@Override
	public TreeNodeList leafs() {
		return leafs(new TreeNodeListImpl<>() , this);
	}
	
	TreeNodeList leafs(TreeNodeList leafs,TreeNode target) {
		
		if(target.isLeaf()) {
			leafs.add(target);
			return leafs;
		}
		
		for (TreeNode treeNode : target.children()) {
			leafs = leafs(leafs, treeNode);
		}
		return leafs;
	}

	@Override
	public void addChildren(TreeNodeList children) {
		
		for (TreeNode child : children) {
			
			addChild(child);
		}
	}
	
	@Override
	public Optional> find(ID targetId) {
		Predicate> predicate = treeNode-> treeNode.id().equals(targetId);
		return find(this , predicate);
	}

	@Override
	public Optional> find(Predicate> predicate) {
		return find(this , predicate);
	}
	
	public Optional> find(TreeNode targetTreeNode , Predicate> predicate) {
		
		if(predicate.test(targetTreeNode)) {
			return Optional.of(targetTreeNode);
		}
		
		for (TreeNode childTreeNode : targetTreeNode.children()) {
			
			Optional> find = find(childTreeNode , predicate);
			if(find.isPresent()) {
				return find;
			}
		}
		return Optional.empty();
	}
	
	@Override
	public void resetObject(T object) {
		this.object = object;
	}

	@Override
	public Optional> findWithContent(Predicate predicate) {
		return findWithContent(this , predicate);
	}
	
	public Optional> findWithContent(TreeNode targetTreeNode , Predicate predicate) {
		
		if(predicate.test(targetTreeNode.get())) {
			return Optional.of(targetTreeNode);
		}
		
		for (TreeNode childTreeNode : targetTreeNode.children()) {
			
			Optional> find = findWithContent(childTreeNode , predicate);
			if(find.isPresent()) {
				return find;
			}
		}
		return Optional.empty();
	}

	@Override
	public void addChild(int index, TreeNode child) {
		child.setParent(this);
		this.children.add(index,child);
	}

	@Override
	public  TreeNode transform(Function transfrmer) {
		
		TreeNode clone = addChildrenWithClone(this , null , children , transfrmer);
		return clone;
	}
	
	 TreeNode addChildrenWithClone(
			TreeNode target ,
			TreeNode parent , 

			List> children,
			Function transformer) {
		
		TreeNode clone = new TreeNodeImpl<>(
				target.id(),
				transformer.apply(target.get()),
				parent );
		
		for (TreeNode child : children) {
			
			
			TreeNode newChild = addChildrenWithClone(
					child , 
					clone ,
					child.children(),
					transformer);
			
			clone.addChild(newChild);
		}
		return clone;
	}

	@Override
	public TreeNode root() {
		
		TreeNode current = this;
		while (true) {
			if(current.parent().isEmpty()) {
				return current;
			}
			current = current.parent().get();
		}
	}
	
	@Override
	public Stream> stream(){
		return list().stream();
	}
	
	@Override
	public List> list(){
		
		List> list = new ArrayList<>();
		list(this,list);
		return list;
	}
	
	void list(TreeNode node  , List> list){
		list.add(node);
		for(TreeNode child:node.children()) {
			list(child , list);
		}
	}

	@Override
	public boolean removeChild(ID targetId) {
		
		for(int i = 0 ; i < children.size() ; i++) {
			TreeNode treeNode = children.get(i);
			if(treeNode.id().equals(targetId)) {
				children.remove(i);
				return true;
			}
		}
		return false;
	}

	@Override
	public boolean resetChild(ID targetId, TreeNode newChild) {
		
		for(int i = 0 ; i < children.size() ; i++) {
			TreeNode treeNode = children.get(i);
			if(treeNode.id().equals(targetId)) {
				children.set(i, newChild);
				return true;
			}
		}
		return false;
	}
}