changeset 22:fa784faafc78

commit
author shoshi
date Tue, 07 Jun 2011 16:42:49 +0900
parents f3150b37f9be
children 77a894c0b919
files src/treecms/api/Forest.java src/treecms/api/NodeChildren.java src/treecms/api/NodeContext.java src/treecms/memory/OnMemoryForest.java src/treecms/memory/OnMemoryMonotonicTree.java src/treecms/memory/OnMemoryMonotonicTreeNode.java src/treecms/memory/OnMemoryNode.java src/treecms/tree/util/NodeChildrenImpl.java src/treecms/tree/util/NodeData.java
diffstat 9 files changed, 165 insertions(+), 243 deletions(-) [+]
line wrap: on
line diff
--- a/src/treecms/api/Forest.java	Mon Jun 06 21:49:04 2011 +0900
+++ b/src/treecms/api/Forest.java	Tue Jun 07 16:42:49 2011 +0900
@@ -1,12 +1,6 @@
-package treecms.api;
-
-import treecms.tree.util.NodeData;
+package treecms.api; 
 
 public interface Forest
 {
-	MonotonicTree get(NodeID _id);
-	MonotonicTree getTip(String _uuid);
-	MonotonicTree create();
-	MonotonicTree create(NodeData<Node> _data);
 	MonotonicTree getMainTree();
 }
--- a/src/treecms/api/NodeChildren.java	Mon Jun 06 21:49:04 2011 +0900
+++ b/src/treecms/api/NodeChildren.java	Tue Jun 07 16:42:49 2011 +0900
@@ -3,22 +3,16 @@
 import java.util.List;
 import java.util.Set;
 
-public interface NodeChildren<T extends NodeContext & NodeChildren<T>>
+public interface NodeChildren<T extends NodeContext & NodeAttributes & NodeChildren<T>>
 {
 	public List<T> getList();
-	
-	public boolean add(T _child);
-	public boolean addAll(NodeChildren<T> _list);
+	public T create(NodeAttributes _attr);
 	public Set<String> getFamilyIDSet();
-	
 	public T get(String _uuid);
 	public T get(int _index);
 	public T remove(String _uuid);
 	public T remove(int _index);
-	public T replace(T _new);
-	
 	public boolean contains(NodeID _id);
 	public boolean swap(String _uuid,String _uuid2);
-	
 	public void clearChildren();
 }
--- a/src/treecms/api/NodeContext.java	Mon Jun 06 21:49:04 2011 +0900
+++ b/src/treecms/api/NodeContext.java	Tue Jun 07 16:42:49 2011 +0900
@@ -3,5 +3,4 @@
 public interface NodeContext
 {
 	public NodeID getID();
-	public Forest getForest();
 }
--- a/src/treecms/memory/OnMemoryForest.java	Mon Jun 06 21:49:04 2011 +0900
+++ b/src/treecms/memory/OnMemoryForest.java	Tue Jun 07 16:42:49 2011 +0900
@@ -1,74 +1,25 @@
 package treecms.memory;
 
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
 import treecms.api.Forest;
-import treecms.api.Node;
+import treecms.api.MonotonicTree;
 import treecms.api.NodeID;
-import treecms.api.MonotonicTree;
 import treecms.tree.id.RandomNodeID;
-import treecms.tree.util.NodeData;
 
 public class OnMemoryForest implements Forest
 {
-	private final Map<NodeID,OnMemoryNode> m_table;
-	private final Map<String,OnMemoryNode> m_tipTable;
-	private final OnMemoryMonotonicTree m_mainTree;
+	private final OnMemoryMonotonicTree m_tree;
 	
 	public OnMemoryForest()
 	{
-		m_table = new ConcurrentHashMap<NodeID,OnMemoryNode>();
-		m_tipTable = new ConcurrentHashMap<String,OnMemoryNode>();
-		
-		OnMemoryNode root = (OnMemoryNode)create();
-		m_mainTree = new OnMemoryMonotonicTree(root);
-	}
-	
-	private NodeID createID(String _fid)
-	{
-		return new RandomNodeID(_fid);
-	}
-
-	@Override
-	public MonotonicTree get(NodeID _id)
-	{
-		OnMemoryNode node = m_table.get(_id);
-		return new OnMemoryMonotonicTree(node);
+		NodeID id = new RandomNodeID(null);
+		OnMemoryNode newNode = new OnMemoryNode(id,null);
+		m_tree = OnMemoryMonotonicTree.createInstance(newNode,null);
 	}
 	
 	@Override
-	public MonotonicTree create()
-	{
-		OnMemoryNode node = createNode(createID(null),null);
-		OnMemoryMonotonicTree tree = new OnMemoryMonotonicTree(node);
-		return tree;
-	}
-
-	@Override
-	public MonotonicTree create(NodeData<Node> _data)
-	{
-		OnMemoryNode node = createNode(null,_data);
-		return new OnMemoryMonotonicTree(node);
-	}
-
-	@Override
-	public MonotonicTree getTip(String _fid)
-	{
-		OnMemoryNode node = m_tipTable.get(_fid);
-		return new OnMemoryMonotonicTree(node);
-	}
-
-	@Override
 	public MonotonicTree getMainTree()
 	{
-		return m_mainTree;
-	}
-	
-	public OnMemoryNode createNode(NodeID _newID,NodeData<Node> _newData)
-	{
-		OnMemoryNode newNode = new OnMemoryNode(this,_newID,_newData);
-		m_table.put(newNode.getID(),newNode);
-		m_tipTable.put(newNode.getID().getFamilyID(),newNode);
-		return newNode;
+		// TODO Auto-generated method stub
+		return null;
 	}
 }
--- a/src/treecms/memory/OnMemoryMonotonicTree.java	Mon Jun 06 21:49:04 2011 +0900
+++ b/src/treecms/memory/OnMemoryMonotonicTree.java	Tue Jun 07 16:42:49 2011 +0900
@@ -6,50 +6,64 @@
 import treecms.api.MonotonicTree;
 import treecms.api.MonotonicTreeNode;
 import treecms.api.Node;
+import treecms.api.NodeID;
 import treecms.merger.Merger;
 import treecms.merger.ReplaceMerger;
+import treecms.tree.util.NodeData;
 
 public class OnMemoryMonotonicTree implements MonotonicTree
 {
-	private OnMemoryNode m_old;
+	private final ConcurrentMap<String,OnMemoryNode> m_members;
+	private final OnMemoryMonotonicTree m_tree;
+	
 	private OnMemoryMonotonicTreeNode m_root;
 	
-	private static final Merger<Node> m_merger = new ReplaceMerger<Node>();
-	
-	private final ConcurrentMap<String,OnMemoryMonotonicTreeNode> m_members;
-	private final OnMemoryMonotonicTree m_tree; //Remote Repository
-	
-	public OnMemoryMonotonicTree(OnMemoryNode _root)
+	private OnMemoryMonotonicTree(OnMemoryNode _root,OnMemoryMonotonicTree _tree)
 	{
-		m_tree = null;
-		m_old = _root;
-		m_root = new OnMemoryMonotonicTreeNode((OnMemoryNode)m_old,null);
-		m_members = new ConcurrentHashMap<String,OnMemoryMonotonicTreeNode>();
+		m_members = new ConcurrentHashMap<String,OnMemoryNode>();
+		m_members.put(_root.getID().getFamilyID(),_root);
+		m_tree = _tree;
 	}
 	
-	public OnMemoryMonotonicTree(OnMemoryMonotonicTree _tree)
+	public static OnMemoryMonotonicTree createInstance(OnMemoryNode _root,OnMemoryMonotonicTree _tree)
+	{
+		OnMemoryMonotonicTree tree = new OnMemoryMonotonicTree(_root,_tree);
+		tree.m_root = new OnMemoryMonotonicTreeNode(_root.getID().getFamilyID(),null,tree);
+		return tree;
+	}
+	
+	public OnMemoryNode get(String _fid)
 	{
-		this((OnMemoryNode)_tree.getRoot().getNode());
+		return m_members.get(_fid);
 	}
-
+	
+	public OnMemoryNode createNode(NodeID _id,NodeData<Node> _data)
+	{
+		OnMemoryNode newNode = new OnMemoryNode(_id,_data);
+		m_members.put(_id.getFamilyID(),newNode);
+		return newNode;
+	}
+	
 	@Override
 	public boolean commit(boolean _force)
 	{
+		if(m_tree == null){
+			return true;
+		}
+		
 		return true;
 	}
 
 	@Override
 	public boolean pull()
 	{
-		OnMemoryNode node = (OnMemoryNode)m_tree.getRoot().getNode();
-		OnMemoryMonotonicTreeNode node = new OnMemoryMonotonicTreeNode();
 		return true;
 	}
 
 	@Override
 	public boolean check()
 	{
-		return m_tree.getRoot().getNode().equals(m_old);
+		return m_tree.getRoot().getNode().equals(m_root.getNode());
 	}
 
 	@Override
--- a/src/treecms/memory/OnMemoryMonotonicTreeNode.java	Mon Jun 06 21:49:04 2011 +0900
+++ b/src/treecms/memory/OnMemoryMonotonicTreeNode.java	Tue Jun 07 16:42:49 2011 +0900
@@ -2,11 +2,16 @@
 
 import java.nio.ByteBuffer;
 
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.Callable;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.FutureTask;
 import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
 
 import treecms.api.Forest;
@@ -24,56 +29,57 @@
  */
 public class OnMemoryMonotonicTreeNode implements MonotonicTreeNode
 {
-	private Node m_node;
-	
-	private static final AtomicReferenceFieldUpdater<OnMemoryMonotonicTreeNode,OnMemoryMonotonicTreeNode> m_parentUpdater 
-		= AtomicReferenceFieldUpdater.newUpdater(OnMemoryMonotonicTreeNode.class,OnMemoryMonotonicTreeNode.class,"m_parent");
-	
+	private String m_node;
 	private OnMemoryMonotonicTreeNode m_parent;
+	private final OnMemoryMonotonicTree m_tree;
+	private final ConcurrentMap<String,MonotonicTreeNode> m_cache;
 	
-	private final Map<String,OnMemoryMonotonicTreeNode> m_cache;
-	
-	public OnMemoryMonotonicTreeNode(OnMemoryNode _target,OnMemoryMonotonicTreeNode _parent)
+	public OnMemoryMonotonicTreeNode(String _fid,OnMemoryMonotonicTreeNode _parent,OnMemoryMonotonicTree _tree)
 	{
-		m_node  = _target;
+		m_node = _fid;
 		m_parent = _parent;
-		m_cache = new ConcurrentHashMap<String,OnMemoryMonotonicTreeNode>();
+		m_cache = new ConcurrentHashMap<String,MonotonicTreeNode>();
+		m_tree = _tree;
 	}
 	
 	@Override
 	public NodeID getID()
 	{
-		return m_node.getID();
-	}
-
-	@Override
-	public Forest getForest()
-	{
-		return m_node.getForest();
+		OnMemoryNode n = m_tree.get(m_node);
+		return n.getID();
 	}
 
 	@Override
 	public MonotonicTreeNode getParent()
 	{
-		return m_parent;
+		synchronized(m_parent){
+			OnMemoryNode node = (OnMemoryNode)getNode();
+			
+			//check , does parent contain the node.
+			if(!m_parent.contains(node.getID())){
+				m_parent = null;
+			}
+			return m_parent;
+		}
 	}
 	
 	@Override
 	public ByteBuffer get(ByteBuffer _key)
 	{
-		return m_node.get(_key);
+		return m_tree.get(m_node).get(_key);
 	}
 
 	@Override
 	public NodeAttributes getAll()
 	{
-		return m_node.getAll();
+		return m_tree.get(m_node).getAll();
 	}
 
 	@Override
 	public synchronized void put(ByteBuffer _key, ByteBuffer _value)
 	{
-		NodeData<Node> d = new NodeData<Node>(m_node,m_node);
+		OnMemoryNode n = m_tree.get(m_node);
+		NodeData<Node> d = new NodeData<Node>(n,n);
 		d.put(_key,_value);
 		
 		cloneAndTransmit(d);
@@ -82,7 +88,8 @@
 	@Override
 	public synchronized void putAll(NodeAttributes _map)
 	{
-		NodeData<Node> d = new NodeData<Node>(m_node,m_node);
+		OnMemoryNode n = m_tree.get(m_node);
+		NodeData<Node> d = new NodeData<Node>(n,n);
 		d.putAll(_map);
 		
 		cloneAndTransmit(d);
@@ -91,7 +98,8 @@
 	@Override
 	public synchronized void remove(ByteBuffer _key)
 	{
-		NodeData<Node> d = new NodeData<Node>(m_node,m_node);
+		OnMemoryNode n = m_tree.get(m_node);
+		NodeData<Node> d = new NodeData<Node>(n,n);
 		d.remove(_key);
 		
 		cloneAndTransmit(d);
@@ -100,7 +108,8 @@
 	@Override
 	public synchronized void removeAll(Set<ByteBuffer> _keys)
 	{
-		NodeData<Node> d = new NodeData<Node>(m_node,m_node);
+		OnMemoryNode n = m_tree.get(m_node);
+		NodeData<Node> d = new NodeData<Node>(n,n);
 		d.removeAll(_keys);
 		
 		cloneAndTransmit(d);
@@ -109,7 +118,8 @@
 	@Override
 	public synchronized void clearAttributes()
 	{
-		NodeData<Node> d = new NodeData<Node>(m_node,m_node);
+		OnMemoryNode n = m_tree.get(m_node);
+		NodeData<Node> d = new NodeData<Node>(n,n);
 		d.clearAttributes();
 		
 		cloneAndTransmit(d);
@@ -117,107 +127,82 @@
 	
 	public synchronized void cloneAndTransmit(NodeData<Node> _d)
 	{
-		OnMemoryForest f = (OnMemoryForest)m_node.getForest();
-		Node clone = f.createNode(m_node.getID().update(),_d);
-		transmit(m_node,clone);
-		
-		m_node = clone;
+		OnMemoryNode node = m_tree.get(m_node);
+		Node clone = m_tree.createNode(node.getID().update(),_d);
+		transmit(node,clone);
 	}
 	
-	public synchronized void transmit(Node _orig,Node _edit)
+	public synchronized boolean transmit(Node _orig,Node _edit)
 	{
-		OnMemoryForest f = (OnMemoryForest)m_node.getForest();
-		OnMemoryNode clone = f.createNode(m_node.getID().update(),null);
-		clone.replace(_edit);
+		OnMemoryNode node = m_tree.get(m_node);
 		
-		if(m_parent != null){
-			m_parent.transmit(m_node,(OnMemoryNode)clone);
-			return;
+		NodeData<Node> d = new NodeData<Node>(node,node);
+		if(!d.contains(_edit.getID())){
+			
 		}
-	}
-	
-	private synchronized OnMemoryMonotonicTreeNode getCache(OnMemoryNode _node)
-	{
-		NodeID id = _node.getID();
-		OnMemoryMonotonicTreeNode mono;
-		synchronized(m_cache){
-			mono = m_cache.get(id);
-			if(mono == null){
-				//cache not found . create it
-				mono = new OnMemoryMonotonicTreeNode(_node,this);
-			}
+		d.replace(_edit);
+		
+		OnMemoryNode clone = m_tree.createNode(node.getID().update(),null);
+		
+		
+		OnMemoryMonotonicTreeNode parent = (OnMemoryMonotonicTreeNode)getParent();
+		if(parent != null){
+			return m_parent.transmit(node,clone);
 		}
-		return mono;
+		return true;
 	}
 	
 	@Override
 	public synchronized Node getNode()
 	{
-		return m_node;
+		return m_tree.get(m_node);
 	}
 	
 	@Override
 	public synchronized List<MonotonicTreeNode> getList()
 	{
 		//NodeのリストよりMonotonicTreeNodeのリストを作成する.
-		NodeChildren<MonotonicTreeNode> res = new NodeChildrenImpl<MonotonicTreeNode>();
-		for(Iterator<Node> it = m_node.getList().iterator();it.hasNext();){
+		OnMemoryNode node = m_tree.get(m_node);
+		int size = node.getList().size();
+		ArrayList<MonotonicTreeNode> list = new ArrayList<MonotonicTreeNode>(size);
+		for(Iterator<Node> it = node.getList().iterator();it.hasNext();){
 			OnMemoryNode n = (OnMemoryNode)it.next();
-			res.add(getCache(n));
-		}
-		
-		return res.getList();
-	}
-
-	@Override
-	public synchronized boolean add(MonotonicTreeNode _n)
-	{
-		OnMemoryMonotonicTreeNode mono = (OnMemoryMonotonicTreeNode)_n;
-		NodeData<Node> d = new NodeData<Node>(m_node,m_node);
-		boolean ret = d.add(mono.m_node);
-		if(ret){
-			cloneAndTransmit(d);
+			list.add(getCache(n.getID().getFamilyID()));
 		}
 		
-		return ret;
+		return (List<MonotonicTreeNode>)Collections.unmodifiableCollection(list);
 	}
-
-	@Override
-	public synchronized boolean addAll(NodeChildren<MonotonicTreeNode> _list)
+	
+	public OnMemoryMonotonicTreeNode getCache(final String _fid)
 	{
-		//MotonicTreeNodeのリストからNodeのリストを作成する.
-		NodeChildren<Node> c = new NodeChildrenImpl<Node>();
-		for(Iterator<MonotonicTreeNode> it = _list.getList().iterator();it.hasNext();){
-			OnMemoryMonotonicTreeNode mono = (OnMemoryMonotonicTreeNode)it.next();
-			c.add(mono.m_node);
-		}
+		OnMemoryMonotonicTreeNode cache = new OnMemoryMonotonicTreeNode(m_node,this,m_tree);
+		cache = (OnMemoryMonotonicTreeNode)m_cache.putIfAbsent(_fid,cache);
 		
-		NodeData<Node> d = new NodeData<Node>(m_node,m_node);
-		boolean ret = d.addAll(c);
-		if(ret){
-			cloneAndTransmit(d);
-		}
-		
-		return ret;
+		return cache;
 	}
 
 	@Override
 	public synchronized MonotonicTreeNode remove(int _index)
 	{
-		NodeData<Node> d = new NodeData<Node>(m_node,m_node);
-		OnMemoryNode n = (OnMemoryNode) d.remove(_index);
+		OnMemoryNode n = m_tree.get(m_node);
+		NodeData<Node> d = new NodeData<Node>(n,n);
+		OnMemoryNode deleted = (OnMemoryNode) d.remove(_index);
+		
 		if(n != null){
 			cloneAndTransmit(d);
-			return new OnMemoryMonotonicTreeNode((OnMemoryNode)n,null);
+			
+			OnMemoryMonotonicTreeNode tn = getCache(deleted.getID().getFamilyID());
+			return tn;
 		}
 		
 		return null;
 	}
-
+	
 	@Override
 	public synchronized void clearChildren()
 	{
-		NodeData<Node> d = new NodeData<Node>(m_node,m_node);
+		OnMemoryNode node = m_tree.get(m_node);
+		NodeData<Node> d = new NodeData<Node>(node,node);
 		d.clearChildren();
 		
 		cloneAndTransmit(d);
@@ -226,72 +211,75 @@
 	@Override
 	public Map<ByteBuffer, ByteBuffer> asMap()
 	{
-		return m_node.asMap();
+		OnMemoryNode node = m_tree.get(m_node);
+		return node.asMap();
 	}
 
 	@Override
 	public Set<ByteBuffer> getKeySet()
 	{
-		return m_node.getKeySet();
+		OnMemoryNode node = m_tree.get(m_node);
+		return node.getKeySet();
 	}
 
 	@Override
 	public synchronized MonotonicTreeNode get(int _index)
 	{
-		OnMemoryNode n = (OnMemoryNode) m_node.get(_index);
-		return getCache(n);
-	}
-
-	@Override
-	public synchronized MonotonicTreeNode replace(MonotonicTreeNode _newChild)
-	{
-		OnMemoryMonotonicTreeNode mono = (OnMemoryMonotonicTreeNode)_newChild;
-		NodeData<Node> d = new NodeData<Node>(m_node,m_node);
-		OnMemoryNode n = (OnMemoryNode) d.replace(mono.m_node);
-		
-		if(n != null){
-			cloneAndTransmit(d);
-			return new OnMemoryMonotonicTreeNode(n,null);
-		}
-		
-		return null;
+		OnMemoryNode node = m_tree.get(m_node);
+		return getCache(node.getID().getFamilyID());
 	}
 
 	@Override
 	public boolean contains(NodeID _id)
 	{
-		return m_node.contains(_id);
+		OnMemoryNode node = m_tree.get(m_node);
+		return node.contains(_id);
 	}
 
 	@Override
 	public boolean swap(String _fid1,String _fid2)
 	{
-		return m_node.swap(_fid1,_fid2);
+		OnMemoryNode node = m_tree.get(m_node);
+		return node.swap(_fid1,_fid2);
 	}
 
 	@Override
 	public Set<String> getFamilyIDSet()
 	{
-		return m_node.getFamilyIDSet();
+		OnMemoryNode node = m_tree.get(m_node);
+		return node.getFamilyIDSet();
 	}
 
 	@Override
 	public synchronized MonotonicTreeNode get(String _fid)
 	{
-		OnMemoryNode n = (OnMemoryNode) m_node.get(_fid);
-		OnMemoryMonotonicTreeNode mono = getCache(n);
-		
+		OnMemoryMonotonicTreeNode mono = getCache(_fid);
 		return mono;
 	}
 
 	@Override
 	public synchronized MonotonicTreeNode remove(String _fid)
 	{
-		NodeData<Node> d = new NodeData<Node>(m_node,m_node);
-		OnMemoryNode n = (OnMemoryNode) d.remove(_fid);
+		OnMemoryMonotonicTreeNode tnode = getCache(_fid);
+		OnMemoryNode node = (OnMemoryNode)tnode.getNode();
+		
+		NodeData<Node> d = new NodeData<Node>(node,node);
+		d.remove(_fid);
 		
 		cloneAndTransmit(d);
+		return tnode;
+	}
+
+	@Override
+	public synchronized MonotonicTreeNode create(NodeAttributes _attr)
+	{
+		NodeID newID = getNode().getID().create();
+		OnMemoryNode newNode = new OnMemoryNode(newID,new NodeData<Node>(null,_attr));
 		
-		return new OnMemoryMonotonicTreeNode(n,null);
+		OnMemoryNode thisNode = (OnMemoryNode)getNode();
+		NodeData<Node> d = new NodeData<Node>(thisNode,thisNode);
+		d.add(newNode);
+		
+		return null;
 	}
 }
--- a/src/treecms/memory/OnMemoryNode.java	Mon Jun 06 21:49:04 2011 +0900
+++ b/src/treecms/memory/OnMemoryNode.java	Tue Jun 07 16:42:49 2011 +0900
@@ -4,25 +4,21 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import treecms.api.Forest;
 import treecms.api.Node;
 import treecms.api.NodeAttributes;
-import treecms.api.NodeChildren;
 import treecms.api.NodeID;
 import treecms.tree.util.NodeData;
 
 class OnMemoryNode implements Node
 {
-	private final OnMemoryForest m_forest;
 	private final NodeID m_id;
 	private final NodeData<Node> m_data;
 	
 	private static final String ERR_READONLY = "this is a readonly node.";
 	
-	public OnMemoryNode(OnMemoryForest _forest,NodeID _id,NodeData<Node> _newData)
+	public OnMemoryNode(NodeID _id,NodeData<Node> _newData)
 	{
 		m_id = _id;
-		m_forest = _forest;
 		m_data = new NodeData<Node>(_newData);
 	}
 
@@ -33,12 +29,6 @@
 	}
 
 	@Override
-	public Forest getForest()
-	{
-		return m_forest;
-	}
-
-	@Override
 	public List<Node> getList()
 	{
 		return m_data.getList();
@@ -93,13 +83,7 @@
 	}
 
 	@Override
-	public boolean add(Node _child)
-	{
-		throw new UnsupportedOperationException(ERR_READONLY);
-	}
-
-	@Override
-	public boolean addAll(NodeChildren<Node> _list)
+	public Node create(NodeAttributes _attr)
 	{
 		throw new UnsupportedOperationException(ERR_READONLY);
 	}
@@ -117,12 +101,6 @@
 	}
 
 	@Override
-	public Node replace(Node _new)
-	{
-		throw new UnsupportedOperationException(ERR_READONLY);
-	}
-
-	@Override
 	public boolean swap(String _uuid, String _uuid2)
 	{
 		throw new UnsupportedOperationException(ERR_READONLY);
--- a/src/treecms/tree/util/NodeChildrenImpl.java	Mon Jun 06 21:49:04 2011 +0900
+++ b/src/treecms/tree/util/NodeChildrenImpl.java	Tue Jun 07 16:42:49 2011 +0900
@@ -6,14 +6,17 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.CopyOnWriteArrayList;
+
+import treecms.api.NodeAttributes;
 import treecms.api.NodeChildren;
 import treecms.api.NodeContext;
 import treecms.api.NodeID;
 
-public class NodeChildrenImpl<T extends NodeContext & NodeChildren<T>> implements NodeChildren<T>
+public class NodeChildrenImpl<T extends NodeContext & NodeAttributes & NodeChildren<T>> implements NodeChildren<T>
 {
-	private final Map<String,T> m_map;
+	private final ConcurrentMap<String,T> m_map;
 	private final List<T> m_list;
 	private final List<T> m_readOnlyList;
 	
@@ -54,6 +57,11 @@
 	}
 	
 	@Override
+	public T create(NodeAttributes _attr)
+	{
+		throw new UnsupportedOperationException();
+	}
+	
 	public synchronized T replace(T _node)
 	{
 		String fid = _node.getID().getFamilyID();
@@ -79,7 +87,6 @@
 		return null;
 	}
 	
-	@Override
 	public synchronized boolean add(T _n)
 	{
 		if(!m_map.containsKey(_n.getID().getFamilyID())){
@@ -89,7 +96,6 @@
 		return false;
 	}
 	
-	@Override
 	public synchronized boolean addAll(NodeChildren<T> _list)
 	{
 		if(_list == this){
--- a/src/treecms/tree/util/NodeData.java	Mon Jun 06 21:49:04 2011 +0900
+++ b/src/treecms/tree/util/NodeData.java	Tue Jun 07 16:42:49 2011 +0900
@@ -37,15 +37,9 @@
 	}
 
 	@Override
-	public boolean add(T _child)
+	public T create(NodeAttributes _attrs)
 	{
-		return m_children.add(_child);
-	}
-
-	@Override
-	public boolean addAll(NodeChildren<T> _children)
-	{
-		return m_children.addAll(_children);
+		throw new UnsupportedOperationException();
 	}
 
 	@Override
@@ -59,8 +53,12 @@
 	{
 		return m_children.remove(_uuid);
 	}
+	
+	public void add(T _newChild)
+	{
+		m_children.add(_newChild);
+	}
 
-	@Override
 	public T replace(T _newChild)
 	{
 		return m_children.replace(_newChild);