/*package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl;


import java.util.Iterator;
import fj.data.List;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Children;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.NodeEditorError;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.IterableWrapper;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;

public class DefaultChildren<T extends TreeNode<T>> implements Children<TreeNode<T>>
{
	private final List<TreeNode<T>> children;
	
	public DefaultChildren(List<TreeNode<T>> _children)
	{
		children = _children;
	}
	
	/*
	public Either<Error,DefaultNode> replaceNode(DefaultNode _target,int _pos)
	{
		if(check(_pos)){
			return DefaultEither.newA(OUT_OF_RANGE);
		}
		
		P2<List<DefaultNode>,List<DefaultNode>> split = children.splitAt(_pos);
		List<DefaultNode> head = split._1();
		List<DefaultNode> tail = split._2().tail().cons(_target);
		List<DefaultNode> newList = head.append(tail);
		
		DefaultNode newNode = new DefaultNode(newList,attrs);
		return DefaultEither.newB(newNode);
	}
	
	
	@Override
	public int size()
	{
		return children.length();
	}
	
	/*
	
	public Either<Error,DefaultNode> addNewChildAt(int _pos)
	{
		if(!check(_pos)){
			return DefaultEither.newA(OUT_OF_RANGE);
		}
		
		P2<List<DefaultNode>,List<DefaultNode>> split = children.splitAt(_pos);
		List<DefaultNode> newChildren = split._1().snoc(new DefaultNode()).append(split._2());
		DefaultNode newNode = new DefaultNode(newChildren,attrs);
		
		return DefaultEither.newB(newNode);
	}
	
	public Either<Error,DefaultNode> deleteChildAt(int _pos)
	{
		if(!check(_pos)){
			return DefaultEither.newA(OUT_OF_RANGE);
		}
		
		P2<List<DefaultNode>,List<DefaultNode>> split = children.splitAt(_pos);
		List<DefaultNode> newChildren = split._1().init().append(split._2());
		
		DefaultNode newNode = new DefaultNode(newChildren,attrs);
		
		return DefaultEither.newB(newNode);
	}
	
	
	
	@Override
	public Either<Error,TreeNode<T>> at(int _pos)
	{
		TreeNode<T> target = children.index(_pos);
		if(target == null){
			return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS); // TODO
		}
		TreeNode<T> ret = target;
		
		return DefaultEither.newB(ret);
	}
	
	public List<TreeNode<T>> getChildrenAsRawList()
	{
		return children;
	}

	@Override
	public Iterator<TreeNode<T>> iterator()
	{
		return (new IterableWrapper<TreeNode<T>>(children)).iterator();
	}
}*/