Mercurial > hg > Members > shoshi > TreeCMSv2

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/treecms/api/NodeTable.java	Thu Jun 09 01:03:48 2011 +0900
@@ -0,0 +1,8 @@
+package treecms.api;
+
+public interface NodeTable
+{
+	public void register(Node _newNode);
+	public Node get(NodeID _id);
+	public Node tip(String _fid);
+}
--- a/src/treecms/memory/OnMemoryForest.java	Tue Jun 07 16:42:49 2011 +0900
+++ b/src/treecms/memory/OnMemoryForest.java	Thu Jun 09 01:03:48 2011 +0900
@@ -13,13 +13,13 @@
 	{
 		NodeID id = new RandomNodeID(null);
 		OnMemoryNode newNode = new OnMemoryNode(id,null);
+
 		m_tree = OnMemoryMonotonicTree.createInstance(newNode,null);
 	}

 	@Override
 	public MonotonicTree getMainTree()
 	{
-		// TODO Auto-generated method stub
-		return null;
+		return m_tree;
 	}
 }
--- a/src/treecms/memory/OnMemoryMonotonicTree.java	Tue Jun 07 16:42:49 2011 +0900
+++ b/src/treecms/memory/OnMemoryMonotonicTree.java	Thu Jun 09 01:03:48 2011 +0900
@@ -1,28 +1,30 @@
 package treecms.memory;
+import java.util.concurrent.ConcurrentHashMap;

-import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;

 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.api.NodeTable;
 import treecms.tree.util.NodeData;
+import treecms.tree.util.NodeTableImpl;

 public class OnMemoryMonotonicTree implements MonotonicTree
 {
-	private final ConcurrentMap<String,OnMemoryNode> m_members;
 	private final OnMemoryMonotonicTree m_tree;
-
-	private OnMemoryMonotonicTreeNode m_root;
+	private final NodeTable m_table;
+	private final OnMemoryMonotonicTreeNode m_root;

 	private OnMemoryMonotonicTree(OnMemoryNode _root,OnMemoryMonotonicTree _tree)
 	{
-		m_members = new ConcurrentHashMap<String,OnMemoryNode>();
-		m_members.put(_root.getID().getFamilyID(),_root);
 		m_tree = _tree;
+		m_table = new NodeTableImpl();
+
+		NodeID id = _root.getID();
+		String fid = id.getFamilyID();
+		m_root = new OnMemoryMonotonicTreeNode(fid,null,m_table);
 	}

 	public static OnMemoryMonotonicTree createInstance(OnMemoryNode _root,OnMemoryMonotonicTree _tree)
@@ -63,6 +65,9 @@
 	@Override
 	public boolean check()
 	{
+		if(m_tree != null){
+
+		}
 		return m_tree.getRoot().getNode().equals(m_root.getNode());
 	}
--- a/src/treecms/memory/OnMemoryMonotonicTreeNode.java	Tue Jun 07 16:42:49 2011 +0900
+++ b/src/treecms/memory/OnMemoryMonotonicTreeNode.java	Thu Jun 09 01:03:48 2011 +0900
@@ -1,57 +1,52 @@
 package treecms.memory;

 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;
 import treecms.api.MonotonicTreeNode;
 import treecms.api.Node;
 import treecms.api.NodeAttributes;
-import treecms.api.NodeChildren;
 import treecms.api.NodeID;
-import treecms.tree.util.NodeChildrenImpl;
+import treecms.api.NodeTable;
 import treecms.tree.util.NodeData;

-/**
- * SingleLinkedなNodeをラップしたDoubleLinkedなNodeの実装です．
- * @author shoshi
- */
 public class OnMemoryMonotonicTreeNode implements MonotonicTreeNode
 {
-	private String m_node;
 	private OnMemoryMonotonicTreeNode m_parent;
-	private final OnMemoryMonotonicTree m_tree;
+	private final NodeTable m_table;
 	private final ConcurrentMap<String,MonotonicTreeNode> m_cache;

-	public OnMemoryMonotonicTreeNode(String _fid,OnMemoryMonotonicTreeNode _parent,OnMemoryMonotonicTree _tree)
+	private final OnMemoryNode m_node;
+
+	public OnMemoryMonotonicTreeNode(OnMemoryNode _node,OnMemoryMonotonicTreeNode _parent,NodeTable _table)
 	{
-		m_node = _fid;
 		m_parent = _parent;
 		m_cache = new ConcurrentHashMap<String,MonotonicTreeNode>();
-		m_tree = _tree;
+		m_table = _table;
+
+		m_node = _node;
 	}

 	@Override
 	public NodeID getID()
 	{
-		OnMemoryNode n = m_tree.get(m_node);
+		OnMemoryNode n = (OnMemoryNode)m_table.tip(m_fid);
 		return n.getID();
 	}

 	@Override
 	public MonotonicTreeNode getParent()
 	{
+		if(m_parent == null){
+			return null;
+		}
+
 		synchronized(m_parent){
 			OnMemoryNode node = (OnMemoryNode)getNode();

@@ -66,19 +61,21 @@
 	@Override
 	public ByteBuffer get(ByteBuffer _key)
 	{
-		return m_tree.get(m_node).get(_key);
+		OnMemoryNode node = (OnMemoryNode)m_table.tip(m_fid);
+		return node.get(_key);
 	}

 	@Override
 	public NodeAttributes getAll()
 	{
-		return m_tree.get(m_node).getAll();
+		OnMemoryNode node = (OnMemoryNode)m_table.tip(m_fid);
+		return node.getAll();
 	}

 	@Override
 	public synchronized void put(ByteBuffer _key, ByteBuffer _value)
 	{
-		OnMemoryNode n = m_tree.get(m_node);
+		OnMemoryNode n = (OnMemoryNode)m_table.tip(m_fid);
 		NodeData<Node> d = new NodeData<Node>(n,n);
 		d.put(_key,_value);

@@ -88,7 +85,7 @@
 	@Override
 	public synchronized void putAll(NodeAttributes _map)
 	{
-		OnMemoryNode n = m_tree.get(m_node);
+		OnMemoryNode n = (OnMemoryNode)m_table.tip(m_fid);
 		NodeData<Node> d = new NodeData<Node>(n,n);
 		d.putAll(_map);

@@ -98,7 +95,7 @@
 	@Override
 	public synchronized void remove(ByteBuffer _key)
 	{
-		OnMemoryNode n = m_tree.get(m_node);
+		OnMemoryNode n = (OnMemoryNode)m_table.tip(m_fid);
 		NodeData<Node> d = new NodeData<Node>(n,n);
 		d.remove(_key);

@@ -108,7 +105,7 @@
 	@Override
 	public synchronized void removeAll(Set<ByteBuffer> _keys)
 	{
-		OnMemoryNode n = m_tree.get(m_node);
+		OnMemoryNode n = (OnMemoryNode)m_table.tip(m_fid);
 		NodeData<Node> d = new NodeData<Node>(n,n);
 		d.removeAll(_keys);

@@ -118,7 +115,7 @@
 	@Override
 	public synchronized void clearAttributes()
 	{
-		OnMemoryNode n = m_tree.get(m_node);
+		OnMemoryNode n = (OnMemoryNode)m_table.tip(m_fid);
 		NodeData<Node> d = new NodeData<Node>(n,n);
 		d.clearAttributes();

@@ -127,22 +124,27 @@

 	public synchronized void cloneAndTransmit(NodeData<Node> _d)
 	{
-		OnMemoryNode node = m_tree.get(m_node);
-		Node clone = m_tree.createNode(node.getID().update(),_d);
-		transmit(node,clone);
+		OnMemoryNode node = (OnMemoryNode)m_table.tip(m_fid);
+		NodeID newID = node.getID().update();
+		Node clone = new OnMemoryNode(newID,_d);
+
+		OnMemoryMonotonicTreeNode parent = (OnMemoryMonotonicTreeNode)getParent();
+		if(parent != null){
+			parent.transmit(node,clone);
+		}
+		m_table.register(clone);
 	}

 	public synchronized boolean transmit(Node _orig,Node _edit)
 	{
-		OnMemoryNode node = m_tree.get(m_node);
+		OnMemoryNode node = (OnMemoryNode)m_table.tip(m_fid);

 		NodeData<Node> d = new NodeData<Node>(node,node);
-		if(!d.contains(_edit.getID())){
-
-		}
 		d.replace(_edit);

-		OnMemoryNode clone = m_tree.createNode(node.getID().update(),null);
+		NodeID newID = node.getID().update();
+		OnMemoryNode clone = new OnMemoryNode(newID,null);
+		m_table.register(_newNode);


 		OnMemoryMonotonicTreeNode parent = (OnMemoryMonotonicTreeNode)getParent();
@@ -155,14 +157,14 @@
 	@Override
 	public synchronized Node getNode()
 	{
-		return m_tree.get(m_node);
+		return m_table.tip(m_fid);
 	}

 	@Override
 	public synchronized List<MonotonicTreeNode> getList()
 	{
 		//NodeのリストよりMonotonicTreeNodeのリストを作成する．
-		OnMemoryNode node = m_tree.get(m_node);
+		OnMemoryNode node = m_table.tip(m_fid);
 		int size = node.getList().size();
 		ArrayList<MonotonicTreeNode> list = new ArrayList<MonotonicTreeNode>(size);
 		for(Iterator<Node> it = node.getList().iterator();it.hasNext();){
@@ -170,13 +172,16 @@
 			list.add(getCache(n.getID().getFamilyID()));
 		}

-		return (List<MonotonicTreeNode>)Collections.unmodifiableCollection(list);
+		return Collections.unmodifiableList(list);
 	}

 	public OnMemoryMonotonicTreeNode getCache(final String _fid)
 	{
-		OnMemoryMonotonicTreeNode cache = new OnMemoryMonotonicTreeNode(m_node,this,m_tree);
-		cache = (OnMemoryMonotonicTreeNode)m_cache.putIfAbsent(_fid,cache);
+		OnMemoryMonotonicTreeNode newCache = new OnMemoryMonotonicTreeNode(m_fid,this,m_table);
+		OnMemoryMonotonicTreeNode cache = (OnMemoryMonotonicTreeNode)m_cache.putIfAbsent(_fid,newCache);
+		if(cache == null){
+			return newCache;
+		}

 		return cache;
 	}
@@ -184,7 +189,7 @@
 	@Override
 	public synchronized MonotonicTreeNode remove(int _index)
 	{
-		OnMemoryNode n = m_tree.get(m_node);
+		OnMemoryNode n = m_table.tip(m_fid);
 		NodeData<Node> d = new NodeData<Node>(n,n);
 		OnMemoryNode deleted = (OnMemoryNode) d.remove(_index);

@@ -201,7 +206,7 @@
 	@Override
 	public synchronized void clearChildren()
 	{
-		OnMemoryNode node = m_tree.get(m_node);
+		OnMemoryNode node = m_table.tip(m_fid);
 		NodeData<Node> d = new NodeData<Node>(node,node);
 		d.clearChildren();

@@ -211,42 +216,42 @@
 	@Override
 	public Map<ByteBuffer, ByteBuffer> asMap()
 	{
-		OnMemoryNode node = m_tree.get(m_node);
+		OnMemoryNode node = m_table.tip(m_fid);
 		return node.asMap();
 	}

 	@Override
 	public Set<ByteBuffer> getKeySet()
 	{
-		OnMemoryNode node = m_tree.get(m_node);
+		OnMemoryNode node = m_table.tip(m_fid);
 		return node.getKeySet();
 	}

 	@Override
 	public synchronized MonotonicTreeNode get(int _index)
 	{
-		OnMemoryNode node = m_tree.get(m_node);
+		OnMemoryNode node = m_table.tip(m_fid);
 		return getCache(node.getID().getFamilyID());
 	}

 	@Override
 	public boolean contains(NodeID _id)
 	{
-		OnMemoryNode node = m_tree.get(m_node);
+		OnMemoryNode node = m_table.tip(m_fid);
 		return node.contains(_id);
 	}

 	@Override
 	public boolean swap(String _fid1,String _fid2)
 	{
-		OnMemoryNode node = m_tree.get(m_node);
+		OnMemoryNode node = m_table.tip(m_fid);
 		return node.swap(_fid1,_fid2);
 	}

 	@Override
 	public Set<String> getFamilyIDSet()
 	{
-		OnMemoryNode node = m_tree.get(m_node);
+		OnMemoryNode node = m_table.tip(m_fid);
 		return node.getFamilyIDSet();
 	}

@@ -274,12 +279,16 @@
 	public synchronized MonotonicTreeNode create(NodeAttributes _attr)
 	{
 		NodeID newID = getNode().getID().create();
-		OnMemoryNode newNode = new OnMemoryNode(newID,new NodeData<Node>(null,_attr));
+		OnMemoryNode newNode = m_table.createNode(newID,new NodeData<Node>(null,_attr));

 		OnMemoryNode thisNode = (OnMemoryNode)getNode();
 		NodeData<Node> d = new NodeData<Node>(thisNode,thisNode);
 		d.add(newNode);

-		return null;
+		cloneAndTransmit(d);
+
+		OnMemoryMonotonicTreeNode tn = getCache(newID.getFamilyID());
+
+		return tn;
 	}
 }
--- a/src/treecms/test/AbstractNodeTest.java	Tue Jun 07 16:42:49 2011 +0900
+++ b/src/treecms/test/AbstractNodeTest.java	Thu Jun 09 01:03:48 2011 +0900
@@ -6,7 +6,6 @@
 import org.junit.Test;
 import treecms.api.NodeChildren;
 import treecms.api.NodeID;
-import treecms.api.SingleNode;
 import treecms.tree.util.NodeChildrenImpl;

 /**
@@ -19,7 +18,7 @@
 	 * テストに用いるNodeを実装者は返す
 	 * @return Node
 	 */
-	public abstract SingleNode getInstance();
+	public abstract Node getInstance();

 	/**
 	 * NodeID取得のテスト
--- a/src/treecms/test/AbstractTreeTest.java	Tue Jun 07 16:42:49 2011 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,33 +0,0 @@
-package treecms.test;
-
-
-import junit.framework.Assert;
-import org.junit.Test;
-import treecms.api.Tree;
-import treecms.api.TreeNode;
-
-/**
- * Tree実装の基本的なテスト
- * @author shoshi
- */
-public abstract class AbstractTreeTest
-{
-	/**
-	 * インスタンスください
-	 * @return Tree
-	 */
-	public abstract Tree getInstance();
-
-	/**
-	 * 木のRootNodeが取得できるか確認する
-	 */
-	@Test
-	public void testGetRoot()
-	{
-		Tree tree = getInstance();
-		TreeNode treeNode = tree.getRoot();
-
-		Assert.assertNotNull(treeNode);
-		Assert.assertNotNull(treeNode.getNode());
-	}
-}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/treecms/tree/util/LockableReference.java	Thu Jun 09 01:03:48 2011 +0900
@@ -0,0 +1,40 @@
+package treecms.tree.util;
+
+import java.util.concurrent.locks.ReentrantLock;
+
+public class LockableReference<V>
+{
+	private volatile V m_ref;
+	private volatile ReentrantLock m_lock;
+
+	public LockableReference(V _ref)
+	{
+		m_ref = _ref;
+		m_lock = new ReentrantLock();
+	}
+
+	public V get()
+	{
+		m_lock.lock();
+		V ref = m_ref;
+		m_lock.unlock();
+		return ref;
+	}
+
+	public void put(V _ref)
+	{
+		m_lock.lock();
+		m_ref = _ref;
+		m_lock.unlock();
+	}
+
+	public void lock()
+	{
+		m_lock.lock();
+	}
+
+	public void unlock()
+	{
+		m_lock.unlock();
+	}
+}
--- a/src/treecms/tree/util/NodeChildrenImpl.java	Tue Jun 07 16:42:49 2011 +0900
+++ b/src/treecms/tree/util/NodeChildrenImpl.java	Thu Jun 09 01:03:48 2011 +0900
@@ -143,6 +143,10 @@
 	public synchronized boolean contains(NodeID _id)
 	{
 		T n = m_map.get(_id);
+		if(n == null){
+			return false;
+		}
+
 		NodeID id = n.getID();
 		return id.equals(_id);
 	}
--- a/src/treecms/tree/util/NodeData.java	Tue Jun 07 16:42:49 2011 +0900
+++ b/src/treecms/tree/util/NodeData.java	Thu Jun 09 01:03:48 2011 +0900
@@ -21,7 +21,7 @@

 	public NodeData(NodeData<T> _newData)
 	{
-		this(_newData.m_children,_newData.m_attrs);
+		this((_newData != null) ? _newData.m_children : null,(_newData != null) ? _newData.m_attrs : null);
 	}

 	public NodeData(NodeChildren<T> _children,NodeAttributes _attrs)
--- a/src/treecms/tree/util/NodeFinder.java	Tue Jun 07 16:42:49 2011 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,85 +0,0 @@
-package treecms.tree.util;
-
-import treecms.api.NodeChildren;
-import treecms.api.NodeContext;
-import treecms.api.NodeID;
-
-public class NodeFinder<T extends NodeContext & NodeChildren<T>>
-{
-	private T m_root;
-	public NodeFinder(T _root)
-	{
-		m_root = _root;
-	}
-
-	public T findByUUID(final String _uuid)
-	{
-		Evaluator<T,T> ev = new Evaluator<T,T>(){
-			private T m_res = null;
-			@Override
-			public boolean evaluate(T _target)
-			{
-				if(_target.getID().getFamilyID().equals(_uuid)){
-					m_res = _target;
-					return true;
-				}
-				return false;
-			}
-			@Override
-			public T getResult()
-			{
-				return m_res;
-			}
-		};
-
-		_recursiveFinder(m_root,ev);
-		return ev.getResult();
-	}
-
-	public T findByNodeID(final NodeID _id)
-	{
-		Evaluator<T,T> ev = new Evaluator<T,T>(){
-			private T m_res = null;
-			@Override
-			public boolean evaluate(T _target)
-			{
-				if(_target.getID().equals(_id)){
-					m_res = _target;
-					return true;
-				}
-				return false;
-			}
-
-			@Override
-			public T getResult()
-			{
-				return m_res;
-			}
-
-		};
-
-		_recursiveFinder(m_root,ev);
-		return ev.getResult();
-	}
-
-	private boolean _recursiveFinder(T _cur,Evaluator<T,?> _e)
-	{
-		if(_e.evaluate(_cur)){
-			return true;
-		}
-
-		for(T child : _cur.getList()){
-			if(_recursiveFinder(child,_e)){
-				return true;
-			}
-		}
-
-		return false;
-	}
-
-	private static interface Evaluator<T,R>
-	{
-		public boolean evaluate(T _target);
-		public R getResult();
-	}
-}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/treecms/tree/util/NodeTableImpl.java	Thu Jun 09 01:03:48 2011 +0900
@@ -0,0 +1,40 @@
+package treecms.tree.util;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import treecms.api.Node;
+import treecms.api.NodeID;
+import treecms.api.NodeTable;
+
+public class NodeTableImpl implements NodeTable
+{
+	private final ConcurrentMap<NodeID,Node> m_nodes;
+	private final ConcurrentMap<String,Node> m_tips;
+
+	public NodeTableImpl()
+	{
+		m_nodes = new ConcurrentHashMap<NodeID,Node>();
+		m_tips = new ConcurrentHashMap<String,Node>();
+	}
+
+	@Override
+	public void register(Node _newNode)
+	{
+		NodeID id = _newNode.getID();
+		m_nodes.put(id,_newNode);
+		m_tips.put(id.getFamilyID(),_newNode);
+	}
+
+	@Override
+	public Node get(NodeID _id)
+	{
+		return m_nodes.get(_id);
+	}
+
+	@Override
+	public Node tip(String _fid)
+	{
+		return m_tips.get(_fid);
+	}
+
+}