--- 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;
 	}
 }