changeset 31:190f6a3bdab2

rename some packages
author one
date Mon, 01 Jul 2013 20:34:03 +0900
parents 8593c2525aa7
children 2f1879e0acec
files src/alice/jungle/core/NetworkDefaultJungle.java src/alice/jungle/datasegment/store/operations/DefaultNodeOperationContainer.java src/alice/jungle/datasegment/store/operations/DefaultNodePathContainer.java src/alice/jungle/datasegment/store/operations/DefaultTreeOperationContainer.java src/alice/jungle/datasegment/store/operations/DefaultTreeOperationLogContainer.java src/alice/jungle/operations/NetworkNodeOperation.java src/alice/jungle/operations/NetworkNodePath.java src/alice/jungle/operations/NetworkTreeOperation.java src/alice/jungle/operations/NetworkTreeOperationLog.java src/alice/jungle/transaction/NetworkDefaultJungleTree.java src/alice/jungle/transaction/NetworkDefaultJungleTreeEditor.java src/alice/jungle/transaction/NetworkTransactionManager.java src/jungle/test/codesegment/log/practice/StartCodeSegment.java src/jungle/test/codesegment/log/practice/TestCodeSegment.java src/jungle/test/codesegment/operation/JungleManager.java src/jungle/test/codesegment/operation/StartJungleCodeSegment.java src/jungle/test/codesegment/operation/TestPutAttributeCodeSegment.java src/jungle/test/codesegment/persistence/AliceJournal.java src/jungle/test/core/NetworkDefaultJungle.java src/jungle/test/core/practice/LogReadCodeSegment.java src/jungle/test/core/practice/LogSendTest.java src/jungle/test/datasegment/store/operations/DefaultNodeOperationContainer.java src/jungle/test/datasegment/store/operations/DefaultNodePathContainer.java src/jungle/test/datasegment/store/operations/DefaultTreeOperationContainer.java src/jungle/test/datasegment/store/operations/DefaultTreeOperationLogContainer.java src/jungle/test/operations/NetworkNodeOperation.java src/jungle/test/operations/NetworkNodePath.java src/jungle/test/operations/NetworkTreeOperation.java src/jungle/test/operations/NetworkTreeOperationLog.java src/jungle/test/operations/messagepack/PackOperationLog.java src/jungle/test/transaction/NetworkDefaultJungleTree.java src/jungle/test/transaction/NetworkDefaultJungleTreeEditor.java src/jungle/test/transaction/NetworkTransactionManager.java
diffstat 33 files changed, 937 insertions(+), 933 deletions(-) [+]
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/alice/jungle/core/NetworkDefaultJungle.java	Mon Jul 01 20:34:03 2013 +0900
@@ -0,0 +1,62 @@
+package alice.jungle.core;
+
+import java.util.Iterator;
+import java.util.concurrent.ConcurrentHashMap;
+
+import alice.jungle.transaction.NetworkDefaultJungleTree;
+
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.Jungle;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeList;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.Journal;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.NullJournal;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.ChangeSet;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeEditor;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultChangeSet;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeContext;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNode;
+import jungle.test.codesegment.persistence.AliceJournal;
+import fj.data.List;
+
+public class NetworkDefaultJungle implements Jungle {
+	private Journal journal;
+	private ConcurrentHashMap<String,JungleTree> trees;
+	private String uuid;
+	private TreeEditor editor;
+	
+	public NetworkDefaultJungle(Journal _journal,String _uuid,TreeEditor _editor)
+	{
+//		journal = new AliceJournal();
+		journal = new NullJournal();		
+		trees = new ConcurrentHashMap<String,JungleTree>();
+		uuid = _uuid;
+		editor = _editor;
+	}
+
+	@Override
+	public JungleTree getTreeByName(String _name)
+	{
+		return trees.get(_name);
+	}
+
+	@Override
+	public JungleTree createNewTree(String _name)
+	{
+		ChangeList list = new ChangeList(){
+			@Override
+			public Iterator<TreeOperation> iterator() {
+				List<TreeOperation> nil = List.nil();
+				return nil.iterator();
+			}
+		};
+		DefaultTreeNode root = new DefaultTreeNode();
+		ChangeSet set = new DefaultChangeSet(root.getAsNode(),null,list,uuid,0);
+		DefaultTreeContext<DefaultTreeNode> tc = new DefaultTreeContext<DefaultTreeNode>(root,set);
+		JungleTree newTree = new NetworkDefaultJungleTree<DefaultTreeNode>(tc,uuid,journal.getWriter(),editor);
+		if(trees.putIfAbsent(_name,newTree) != null){
+			return null;
+		}
+		return newTree;
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/alice/jungle/datasegment/store/operations/DefaultNodeOperationContainer.java	Mon Jul 01 20:34:03 2013 +0900
@@ -0,0 +1,81 @@
+package alice.jungle.datasegment.store.operations;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.AppendChildAtOperation;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DeleteAttributeOperation;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DeleteChildAtOperation;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.PutAttributeOperation;
+
+import org.msgpack.MessagePack;
+import org.msgpack.annotation.Message;
+import org.msgpack.template.OrdinalEnumTemplate;
+import org.msgpack.type.Value;
+
+@Message
+public class DefaultNodeOperationContainer {
+
+	public int pos;
+	public String key;
+	public Value value;
+	public Value commandValue;
+	
+	public static void main(String[] args) throws IOException {
+		String key = "hoge";
+		ByteBuffer b = ByteBuffer.wrap("messagepack value".getBytes());
+		PutAttributeOperation op = new PutAttributeOperation(key, b);
+		DefaultNodeOperationContainer container = new DefaultNodeOperationContainer();
+		container.unconvert(op);
+		NodeOperation convertedOp = container.convert(); 
+		System.out.println("pos : "+convertedOp.getPosition());
+		System.out.println("Command : "+convertedOp.getCommand());
+		System.out.println("key : "+convertedOp.getKey());
+		System.out.println("value : "+new String(convertedOp.getValue().array()));
+		
+	}
+	
+	public DefaultNodeOperationContainer() {
+		
+	}
+
+	public void unconvert(NodeOperation op) throws IOException {
+		MessagePack msgpack = new MessagePack();
+		pos = op.getPosition();
+		key = op.getKey();
+		value = null;
+		if (op.getValue() != null) {
+			ByteBuffer b = op.getValue();
+			byte[] bytes = b.array();
+			Value v = msgpack.unconvert(bytes);
+			value = v;
+		}
+		Command c = op.getCommand();
+		msgpack.register(Command.class, new OrdinalEnumTemplate(Command.class));
+		Value cValue = msgpack.unconvert(c);
+		commandValue = cValue;
+	}
+	
+	public NodeOperation convert() throws IOException{
+		MessagePack msgpack = new MessagePack();
+		msgpack.register(Command.class, new OrdinalEnumTemplate(Command.class));
+		Command c = msgpack.convert(commandValue, Command.class);
+		ByteBuffer b = null;
+		if (value != null) {
+			b = ByteBuffer.wrap(msgpack.convert(value, byte[].class));
+		}
+		if (c == Command.PUT_ATTRIBUTE) {
+			return new PutAttributeOperation(key, b);
+		} else if (c == Command.APPEND_CHILD) {
+			return new AppendChildAtOperation(pos);
+		} else if (c == Command.DELETE_CHILD) {
+			return new DeleteChildAtOperation(pos);
+		} else if (c == Command.DELETE_ATTRIBUTE){
+			return new DeleteAttributeOperation(key);
+		}
+		return null;
+	}
+	
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/alice/jungle/datasegment/store/operations/DefaultNodePathContainer.java	Mon Jul 01 20:34:03 2013 +0900
@@ -0,0 +1,59 @@
+package alice.jungle.datasegment.store.operations;
+
+import java.io.IOException;
+import java.util.LinkedList;
+import java.util.List;
+
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
+
+import org.msgpack.MessagePack;
+import org.msgpack.annotation.Message;
+import org.msgpack.template.IntegerTemplate;
+import org.msgpack.template.ListTemplate;
+import org.msgpack.type.Value;
+
+@Message
+public class DefaultNodePathContainer {
+
+	public Value pathValue;
+	
+	public static void main(String[] args) throws IOException {
+		DefaultNodePath p = new DefaultNodePath();
+		p = p.add(1).add(2).add(3);
+		DefaultNodePathContainer pathContainer = new DefaultNodePathContainer();
+		pathContainer.unconvert(p);
+		NodePath convertedPath = pathContainer.convert();
+		for (int i : convertedPath) {
+			System.out.println(i);
+		}
+	}
+	
+	public DefaultNodePathContainer() {
+		
+	}
+	
+	public void unconvert(NodePath path) throws IOException {
+		MessagePack msgpack = new MessagePack();
+		List<Integer> list = new LinkedList<Integer>();
+		for(Integer i : path) {
+			list.add(i);
+		}
+		/* Remove first Element(-1). */
+		list.remove(0);
+		msgpack.register(List.class, new ListTemplate(IntegerTemplate.getInstance()));
+		Value v = msgpack.unconvert(list);
+		pathValue = v;
+	}
+	
+	public DefaultNodePath convert() throws IOException {
+		MessagePack msgpack = new MessagePack();
+		msgpack.register(List.class, new ListTemplate(IntegerTemplate.getInstance()));
+		List<Integer> convertedList = (List<Integer>)msgpack.convert(pathValue, List.class);
+		DefaultNodePath path = new DefaultNodePath();
+		for (int i: convertedList) {
+			path = path.add(i);
+		}
+		return path;
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/alice/jungle/datasegment/store/operations/DefaultTreeOperationContainer.java	Mon Jul 01 20:34:03 2013 +0900
@@ -0,0 +1,96 @@
+package alice.jungle.datasegment.store.operations;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DefaultTreeOperation;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.PutAttributeOperation;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
+
+import org.msgpack.MessagePack;
+import org.msgpack.annotation.Message;
+import org.msgpack.type.Value;
+
+@Message
+public class DefaultTreeOperationContainer {
+
+	Value pathValue;
+	Value opValue;
+
+	public static void main(String[] args) throws IOException {
+		String key = "hoge";
+		ByteBuffer b = ByteBuffer.wrap("messagepack value".getBytes());
+		PutAttributeOperation op = new PutAttributeOperation(key, b);
+
+		DefaultNodePath p = new DefaultNodePath();
+		p = p.add(1).add(2).add(3);
+		DefaultTreeOperation treeOp = new DefaultTreeOperation(p, op);
+		
+		DefaultTreeOperationContainer treeOperationContainer = new DefaultTreeOperationContainer();
+		treeOperationContainer.unconvert(treeOp);
+
+		TreeOperation treeOperation = treeOperationContainer.convert();
+		NodePath nodePath = treeOperation.getNodePath();
+		NodeOperation nodeOp = treeOperation.getNodeOperation();
+		Command c = nodeOp.getCommand();
+		String str = "";
+		switch (c) {
+		case PUT_ATTRIBUTE:
+			String k = nodeOp.getKey();
+			ByteBuffer value = nodeOp.getValue();
+			if (value.limit() < 100) {
+				str = String.format("key:%s,value:%s", k,
+						new String(value.array()));
+			} else {
+				str = String.format("key:%s,value:%d", k, value.limit());
+			}
+			break;
+		case DELETE_ATTRIBUTE:
+			str = String.format("key:%s", nodeOp.getKey());
+			break;
+		case APPEND_CHILD:
+			str = String.format("pos:%d", nodeOp.getPosition());
+			break;
+		case DELETE_CHILD:
+			str = String.format("pos:%d", nodeOp.getPosition());
+			break;
+		}
+		System.out.println(String.format("[%s:%s:%s]", c, nodePath, str));
+		for (int i: nodePath ) {
+			System.out.println(i);
+		}
+	}
+
+	public DefaultTreeOperationContainer() {
+
+	}
+	
+	public void unconvert(DefaultTreeOperation _op) throws IOException {
+		NodeOperation nodeOp = _op.getNodeOperation();
+		NodePath nodePath = _op.getNodePath();
+		DefaultNodeOperationContainer opContainer = new DefaultNodeOperationContainer();
+		opContainer.unconvert(nodeOp);
+		DefaultNodePathContainer pathContainer = new DefaultNodePathContainer();
+		pathContainer.unconvert(nodePath);
+		unconvert(opContainer, pathContainer);
+	}
+
+	public void unconvert(DefaultNodeOperationContainer _op,
+			DefaultNodePathContainer _path) throws IOException {
+		MessagePack msgpack = new MessagePack();
+		pathValue = msgpack.unconvert(_path);
+		opValue = msgpack.unconvert(_op);
+	}
+
+	public TreeOperation convert() throws IOException {
+		MessagePack msgpack = new MessagePack();
+		DefaultNodePathContainer pathContainer = msgpack.convert(pathValue, DefaultNodePathContainer.class);
+		DefaultNodeOperationContainer opContainer = msgpack.convert(opValue, DefaultNodeOperationContainer.class);
+		return new DefaultTreeOperation(pathContainer.convert(), opContainer.convert());
+	}
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/alice/jungle/datasegment/store/operations/DefaultTreeOperationLogContainer.java	Mon Jul 01 20:34:03 2013 +0900
@@ -0,0 +1,124 @@
+package alice.jungle.datasegment.store.operations;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.LinkedList;
+import java.util.List;
+
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.DefaultTreeOperationLog;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DefaultTreeOperation;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.PutAttributeOperation;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
+
+import org.msgpack.MessagePack;
+import org.msgpack.annotation.Message;
+import org.msgpack.template.ListTemplate;
+import org.msgpack.template.ValueTemplate;
+import org.msgpack.type.Value;
+
+@Message
+public class DefaultTreeOperationLogContainer {
+
+	Value logValue;
+	
+	public static void main(String[] args) throws IOException {
+		String key = "hoge";
+		ByteBuffer b = ByteBuffer.wrap("messagepack value".getBytes());
+		PutAttributeOperation putOp = new PutAttributeOperation(key, b);
+		DefaultNodePath nodePath = new DefaultNodePath();
+		nodePath = nodePath.add(1).add(2).add(3);
+		TreeOperation op = new DefaultTreeOperation(nodePath, putOp);
+		List<TreeOperation> list = new LinkedList<TreeOperation>();
+		list.add(op);
+		list.add(op);
+		list.add(op);
+		DefaultTreeOperationLog log = new DefaultTreeOperationLog(list, list.size());
+		
+		DefaultTreeOperationLogContainer logContainer = new DefaultTreeOperationLogContainer();
+		logContainer.unconvert(log);
+
+		MessagePack msgpack = new MessagePack();
+		Value logContainerValue = msgpack.unconvert(logContainer);
+		DefaultTreeOperationLogContainer convertedLogContainer = msgpack.convert(logContainerValue,
+																	DefaultTreeOperationLogContainer.class);
+		
+		TreeOperationLog convertedLog = convertedLogContainer.convert();
+		for (TreeOperation treeOp : convertedLog) {
+			NodePath path = treeOp.getNodePath();
+			NodeOperation nodeOp = treeOp.getNodeOperation();
+			Command c = nodeOp.getCommand();
+			String str = "";
+			switch (c) {
+			case PUT_ATTRIBUTE:
+				String k = nodeOp.getKey();
+				ByteBuffer value = nodeOp.getValue();
+				if (value.limit() < 100) {
+					str = String.format("key:%s,value:%s", k,
+							new String(value.array()));
+				} else {
+					str = String.format("key:%s,value:%d", k, value.limit());
+				}
+				break;
+			case DELETE_ATTRIBUTE:
+				str = String.format("key:%s", nodeOp.getKey());
+				break;
+			case APPEND_CHILD:
+				str = String.format("pos:%d", nodeOp.getPosition());
+				break;
+			case DELETE_CHILD:
+				str = String.format("pos:%d", nodeOp.getPosition());
+				break;
+			}
+			System.out.println(String.format("[%s:%s:%s]", c, path, str));
+			for (int i: path ) {
+				System.out.println(i);
+			}
+			
+		}
+		
+		
+	}
+	
+	public DefaultTreeOperationLogContainer() {
+		
+	}
+	
+	public void unconvert(TreeOperationLog _log) throws IOException {
+		MessagePack msgpack = new MessagePack();
+		List<Value> list = new LinkedList<Value>();
+		for(TreeOperation op : _log) {
+			NodeOperation nOp = op.getNodeOperation();
+			NodePath nodePath = op.getNodePath();
+			DefaultTreeOperation treeOp = new DefaultTreeOperation(nodePath, nOp);
+			DefaultTreeOperationContainer container = new DefaultTreeOperationContainer();
+			container.unconvert(treeOp);
+			Value v = msgpack.unconvert(container);
+			list.add(v);
+		}
+		/* */
+		msgpack.register(List.class, new ListTemplate(ValueTemplate.getInstance()));
+		Value listValue = msgpack.unconvert(list);
+		logValue = listValue;
+	}
+	
+	public DefaultTreeOperationLog convert() throws IOException {
+		MessagePack msgpack = new MessagePack();
+		msgpack.register(List.class, new ListTemplate(ValueTemplate.getInstance()));
+		List<Value> listValue = msgpack.convert(logValue, List.class);
+		List<TreeOperation> logList = new LinkedList<TreeOperation>();
+		for(Value v: listValue) {
+			DefaultTreeOperationContainer container = msgpack.convert(v, DefaultTreeOperationContainer.class);
+			logList.add(container.convert());
+		}
+		DefaultTreeOperationLog log = new DefaultTreeOperationLog(logList, logList.size());
+		return log;
+	}
+	
+	
+	
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/alice/jungle/operations/NetworkNodeOperation.java	Mon Jul 01 20:34:03 2013 +0900
@@ -0,0 +1,47 @@
+package alice.jungle.operations;
+
+import java.nio.ByteBuffer;
+
+import org.msgpack.annotation.Message;
+
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.EditableNode;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
+
+@Message
+public class NetworkNodeOperation implements NodeOperation {
+
+	@Override
+	public Command getCommand() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public String getKey() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public int getPosition() {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	@Override
+	public ByteBuffer getValue() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public <T extends EditableNode<T>> Either<Error, T> invoke(T arg0) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+	
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/alice/jungle/operations/NetworkNodePath.java	Mon Jul 01 20:34:03 2013 +0900
@@ -0,0 +1,59 @@
+package alice.jungle.operations;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
+
+public class NetworkNodePath implements NodePath
+{
+	LinkedList<Integer> path;
+	
+	public NetworkNodePath() {
+		path = new LinkedList<Integer>();
+	}
+	
+	private NetworkNodePath(LinkedList<Integer> _path) {
+		path = _path;
+	}
+	
+	@Override
+	public Iterator<Integer> iterator() {
+		return path.iterator();
+	}
+
+	@Override
+	public NetworkNodePath add(int _pos) {
+		LinkedList<Integer> newPath = copyPath();
+		newPath.add(_pos);
+		return new NetworkNodePath(newPath);
+	}
+
+	@Override
+	public Pair<Integer, NodePath> pop() {
+		LinkedList<Integer> cPath = copyPath();
+		int e = cPath.getFirst();
+		cPath.remove();
+		return new Pair<Integer, NodePath>(e, new NetworkNodePath(cPath));
+	}
+
+	@Override
+	public int size() {
+		return path.size();
+	}
+
+	private LinkedList<Integer> copyPath() {
+		LinkedList<Integer> newPath = new LinkedList<Integer>();
+		for (Integer i : path) {
+			newPath.add(i);
+		}
+		return newPath;
+	}
+	
+	@Override
+	public String toString() {
+		return path.toString();
+	}
+	
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/alice/jungle/operations/NetworkTreeOperation.java	Mon Jul 01 20:34:03 2013 +0900
@@ -0,0 +1,35 @@
+package alice.jungle.operations;
+
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
+
+import org.msgpack.annotation.Message;
+
+@Message
+public class NetworkTreeOperation implements TreeOperation {
+
+	public NodePath path;
+	public NodeOperation operation;
+	
+	public NetworkTreeOperation() {
+		path = null;
+		operation = null;
+	}
+	
+	public NetworkTreeOperation(NodePath _p, NodeOperation _op) {
+		path = _p;
+		operation = _op;
+	}
+
+	@Override
+	public NodePath getNodePath() {
+		return path;
+	}
+	
+	@Override
+	public NodeOperation getNodeOperation() {
+		return operation;
+	}
+	
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/alice/jungle/operations/NetworkTreeOperationLog.java	Mon Jul 01 20:34:03 2013 +0900
@@ -0,0 +1,72 @@
+package alice.jungle.operations;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+
+import org.msgpack.annotation.Message;
+
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
+
+@Message
+public class NetworkTreeOperationLog implements TreeOperationLog
+{
+	public Iterable<TreeOperation> list;
+	public int size;
+	
+	public NetworkTreeOperationLog() {
+		list = new LinkedList<TreeOperation>();
+		size = 0;
+	}
+	
+	public NetworkTreeOperationLog(Iterable<TreeOperation> _list, int _size)
+	{
+		list = _list;
+		size = _size;
+	}
+	
+	public Iterable<TreeOperation> getOperationLogList() {
+		return list;
+	}
+	
+	@Override
+	public Iterator<TreeOperation> iterator() {
+		return list.iterator();
+	}
+
+	@Override
+	public NetworkTreeOperationLog add(NodePath _p, NodeOperation _op) 
+	{
+		TreeOperation op = new NetworkTreeOperation(_p, _op);
+		LinkedList<TreeOperation> newList = new LinkedList<TreeOperation>();
+		for (Iterator<TreeOperation> iter = list.iterator(); iter.hasNext();) {
+			TreeOperation o = iter.next();
+			newList.add(o);
+		}
+		newList.add(op);
+		return new NetworkTreeOperationLog(newList, size+1);
+	}
+
+	@Override
+	public NetworkTreeOperationLog append(TreeOperationLog _log) 
+	{
+		LinkedList<TreeOperation> newList = new LinkedList<TreeOperation>();
+		for (Iterator<TreeOperation> iter = list.iterator(); iter.hasNext();) {
+			TreeOperation o = iter.next();
+			newList.add(o);
+		}
+		for (TreeOperation o : _log) {
+			newList.add(o);
+		}
+		return new NetworkTreeOperationLog(newList, size+_log.length());
+	}
+
+	@Override
+	public int length() 
+	{
+		return size;
+	}
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/alice/jungle/transaction/NetworkDefaultJungleTree.java	Mon Jul 01 20:34:03 2013 +0900
@@ -0,0 +1,44 @@
+package alice.jungle.transaction;
+
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Node;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeListWriter;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.ChangeSet;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeEditor;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.AtomicReservableReference;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTransactionManager;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.TreeContext;
+
+public class NetworkDefaultJungleTree<T extends TreeNode<T>> implements JungleTree {
+	private final AtomicReservableReference<TreeContext<T>> repository;
+	private final String uuid;
+	private final ChangeListWriter writer;
+	private final TreeEditor editor;
+	
+	public NetworkDefaultJungleTree(TreeContext<T> _tc,String _uuid,ChangeListWriter _writer,TreeEditor _editor)
+	{
+		repository = new AtomicReservableReference<TreeContext<T>>(_tc);
+		uuid = _uuid;
+		writer = _writer;
+		editor = _editor;
+	}
+
+	@Override
+	public JungleTreeEditor getTreeEditor()
+	{
+		TreeContext<T> tc = repository.get();
+		DefaultTransactionManager<T> txManager = new DefaultTransactionManager<T>(writer,tc,repository,uuid);
+		T root = tc.getTreeNode();
+		return new NetworkDefaultJungleTreeEditor<T>(root,txManager,editor);
+	}
+
+	@Override
+	public Node getRootNode()
+	{
+		TreeContext<T> tc = repository.get();
+		ChangeSet cs = tc.getChangeSet();
+		return cs.getRoot();
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/alice/jungle/transaction/NetworkDefaultJungleTreeEditor.java	Mon Jul 01 20:34:03 2013 +0900
@@ -0,0 +1,151 @@
+package alice.jungle.transaction;
+
+import java.nio.ByteBuffer;
+
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Node;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeEditor;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.DefaultTreeOperationLog;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNodeHook;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.OperationLog;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DefaultTreeOperation;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.AppendChildAt;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.DeleteAttribute;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.DeleteChildAt;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.NodeEditor;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.PutAttribute;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultJungleTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.TransactionManager;
+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.Error;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.IterableConverter;
+
+public class NetworkDefaultJungleTreeEditor<T extends TreeNode<T>> implements JungleTreeEditor {
+
+	private final TransactionManager<T> txManager;
+	private final T root;
+	private final TreeEditor editor;
+	private final TreeOperationLog log;
+
+	public NetworkDefaultJungleTreeEditor(T _root,TransactionManager<T> _txManager,TreeEditor _editor)
+	{
+		this(_root,_txManager,_editor,new DefaultTreeOperationLog());
+	}
+	
+	public NetworkDefaultJungleTreeEditor(T _root,TransactionManager<T> _txManager,TreeEditor _editor,TreeOperationLog _log)
+	{
+		root = _root;
+		txManager = _txManager;
+		editor = _editor;
+		log = _log;
+	}
+	
+	private Either<Error,JungleTreeEditor> _edit(final NodePath _path,NodeEditor _e)
+	{
+		LoggingNodeHook hook = new LoggingNodeHook(_e);
+		Either<Error,T> either = editor.edit(root,_path,hook);
+		if(either.isA()){
+			return DefaultEither.newA(either.a());
+		}
+		
+		T newNode = either.b();
+		OperationLog newLog = hook.getLog();
+		
+		IterableConverter.Converter<TreeOperation,NodeOperation> converter = new IterableConverter.Converter<TreeOperation,NodeOperation>(){
+			@Override
+			public TreeOperation conv(NodeOperation _b){
+				return new DefaultTreeOperation(_path,_b);
+			}
+		};
+		
+		Iterable<TreeOperation> iterable = new IterableConverter<TreeOperation,NodeOperation>(newLog,converter);
+		DefaultTreeOperationLog treeOperationLog = new DefaultTreeOperationLog(iterable,newLog.length());
+		TreeOperationLog newTreeOpLog = log.append(treeOperationLog);
+		
+		JungleTreeEditor newEditor = new NetworkDefaultJungleTreeEditor<T>(newNode,txManager,editor,newTreeOpLog);
+		return DefaultEither.newB(newEditor);
+	}
+	
+	@Override
+	public Either<Error,JungleTreeEditor> addNewChildAt(NodePath _path, int _pos)
+	{
+		AppendChildAt appendChildAt = new AppendChildAt(_pos);
+		return _edit(_path,appendChildAt);
+	}
+
+	@Override
+	public Either<Error,JungleTreeEditor> deleteChildAt(NodePath _path, int _pos)
+	{
+		DeleteChildAt deleteChildAt = new DeleteChildAt(_pos);
+		return _edit(_path,deleteChildAt);
+	}
+
+	@Override
+	public Either<Error,JungleTreeEditor> putAttribute(NodePath _path,String _key,ByteBuffer _value)
+	{
+		PutAttribute putAttribute = new PutAttribute(_key,_value);
+		return _edit(_path,putAttribute);
+	}
+
+	@Override
+	public Either<Error,JungleTreeEditor> deleteAttribute(NodePath _path, String _key)
+	{
+		DeleteAttribute deleteAttribute = new DeleteAttribute(_key);
+		return _edit(_path,deleteAttribute);
+	}
+
+	@Override
+	public Either<Error,JungleTreeEditor> edit(NodePath _path,NodeEditor _editor)
+	{
+		return _edit(_path,_editor);
+	}
+
+	@Override
+	public Either<Error,JungleTreeEditor> success()
+	{
+		Either<Error,TransactionManager<T>> either = txManager.commit(root,log);
+		if(either.isA()){
+			return DefaultEither.newA(either.a());
+		}
+		
+		TransactionManager<T> newTxManager = either.b();
+		JungleTreeEditor newTreeEditor = new NetworkDefaultJungleTreeEditor<T>(root,newTxManager,editor);
+		
+		return DefaultEither.newB(newTreeEditor);
+	}
+
+	@Override
+	public String getID()
+	{
+		return txManager.getUUID();
+	}
+
+	@Override
+	public String getRevision()
+	{
+		return Long.toString(txManager.getRevision());
+	}
+
+	@Override
+	public Node getRoot()
+	{
+		return null;
+	}
+	
+	public JungleTreeEditor setNewLogAndGetEditor(TreeOperationLog _log) {
+		JungleTreeEditor newEditor = new NetworkDefaultJungleTreeEditor<T>(root,txManager,editor, _log);
+		return newEditor;
+	}
+	
+	public TreeOperationLog getTreeOperationLog() {
+		return log;
+	}
+
+	
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/alice/jungle/transaction/NetworkTransactionManager.java	Mon Jul 01 20:34:03 2013 +0900
@@ -0,0 +1,87 @@
+package alice.jungle.transaction;
+
+import java.util.Iterator;
+
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Node;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeList;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeListWriter;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.Result;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.ChangeSet;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.AtomicReservableReference;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.AtomicReservableReference.Reservation;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultChangeSet;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeContext;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.TransactionManager;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.TreeContext;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultError;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
+
+public class NetworkTransactionManager<T extends TreeNode<T>> implements TransactionManager<T> 
+{
+
+	private final AtomicReservableReference<TreeContext<T>> repository;
+	private final TreeContext<T> tip;
+	private final ChangeListWriter writer;
+	private final String uuid;	
+	private final String treeName;	
+	
+	public NetworkTransactionManager(ChangeListWriter _writer,TreeContext<T> _tip,
+			AtomicReservableReference<TreeContext<T>> _repository,String _uuid, String _treeName)
+	{
+		repository = _repository;
+		tip = _tip;
+		writer = _writer;
+		uuid = _uuid;
+		treeName = _treeName;
+	}
+	
+	@Override
+	public Either<Error, TransactionManager<T>> commit(T _newRoot,final TreeOperationLog _log) {
+		ChangeSet cs = tip.getChangeSet();
+		long currentRevision = cs.revision();
+		long nextRevision = currentRevision + 1;
+		
+		ChangeList list = new ChangeList() {
+			@Override
+			public Iterator<TreeOperation> iterator(){
+				return _log.iterator();
+			}
+		};
+		
+		Node root = _newRoot.getAsNode();
+		DefaultChangeSet newCs = new DefaultChangeSet(root, cs, list, uuid, nextRevision);
+		DefaultTreeContext<T> newContext = new DefaultTreeContext<T>(_newRoot,newCs);
+		
+		@SuppressWarnings("rawtypes")
+		Reservation reservation = repository.makeReservation(tip, newContext);
+		if(reservation == null) {
+			return DefaultEither.newA((Error)new DefaultError());
+		}
+		Result r = writer.write(list);
+		if(r == Result.SUCCESS){
+			reservation.confirm();
+			TransactionManager<T> txManager = new NetworkTransactionManager<T>(writer, newContext, repository, uuid, treeName);
+			return DefaultEither.newB(txManager);
+		}
+
+		return DefaultEither.newA((Error)new DefaultError());
+	}
+
+	@Override
+	public long getRevision() 
+	{
+		ChangeSet cs = tip.getChangeSet();
+		return cs.revision();
+	}
+
+	@Override
+	public String getUUID() {
+		return uuid;
+	}
+
+}
--- a/src/jungle/test/codesegment/log/practice/StartCodeSegment.java	Mon Jul 01 20:31:29 2013 +0900
+++ b/src/jungle/test/codesegment/log/practice/StartCodeSegment.java	Mon Jul 01 20:34:03 2013 +0900
@@ -13,8 +13,8 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DeleteChildAtOperation;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.PutAttributeOperation;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
-import jungle.test.datasegment.store.operations.DefaultTreeOperationLogContainer;
 import alice.codesegment.CodeSegment;
+import alice.jungle.datasegment.store.operations.DefaultTreeOperationLogContainer;
 
 public class StartCodeSegment extends CodeSegment {
 
--- a/src/jungle/test/codesegment/log/practice/TestCodeSegment.java	Mon Jul 01 20:31:29 2013 +0900
+++ b/src/jungle/test/codesegment/log/practice/TestCodeSegment.java	Mon Jul 01 20:34:03 2013 +0900
@@ -19,12 +19,12 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import jungle.test.core.NetworkDefaultJungle;
-import jungle.test.datasegment.store.operations.DefaultTreeOperationLogContainer;
-import jungle.test.transaction.NetworkDefaultJungleTreeEditor;
 import alice.codesegment.CodeSegment;
 import alice.datasegment.CommandType;
 import alice.datasegment.Receiver;
+import alice.jungle.core.NetworkDefaultJungle;
+import alice.jungle.datasegment.store.operations.DefaultTreeOperationLogContainer;
+import alice.jungle.transaction.NetworkDefaultJungleTreeEditor;
 import alice.test.topology.aquarium.FishPoint;
 
 import org.msgpack.MessagePack;
--- a/src/jungle/test/codesegment/operation/JungleManager.java	Mon Jul 01 20:31:29 2013 +0900
+++ b/src/jungle/test/codesegment/operation/JungleManager.java	Mon Jul 01 20:34:03 2013 +0900
@@ -1,11 +1,11 @@
 package jungle.test.codesegment.operation;
 
+import alice.jungle.core.NetworkDefaultJungle;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungle;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.Jungle;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser;
-import jungle.test.core.NetworkDefaultJungle;
 
 public class JungleManager {
 	static Jungle jungle = new NetworkDefaultJungle(null,"hoge",new DefaultTreeEditor(new DefaultTraverser()));
--- a/src/jungle/test/codesegment/operation/StartJungleCodeSegment.java	Mon Jul 01 20:31:29 2013 +0900
+++ b/src/jungle/test/codesegment/operation/StartJungleCodeSegment.java	Mon Jul 01 20:34:03 2013 +0900
@@ -8,8 +8,8 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DefaultTreeOperation;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.PutAttributeOperation;
-import jungle.test.datasegment.store.operations.DefaultTreeOperationContainer;
 import alice.codesegment.CodeSegment;
+import alice.jungle.datasegment.store.operations.DefaultTreeOperationContainer;
 
 public class StartJungleCodeSegment {
 	
--- a/src/jungle/test/codesegment/operation/TestPutAttributeCodeSegment.java	Mon Jul 01 20:31:29 2013 +0900
+++ b/src/jungle/test/codesegment/operation/TestPutAttributeCodeSegment.java	Mon Jul 01 20:34:03 2013 +0900
@@ -17,15 +17,15 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import jungle.test.datasegment.store.operations.DefaultTreeOperationContainer;
-import jungle.test.datasegment.store.operations.DefaultTreeOperationLogContainer;
-import jungle.test.transaction.NetworkDefaultJungleTreeEditor;
 
 import org.msgpack.type.Value;
 
 import alice.codesegment.CodeSegment;
 import alice.datasegment.CommandType;
 import alice.datasegment.Receiver;
+import alice.jungle.datasegment.store.operations.DefaultTreeOperationContainer;
+import alice.jungle.datasegment.store.operations.DefaultTreeOperationLogContainer;
+import alice.jungle.transaction.NetworkDefaultJungleTreeEditor;
 
 public class TestPutAttributeCodeSegment extends CodeSegment {
 
--- a/src/jungle/test/codesegment/persistence/AliceJournal.java	Mon Jul 01 20:31:29 2013 +0900
+++ b/src/jungle/test/codesegment/persistence/AliceJournal.java	Mon Jul 01 20:34:03 2013 +0900
@@ -2,6 +2,9 @@
 
 import java.nio.ByteBuffer;
 
+import alice.jungle.datasegment.store.operations.DefaultNodeOperationContainer;
+import alice.jungle.datasegment.store.operations.DefaultTreeOperationContainer;
+
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeList;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeListReader;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeListWriter;
@@ -11,8 +14,6 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
-import jungle.test.datasegment.store.operations.DefaultNodeOperationContainer;
-import jungle.test.datasegment.store.operations.DefaultTreeOperationContainer;
 
 public class AliceJournal implements Journal {
 	
--- a/src/jungle/test/core/NetworkDefaultJungle.java	Mon Jul 01 20:31:29 2013 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,61 +0,0 @@
-package jungle.test.core;
-
-import java.util.Iterator;
-import java.util.concurrent.ConcurrentHashMap;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.Jungle;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeList;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.Journal;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.NullJournal;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.ChangeSet;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultChangeSet;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeContext;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNode;
-import jungle.test.codesegment.persistence.AliceJournal;
-import jungle.test.transaction.NetworkDefaultJungleTree;
-import fj.data.List;
-
-public class NetworkDefaultJungle implements Jungle {
-	private Journal journal;
-	private ConcurrentHashMap<String,JungleTree> trees;
-	private String uuid;
-	private TreeEditor editor;
-	
-	public NetworkDefaultJungle(Journal _journal,String _uuid,TreeEditor _editor)
-	{
-//		journal = new AliceJournal();
-		journal = new NullJournal();		
-		trees = new ConcurrentHashMap<String,JungleTree>();
-		uuid = _uuid;
-		editor = _editor;
-	}
-
-	@Override
-	public JungleTree getTreeByName(String _name)
-	{
-		return trees.get(_name);
-	}
-
-	@Override
-	public JungleTree createNewTree(String _name)
-	{
-		ChangeList list = new ChangeList(){
-			@Override
-			public Iterator<TreeOperation> iterator() {
-				List<TreeOperation> nil = List.nil();
-				return nil.iterator();
-			}
-		};
-		DefaultTreeNode root = new DefaultTreeNode();
-		ChangeSet set = new DefaultChangeSet(root.getAsNode(),null,list,uuid,0);
-		DefaultTreeContext<DefaultTreeNode> tc = new DefaultTreeContext<DefaultTreeNode>(root,set);
-		JungleTree newTree = new NetworkDefaultJungleTree<DefaultTreeNode>(tc,uuid,journal.getWriter(),editor);
-		if(trees.putIfAbsent(_name,newTree) != null){
-			return null;
-		}
-		return newTree;
-	}
-}
--- a/src/jungle/test/core/practice/LogReadCodeSegment.java	Mon Jul 01 20:31:29 2013 +0900
+++ b/src/jungle/test/core/practice/LogReadCodeSegment.java	Mon Jul 01 20:34:03 2013 +0900
@@ -15,10 +15,10 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
 import jungle.test.codesegment.operation.JungleManager;
-import jungle.test.datasegment.store.operations.DefaultTreeOperationLogContainer;
 import alice.codesegment.CodeSegment;
 import alice.datasegment.CommandType;
 import alice.datasegment.Receiver;
+import alice.jungle.datasegment.store.operations.DefaultTreeOperationLogContainer;
 
 public class LogReadCodeSegment extends CodeSegment {
 	
--- a/src/jungle/test/core/practice/LogSendTest.java	Mon Jul 01 20:31:29 2013 +0900
+++ b/src/jungle/test/core/practice/LogSendTest.java	Mon Jul 01 20:34:03 2013 +0900
@@ -3,6 +3,9 @@
 import java.io.IOException;
 import java.nio.ByteBuffer;
 
+import alice.jungle.datasegment.store.operations.DefaultTreeOperationLogContainer;
+import alice.jungle.transaction.NetworkDefaultJungleTreeEditor;
+
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
@@ -10,8 +13,6 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
 import jungle.test.codesegment.operation.JungleManager;
-import jungle.test.datasegment.store.operations.DefaultTreeOperationLogContainer;
-import jungle.test.transaction.NetworkDefaultJungleTreeEditor;
 
 public class LogSendTest {
 	
--- a/src/jungle/test/datasegment/store/operations/DefaultNodeOperationContainer.java	Mon Jul 01 20:31:29 2013 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,81 +0,0 @@
-package jungle.test.datasegment.store.operations;
-
-import java.io.IOException;
-import java.nio.ByteBuffer;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.AppendChildAtOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DeleteAttributeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DeleteChildAtOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.PutAttributeOperation;
-
-import org.msgpack.MessagePack;
-import org.msgpack.annotation.Message;
-import org.msgpack.template.OrdinalEnumTemplate;
-import org.msgpack.type.Value;
-
-@Message
-public class DefaultNodeOperationContainer {
-
-	public int pos;
-	public String key;
-	public Value value;
-	public Value commandValue;
-	
-	public static void main(String[] args) throws IOException {
-		String key = "hoge";
-		ByteBuffer b = ByteBuffer.wrap("messagepack value".getBytes());
-		PutAttributeOperation op = new PutAttributeOperation(key, b);
-		DefaultNodeOperationContainer container = new DefaultNodeOperationContainer();
-		container.unconvert(op);
-		NodeOperation convertedOp = container.convert(); 
-		System.out.println("pos : "+convertedOp.getPosition());
-		System.out.println("Command : "+convertedOp.getCommand());
-		System.out.println("key : "+convertedOp.getKey());
-		System.out.println("value : "+new String(convertedOp.getValue().array()));
-		
-	}
-	
-	public DefaultNodeOperationContainer() {
-		
-	}
-
-	public void unconvert(NodeOperation op) throws IOException {
-		MessagePack msgpack = new MessagePack();
-		pos = op.getPosition();
-		key = op.getKey();
-		value = null;
-		if (op.getValue() != null) {
-			ByteBuffer b = op.getValue();
-			byte[] bytes = b.array();
-			Value v = msgpack.unconvert(bytes);
-			value = v;
-		}
-		Command c = op.getCommand();
-		msgpack.register(Command.class, new OrdinalEnumTemplate(Command.class));
-		Value cValue = msgpack.unconvert(c);
-		commandValue = cValue;
-	}
-	
-	public NodeOperation convert() throws IOException{
-		MessagePack msgpack = new MessagePack();
-		msgpack.register(Command.class, new OrdinalEnumTemplate(Command.class));
-		Command c = msgpack.convert(commandValue, Command.class);
-		ByteBuffer b = null;
-		if (value != null) {
-			b = ByteBuffer.wrap(msgpack.convert(value, byte[].class));
-		}
-		if (c == Command.PUT_ATTRIBUTE) {
-			return new PutAttributeOperation(key, b);
-		} else if (c == Command.APPEND_CHILD) {
-			return new AppendChildAtOperation(pos);
-		} else if (c == Command.DELETE_CHILD) {
-			return new DeleteChildAtOperation(pos);
-		} else if (c == Command.DELETE_ATTRIBUTE){
-			return new DeleteAttributeOperation(key);
-		}
-		return null;
-	}
-	
-}
--- a/src/jungle/test/datasegment/store/operations/DefaultNodePathContainer.java	Mon Jul 01 20:31:29 2013 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,59 +0,0 @@
-package jungle.test.datasegment.store.operations;
-
-import java.io.IOException;
-import java.util.LinkedList;
-import java.util.List;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
-
-import org.msgpack.MessagePack;
-import org.msgpack.annotation.Message;
-import org.msgpack.template.IntegerTemplate;
-import org.msgpack.template.ListTemplate;
-import org.msgpack.type.Value;
-
-@Message
-public class DefaultNodePathContainer {
-
-	public Value pathValue;
-	
-	public static void main(String[] args) throws IOException {
-		DefaultNodePath p = new DefaultNodePath();
-		p = p.add(1).add(2).add(3);
-		DefaultNodePathContainer pathContainer = new DefaultNodePathContainer();
-		pathContainer.unconvert(p);
-		NodePath convertedPath = pathContainer.convert();
-		for (int i : convertedPath) {
-			System.out.println(i);
-		}
-	}
-	
-	public DefaultNodePathContainer() {
-		
-	}
-	
-	public void unconvert(NodePath path) throws IOException {
-		MessagePack msgpack = new MessagePack();
-		List<Integer> list = new LinkedList<Integer>();
-		for(Integer i : path) {
-			list.add(i);
-		}
-		/* Remove first Element(-1). */
-		list.remove(0);
-		msgpack.register(List.class, new ListTemplate(IntegerTemplate.getInstance()));
-		Value v = msgpack.unconvert(list);
-		pathValue = v;
-	}
-	
-	public DefaultNodePath convert() throws IOException {
-		MessagePack msgpack = new MessagePack();
-		msgpack.register(List.class, new ListTemplate(IntegerTemplate.getInstance()));
-		List<Integer> convertedList = (List<Integer>)msgpack.convert(pathValue, List.class);
-		DefaultNodePath path = new DefaultNodePath();
-		for (int i: convertedList) {
-			path = path.add(i);
-		}
-		return path;
-	}
-}
--- a/src/jungle/test/datasegment/store/operations/DefaultTreeOperationContainer.java	Mon Jul 01 20:31:29 2013 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,96 +0,0 @@
-package jungle.test.datasegment.store.operations;
-
-import java.io.IOException;
-import java.nio.ByteBuffer;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DefaultTreeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.PutAttributeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
-
-import org.msgpack.MessagePack;
-import org.msgpack.annotation.Message;
-import org.msgpack.type.Value;
-
-@Message
-public class DefaultTreeOperationContainer {
-
-	Value pathValue;
-	Value opValue;
-
-	public static void main(String[] args) throws IOException {
-		String key = "hoge";
-		ByteBuffer b = ByteBuffer.wrap("messagepack value".getBytes());
-		PutAttributeOperation op = new PutAttributeOperation(key, b);
-
-		DefaultNodePath p = new DefaultNodePath();
-		p = p.add(1).add(2).add(3);
-		DefaultTreeOperation treeOp = new DefaultTreeOperation(p, op);
-		
-		DefaultTreeOperationContainer treeOperationContainer = new DefaultTreeOperationContainer();
-		treeOperationContainer.unconvert(treeOp);
-
-		TreeOperation treeOperation = treeOperationContainer.convert();
-		NodePath nodePath = treeOperation.getNodePath();
-		NodeOperation nodeOp = treeOperation.getNodeOperation();
-		Command c = nodeOp.getCommand();
-		String str = "";
-		switch (c) {
-		case PUT_ATTRIBUTE:
-			String k = nodeOp.getKey();
-			ByteBuffer value = nodeOp.getValue();
-			if (value.limit() < 100) {
-				str = String.format("key:%s,value:%s", k,
-						new String(value.array()));
-			} else {
-				str = String.format("key:%s,value:%d", k, value.limit());
-			}
-			break;
-		case DELETE_ATTRIBUTE:
-			str = String.format("key:%s", nodeOp.getKey());
-			break;
-		case APPEND_CHILD:
-			str = String.format("pos:%d", nodeOp.getPosition());
-			break;
-		case DELETE_CHILD:
-			str = String.format("pos:%d", nodeOp.getPosition());
-			break;
-		}
-		System.out.println(String.format("[%s:%s:%s]", c, nodePath, str));
-		for (int i: nodePath ) {
-			System.out.println(i);
-		}
-	}
-
-	public DefaultTreeOperationContainer() {
-
-	}
-	
-	public void unconvert(DefaultTreeOperation _op) throws IOException {
-		NodeOperation nodeOp = _op.getNodeOperation();
-		NodePath nodePath = _op.getNodePath();
-		DefaultNodeOperationContainer opContainer = new DefaultNodeOperationContainer();
-		opContainer.unconvert(nodeOp);
-		DefaultNodePathContainer pathContainer = new DefaultNodePathContainer();
-		pathContainer.unconvert(nodePath);
-		unconvert(opContainer, pathContainer);
-	}
-
-	public void unconvert(DefaultNodeOperationContainer _op,
-			DefaultNodePathContainer _path) throws IOException {
-		MessagePack msgpack = new MessagePack();
-		pathValue = msgpack.unconvert(_path);
-		opValue = msgpack.unconvert(_op);
-	}
-
-	public TreeOperation convert() throws IOException {
-		MessagePack msgpack = new MessagePack();
-		DefaultNodePathContainer pathContainer = msgpack.convert(pathValue, DefaultNodePathContainer.class);
-		DefaultNodeOperationContainer opContainer = msgpack.convert(opValue, DefaultNodeOperationContainer.class);
-		return new DefaultTreeOperation(pathContainer.convert(), opContainer.convert());
-	}
-
-}
--- a/src/jungle/test/datasegment/store/operations/DefaultTreeOperationLogContainer.java	Mon Jul 01 20:31:29 2013 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,124 +0,0 @@
-package jungle.test.datasegment.store.operations;
-
-import java.io.IOException;
-import java.nio.ByteBuffer;
-import java.util.LinkedList;
-import java.util.List;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.DefaultTreeOperationLog;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DefaultTreeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.PutAttributeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
-
-import org.msgpack.MessagePack;
-import org.msgpack.annotation.Message;
-import org.msgpack.template.ListTemplate;
-import org.msgpack.template.ValueTemplate;
-import org.msgpack.type.Value;
-
-@Message
-public class DefaultTreeOperationLogContainer {
-
-	Value logValue;
-	
-	public static void main(String[] args) throws IOException {
-		String key = "hoge";
-		ByteBuffer b = ByteBuffer.wrap("messagepack value".getBytes());
-		PutAttributeOperation putOp = new PutAttributeOperation(key, b);
-		DefaultNodePath nodePath = new DefaultNodePath();
-		nodePath = nodePath.add(1).add(2).add(3);
-		TreeOperation op = new DefaultTreeOperation(nodePath, putOp);
-		List<TreeOperation> list = new LinkedList<TreeOperation>();
-		list.add(op);
-		list.add(op);
-		list.add(op);
-		DefaultTreeOperationLog log = new DefaultTreeOperationLog(list, list.size());
-		
-		DefaultTreeOperationLogContainer logContainer = new DefaultTreeOperationLogContainer();
-		logContainer.unconvert(log);
-
-		MessagePack msgpack = new MessagePack();
-		Value logContainerValue = msgpack.unconvert(logContainer);
-		DefaultTreeOperationLogContainer convertedLogContainer = msgpack.convert(logContainerValue,
-																	DefaultTreeOperationLogContainer.class);
-		
-		TreeOperationLog convertedLog = convertedLogContainer.convert();
-		for (TreeOperation treeOp : convertedLog) {
-			NodePath path = treeOp.getNodePath();
-			NodeOperation nodeOp = treeOp.getNodeOperation();
-			Command c = nodeOp.getCommand();
-			String str = "";
-			switch (c) {
-			case PUT_ATTRIBUTE:
-				String k = nodeOp.getKey();
-				ByteBuffer value = nodeOp.getValue();
-				if (value.limit() < 100) {
-					str = String.format("key:%s,value:%s", k,
-							new String(value.array()));
-				} else {
-					str = String.format("key:%s,value:%d", k, value.limit());
-				}
-				break;
-			case DELETE_ATTRIBUTE:
-				str = String.format("key:%s", nodeOp.getKey());
-				break;
-			case APPEND_CHILD:
-				str = String.format("pos:%d", nodeOp.getPosition());
-				break;
-			case DELETE_CHILD:
-				str = String.format("pos:%d", nodeOp.getPosition());
-				break;
-			}
-			System.out.println(String.format("[%s:%s:%s]", c, path, str));
-			for (int i: path ) {
-				System.out.println(i);
-			}
-			
-		}
-		
-		
-	}
-	
-	public DefaultTreeOperationLogContainer() {
-		
-	}
-	
-	public void unconvert(TreeOperationLog _log) throws IOException {
-		MessagePack msgpack = new MessagePack();
-		List<Value> list = new LinkedList<Value>();
-		for(TreeOperation op : _log) {
-			NodeOperation nOp = op.getNodeOperation();
-			NodePath nodePath = op.getNodePath();
-			DefaultTreeOperation treeOp = new DefaultTreeOperation(nodePath, nOp);
-			DefaultTreeOperationContainer container = new DefaultTreeOperationContainer();
-			container.unconvert(treeOp);
-			Value v = msgpack.unconvert(container);
-			list.add(v);
-		}
-		/* */
-		msgpack.register(List.class, new ListTemplate(ValueTemplate.getInstance()));
-		Value listValue = msgpack.unconvert(list);
-		logValue = listValue;
-	}
-	
-	public DefaultTreeOperationLog convert() throws IOException {
-		MessagePack msgpack = new MessagePack();
-		msgpack.register(List.class, new ListTemplate(ValueTemplate.getInstance()));
-		List<Value> listValue = msgpack.convert(logValue, List.class);
-		List<TreeOperation> logList = new LinkedList<TreeOperation>();
-		for(Value v: listValue) {
-			DefaultTreeOperationContainer container = msgpack.convert(v, DefaultTreeOperationContainer.class);
-			logList.add(container.convert());
-		}
-		DefaultTreeOperationLog log = new DefaultTreeOperationLog(logList, logList.size());
-		return log;
-	}
-	
-	
-	
-}
--- a/src/jungle/test/operations/NetworkNodeOperation.java	Mon Jul 01 20:31:29 2013 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,47 +0,0 @@
-package jungle.test.operations;
-
-import java.nio.ByteBuffer;
-
-import org.msgpack.annotation.Message;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.EditableNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-@Message
-public class NetworkNodeOperation implements NodeOperation {
-
-	@Override
-	public Command getCommand() {
-		// TODO Auto-generated method stub
-		return null;
-	}
-
-	@Override
-	public String getKey() {
-		// TODO Auto-generated method stub
-		return null;
-	}
-
-	@Override
-	public int getPosition() {
-		// TODO Auto-generated method stub
-		return 0;
-	}
-
-	@Override
-	public ByteBuffer getValue() {
-		// TODO Auto-generated method stub
-		return null;
-	}
-
-	@Override
-	public <T extends EditableNode<T>> Either<Error, T> invoke(T arg0) {
-		// TODO Auto-generated method stub
-		return null;
-	}
-	
-
-}
--- a/src/jungle/test/operations/NetworkNodePath.java	Mon Jul 01 20:31:29 2013 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,59 +0,0 @@
-package jungle.test.operations;
-
-import java.util.Iterator;
-import java.util.LinkedList;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
-
-public class NetworkNodePath implements NodePath
-{
-	LinkedList<Integer> path;
-	
-	public NetworkNodePath() {
-		path = new LinkedList<Integer>();
-	}
-	
-	private NetworkNodePath(LinkedList<Integer> _path) {
-		path = _path;
-	}
-	
-	@Override
-	public Iterator<Integer> iterator() {
-		return path.iterator();
-	}
-
-	@Override
-	public NetworkNodePath add(int _pos) {
-		LinkedList<Integer> newPath = copyPath();
-		newPath.add(_pos);
-		return new NetworkNodePath(newPath);
-	}
-
-	@Override
-	public Pair<Integer, NodePath> pop() {
-		LinkedList<Integer> cPath = copyPath();
-		int e = cPath.getFirst();
-		cPath.remove();
-		return new Pair<Integer, NodePath>(e, new NetworkNodePath(cPath));
-	}
-
-	@Override
-	public int size() {
-		return path.size();
-	}
-
-	private LinkedList<Integer> copyPath() {
-		LinkedList<Integer> newPath = new LinkedList<Integer>();
-		for (Integer i : path) {
-			newPath.add(i);
-		}
-		return newPath;
-	}
-	
-	@Override
-	public String toString() {
-		return path.toString();
-	}
-	
-}
--- a/src/jungle/test/operations/NetworkTreeOperation.java	Mon Jul 01 20:31:29 2013 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,35 +0,0 @@
-package jungle.test.operations;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
-
-import org.msgpack.annotation.Message;
-
-@Message
-public class NetworkTreeOperation implements TreeOperation {
-
-	public NodePath path;
-	public NodeOperation operation;
-	
-	public NetworkTreeOperation() {
-		path = null;
-		operation = null;
-	}
-	
-	public NetworkTreeOperation(NodePath _p, NodeOperation _op) {
-		path = _p;
-		operation = _op;
-	}
-
-	@Override
-	public NodePath getNodePath() {
-		return path;
-	}
-	
-	@Override
-	public NodeOperation getNodeOperation() {
-		return operation;
-	}
-	
-}
--- a/src/jungle/test/operations/NetworkTreeOperationLog.java	Mon Jul 01 20:31:29 2013 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,72 +0,0 @@
-package jungle.test.operations;
-
-import java.util.Iterator;
-import java.util.LinkedList;
-
-import org.msgpack.annotation.Message;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
-
-@Message
-public class NetworkTreeOperationLog implements TreeOperationLog
-{
-	public Iterable<TreeOperation> list;
-	public int size;
-	
-	public NetworkTreeOperationLog() {
-		list = new LinkedList<TreeOperation>();
-		size = 0;
-	}
-	
-	public NetworkTreeOperationLog(Iterable<TreeOperation> _list, int _size)
-	{
-		list = _list;
-		size = _size;
-	}
-	
-	public Iterable<TreeOperation> getOperationLogList() {
-		return list;
-	}
-	
-	@Override
-	public Iterator<TreeOperation> iterator() {
-		return list.iterator();
-	}
-
-	@Override
-	public NetworkTreeOperationLog add(NodePath _p, NodeOperation _op) 
-	{
-		TreeOperation op = new NetworkTreeOperation(_p, _op);
-		LinkedList<TreeOperation> newList = new LinkedList<TreeOperation>();
-		for (Iterator<TreeOperation> iter = list.iterator(); iter.hasNext();) {
-			TreeOperation o = iter.next();
-			newList.add(o);
-		}
-		newList.add(op);
-		return new NetworkTreeOperationLog(newList, size+1);
-	}
-
-	@Override
-	public NetworkTreeOperationLog append(TreeOperationLog _log) 
-	{
-		LinkedList<TreeOperation> newList = new LinkedList<TreeOperation>();
-		for (Iterator<TreeOperation> iter = list.iterator(); iter.hasNext();) {
-			TreeOperation o = iter.next();
-			newList.add(o);
-		}
-		for (TreeOperation o : _log) {
-			newList.add(o);
-		}
-		return new NetworkTreeOperationLog(newList, size+_log.length());
-	}
-
-	@Override
-	public int length() 
-	{
-		return size;
-	}
-
-}
--- a/src/jungle/test/operations/messagepack/PackOperationLog.java	Mon Jul 01 20:31:29 2013 +0900
+++ b/src/jungle/test/operations/messagepack/PackOperationLog.java	Mon Jul 01 20:34:03 2013 +0900
@@ -8,13 +8,14 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
-import jungle.test.operations.NetworkNodeOperation;
-import jungle.test.operations.NetworkNodePath;
-import jungle.test.operations.NetworkTreeOperationLog;
 
 import org.msgpack.MessagePack;
 import org.msgpack.type.Value;
 
+import alice.jungle.operations.NetworkNodeOperation;
+import alice.jungle.operations.NetworkNodePath;
+import alice.jungle.operations.NetworkTreeOperationLog;
+
 public class PackOperationLog {
 
 	public static void main(String[] args) throws IOException {
--- a/src/jungle/test/transaction/NetworkDefaultJungleTree.java	Mon Jul 01 20:31:29 2013 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,44 +0,0 @@
-package jungle.test.transaction;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Node;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeListWriter;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.ChangeSet;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.AtomicReservableReference;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTransactionManager;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.TreeContext;
-
-public class NetworkDefaultJungleTree<T extends TreeNode<T>> implements JungleTree {
-	private final AtomicReservableReference<TreeContext<T>> repository;
-	private final String uuid;
-	private final ChangeListWriter writer;
-	private final TreeEditor editor;
-	
-	public NetworkDefaultJungleTree(TreeContext<T> _tc,String _uuid,ChangeListWriter _writer,TreeEditor _editor)
-	{
-		repository = new AtomicReservableReference<TreeContext<T>>(_tc);
-		uuid = _uuid;
-		writer = _writer;
-		editor = _editor;
-	}
-
-	@Override
-	public JungleTreeEditor getTreeEditor()
-	{
-		TreeContext<T> tc = repository.get();
-		DefaultTransactionManager<T> txManager = new DefaultTransactionManager<T>(writer,tc,repository,uuid);
-		T root = tc.getTreeNode();
-		return new NetworkDefaultJungleTreeEditor<T>(root,txManager,editor);
-	}
-
-	@Override
-	public Node getRootNode()
-	{
-		TreeContext<T> tc = repository.get();
-		ChangeSet cs = tc.getChangeSet();
-		return cs.getRoot();
-	}
-}
--- a/src/jungle/test/transaction/NetworkDefaultJungleTreeEditor.java	Mon Jul 01 20:31:29 2013 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,151 +0,0 @@
-package jungle.test.transaction;
-
-import java.nio.ByteBuffer;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Node;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.DefaultTreeOperationLog;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNodeHook;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.OperationLog;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DefaultTreeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.AppendChildAt;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.DeleteAttribute;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.DeleteChildAt;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.NodeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.PutAttribute;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultJungleTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.TransactionManager;
-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.Error;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.IterableConverter;
-
-public class NetworkDefaultJungleTreeEditor<T extends TreeNode<T>> implements JungleTreeEditor {
-
-	private final TransactionManager<T> txManager;
-	private final T root;
-	private final TreeEditor editor;
-	private final TreeOperationLog log;
-
-	public NetworkDefaultJungleTreeEditor(T _root,TransactionManager<T> _txManager,TreeEditor _editor)
-	{
-		this(_root,_txManager,_editor,new DefaultTreeOperationLog());
-	}
-	
-	public NetworkDefaultJungleTreeEditor(T _root,TransactionManager<T> _txManager,TreeEditor _editor,TreeOperationLog _log)
-	{
-		root = _root;
-		txManager = _txManager;
-		editor = _editor;
-		log = _log;
-	}
-	
-	private Either<Error,JungleTreeEditor> _edit(final NodePath _path,NodeEditor _e)
-	{
-		LoggingNodeHook hook = new LoggingNodeHook(_e);
-		Either<Error,T> either = editor.edit(root,_path,hook);
-		if(either.isA()){
-			return DefaultEither.newA(either.a());
-		}
-		
-		T newNode = either.b();
-		OperationLog newLog = hook.getLog();
-		
-		IterableConverter.Converter<TreeOperation,NodeOperation> converter = new IterableConverter.Converter<TreeOperation,NodeOperation>(){
-			@Override
-			public TreeOperation conv(NodeOperation _b){
-				return new DefaultTreeOperation(_path,_b);
-			}
-		};
-		
-		Iterable<TreeOperation> iterable = new IterableConverter<TreeOperation,NodeOperation>(newLog,converter);
-		DefaultTreeOperationLog treeOperationLog = new DefaultTreeOperationLog(iterable,newLog.length());
-		TreeOperationLog newTreeOpLog = log.append(treeOperationLog);
-		
-		JungleTreeEditor newEditor = new NetworkDefaultJungleTreeEditor<T>(newNode,txManager,editor,newTreeOpLog);
-		return DefaultEither.newB(newEditor);
-	}
-	
-	@Override
-	public Either<Error,JungleTreeEditor> addNewChildAt(NodePath _path, int _pos)
-	{
-		AppendChildAt appendChildAt = new AppendChildAt(_pos);
-		return _edit(_path,appendChildAt);
-	}
-
-	@Override
-	public Either<Error,JungleTreeEditor> deleteChildAt(NodePath _path, int _pos)
-	{
-		DeleteChildAt deleteChildAt = new DeleteChildAt(_pos);
-		return _edit(_path,deleteChildAt);
-	}
-
-	@Override
-	public Either<Error,JungleTreeEditor> putAttribute(NodePath _path,String _key,ByteBuffer _value)
-	{
-		PutAttribute putAttribute = new PutAttribute(_key,_value);
-		return _edit(_path,putAttribute);
-	}
-
-	@Override
-	public Either<Error,JungleTreeEditor> deleteAttribute(NodePath _path, String _key)
-	{
-		DeleteAttribute deleteAttribute = new DeleteAttribute(_key);
-		return _edit(_path,deleteAttribute);
-	}
-
-	@Override
-	public Either<Error,JungleTreeEditor> edit(NodePath _path,NodeEditor _editor)
-	{
-		return _edit(_path,_editor);
-	}
-
-	@Override
-	public Either<Error,JungleTreeEditor> success()
-	{
-		Either<Error,TransactionManager<T>> either = txManager.commit(root,log);
-		if(either.isA()){
-			return DefaultEither.newA(either.a());
-		}
-		
-		TransactionManager<T> newTxManager = either.b();
-		JungleTreeEditor newTreeEditor = new NetworkDefaultJungleTreeEditor<T>(root,newTxManager,editor);
-		
-		return DefaultEither.newB(newTreeEditor);
-	}
-
-	@Override
-	public String getID()
-	{
-		return txManager.getUUID();
-	}
-
-	@Override
-	public String getRevision()
-	{
-		return Long.toString(txManager.getRevision());
-	}
-
-	@Override
-	public Node getRoot()
-	{
-		return null;
-	}
-	
-	public JungleTreeEditor setNewLogAndGetEditor(TreeOperationLog _log) {
-		JungleTreeEditor newEditor = new NetworkDefaultJungleTreeEditor<T>(root,txManager,editor, _log);
-		return newEditor;
-	}
-	
-	public TreeOperationLog getTreeOperationLog() {
-		return log;
-	}
-
-	
-}
--- a/src/jungle/test/transaction/NetworkTransactionManager.java	Mon Jul 01 20:31:29 2013 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,87 +0,0 @@
-package jungle.test.transaction;
-
-import java.util.Iterator;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Node;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeList;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeListWriter;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.Result;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.ChangeSet;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.AtomicReservableReference;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.AtomicReservableReference.Reservation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultChangeSet;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeContext;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.TransactionManager;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.TreeContext;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultError;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-public class NetworkTransactionManager<T extends TreeNode<T>> implements TransactionManager<T> 
-{
-
-	private final AtomicReservableReference<TreeContext<T>> repository;
-	private final TreeContext<T> tip;
-	private final ChangeListWriter writer;
-	private final String uuid;	
-	private final String treeName;	
-	
-	public NetworkTransactionManager(ChangeListWriter _writer,TreeContext<T> _tip,
-			AtomicReservableReference<TreeContext<T>> _repository,String _uuid, String _treeName)
-	{
-		repository = _repository;
-		tip = _tip;
-		writer = _writer;
-		uuid = _uuid;
-		treeName = _treeName;
-	}
-	
-	@Override
-	public Either<Error, TransactionManager<T>> commit(T _newRoot,final TreeOperationLog _log) {
-		ChangeSet cs = tip.getChangeSet();
-		long currentRevision = cs.revision();
-		long nextRevision = currentRevision + 1;
-		
-		ChangeList list = new ChangeList() {
-			@Override
-			public Iterator<TreeOperation> iterator(){
-				return _log.iterator();
-			}
-		};
-		
-		Node root = _newRoot.getAsNode();
-		DefaultChangeSet newCs = new DefaultChangeSet(root, cs, list, uuid, nextRevision);
-		DefaultTreeContext<T> newContext = new DefaultTreeContext<T>(_newRoot,newCs);
-		
-		@SuppressWarnings("rawtypes")
-		Reservation reservation = repository.makeReservation(tip, newContext);
-		if(reservation == null) {
-			return DefaultEither.newA((Error)new DefaultError());
-		}
-		Result r = writer.write(list);
-		if(r == Result.SUCCESS){
-			reservation.confirm();
-			TransactionManager<T> txManager = new NetworkTransactionManager<T>(writer, newContext, repository, uuid, treeName);
-			return DefaultEither.newB(txManager);
-		}
-
-		return DefaultEither.newA((Error)new DefaultError());
-	}
-
-	@Override
-	public long getRevision() 
-	{
-		ChangeSet cs = tip.getChangeSet();
-		return cs.revision();
-	}
-
-	@Override
-	public String getUUID() {
-		return uuid;
-	}
-
-}