Merge branch 'master' of github.com:msgpack/msgpack

32 files changed, 2141 insertions, 138 deletions

diff --git a/java/src/main/java/org/msgpack/AbstractTemplate.java b/java/src/main/java/org/msgpack/AbstractTemplate.java
new file mode 100644
index 0000000..5b4442e
--- /dev/null
+++ b/java/src/main/java/org/msgpack/AbstractTemplate.java
@@ -0,0 +1,27 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009-2010 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack;
+
+import java.io.IOException;
+
+public abstract class AbstractTemplate implements Template {
+	public Object unpack(Unpacker pac) throws IOException, MessageTypeException {
+		return convert(pac.unpackObject());
+	}
+}
+
diff --git a/java/src/main/java/org/msgpack/CustomConverter.java b/java/src/main/java/org/msgpack/CustomConverter.java
new file mode 100644
index 0000000..4351464
--- /dev/null
+++ b/java/src/main/java/org/msgpack/CustomConverter.java
@@ -0,0 +1,39 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009-2010 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack;
+
+import java.util.Map;
+import java.util.HashMap;
+
+// FIXME package private?
+public class CustomConverter {
+	public static void register(Class target, MessageConverter converter) {
+		map.put(target, converter);
+	}
+
+	public static MessageConverter get(Class target) {
+		return map.get(target);
+	}
+
+	public static boolean isRegistered(Class target) {
+		return map.containsKey(target);
+	}
+
+	private static Map<Class, MessageConverter> map = new HashMap<Class, MessageConverter>();
+}
+
diff --git a/java/src/main/java/org/msgpack/CustomMessage.java b/java/src/main/java/org/msgpack/CustomMessage.java
new file mode 100644
index 0000000..f87898c
--- /dev/null
+++ b/java/src/main/java/org/msgpack/CustomMessage.java
@@ -0,0 +1,30 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009-2010 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack;
+
+public class CustomMessage {
+	public static void registerPacker(Class target, MessagePacker packer) {
+		CustomPacker.register(target, packer);
+	}
+
+	public static void registerTemplate(Class target, Template tmpl) {
+		CustomUnpacker.register(target, tmpl);
+		CustomConverter.register(target, tmpl);
+	}
+}
+
diff --git a/java/src/main/java/org/msgpack/CustomPacker.java b/java/src/main/java/org/msgpack/CustomPacker.java
new file mode 100644
index 0000000..f0c6b62
--- /dev/null
+++ b/java/src/main/java/org/msgpack/CustomPacker.java
@@ -0,0 +1,39 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009-2010 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack;
+
+import java.util.Map;
+import java.util.HashMap;
+
+// FIXME package private?
+public class CustomPacker {
+	public static void register(Class target, MessagePacker converter) {
+		map.put(target, converter);
+	}
+
+	public static MessagePacker get(Class target) {
+		return map.get(target);
+	}
+
+	public static boolean isRegistered(Class target) {
+		return map.containsKey(target);
+	}
+
+	private static Map<Class, MessagePacker> map = new HashMap<Class, MessagePacker>();
+}
+
diff --git a/java/src/main/java/org/msgpack/CustomUnpacker.java b/java/src/main/java/org/msgpack/CustomUnpacker.java
new file mode 100644
index 0000000..b6047b8
--- /dev/null
+++ b/java/src/main/java/org/msgpack/CustomUnpacker.java
@@ -0,0 +1,39 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009-2010 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack;
+
+import java.util.Map;
+import java.util.HashMap;
+
+// FIXME package private?
+public class CustomUnpacker {
+	public static void register(Class target, MessageUnpacker converter) {
+		map.put(target, converter);
+	}
+
+	public static MessageUnpacker get(Class target) {
+		return map.get(target);
+	}
+
+	public static boolean isRegistered(Class target) {
+		return map.containsKey(target);
+	}
+
+	private static Map<Class, MessageUnpacker> map = new HashMap<Class, MessageUnpacker>();
+}
+
diff --git a/java/src/main/java/org/msgpack/MessageConverter.java b/java/src/main/java/org/msgpack/MessageConverter.java
new file mode 100644
index 0000000..8ad60ae
--- /dev/null
+++ b/java/src/main/java/org/msgpack/MessageConverter.java
@@ -0,0 +1,25 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009-2010 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack;
+
+import java.io.IOException;
+
+public interface MessageConverter {
+	public Object convert(MessagePackObject from) throws MessageTypeException;
+}
+
diff --git a/java/src/main/java/org/msgpack/MessagePackObject.java b/java/src/main/java/org/msgpack/MessagePackObject.java
index 2424446..f7e9e0e 100644
--- a/java/src/main/java/org/msgpack/MessagePackObject.java
+++ b/java/src/main/java/org/msgpack/MessagePackObject.java
@@ -132,5 +132,9 @@ public abstract class MessagePackObject implements Cloneable, MessagePackable {
 	}
 
 	abstract public Object clone();
+
+	public Object convert(Template tmpl) throws MessageTypeException {
+		return tmpl.convert(this);
+	}
 }
 
diff --git a/java/src/main/java/org/msgpack/MessagePacker.java b/java/src/main/java/org/msgpack/MessagePacker.java
new file mode 100644
index 0000000..05d4de5
--- /dev/null
+++ b/java/src/main/java/org/msgpack/MessagePacker.java
@@ -0,0 +1,25 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009-2010 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack;
+
+import java.io.IOException;
+
+public interface MessagePacker {
+	public void pack(Packer pk, Object target) throws IOException;
+}
+
diff --git a/java/src/main/java/org/msgpack/MessageUnpacker.java b/java/src/main/java/org/msgpack/MessageUnpacker.java
new file mode 100644
index 0000000..1817269
--- /dev/null
+++ b/java/src/main/java/org/msgpack/MessageUnpacker.java
@@ -0,0 +1,25 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009-2010 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack;
+
+import java.io.IOException;
+
+public interface MessageUnpacker {
+	public Object unpack(Unpacker pac) throws IOException, MessageTypeException;
+}
+
diff --git a/java/src/main/java/org/msgpack/Packer.java b/java/src/main/java/org/msgpack/Packer.java
index 139b3b1..dd8cdee 100644
--- a/java/src/main/java/org/msgpack/Packer.java
+++ b/java/src/main/java/org/msgpack/Packer.java
@@ -473,9 +473,19 @@ public class Packer {
 			return packDouble((Double)o);
 		} else if(o instanceof BigInteger) {
 			return packBigInteger((BigInteger)o);
-		} else {
-			throw new MessageTypeException("unknown object "+o+" ("+o.getClass()+")");
 		}
+
+		Class klass = o.getClass();
+
+		MessagePacker packer = CustomPacker.get(klass);
+		if(packer != null) {
+			packer.pack(this, o);
+			return this;
+		}
+
+		// FIXME check annotations -> code generation -> CustomMessage.registerPacker
+
+		throw new MessageTypeException("unknown object "+o+" ("+o.getClass()+")");
 	}
 }
 
diff --git a/java/src/main/java/org/msgpack/ReflectionBase.java b/java/src/main/java/org/msgpack/ReflectionBase.java
new file mode 100644
index 0000000..66ec12a
--- /dev/null
+++ b/java/src/main/java/org/msgpack/ReflectionBase.java
@@ -0,0 +1,26 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009-2010 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack;
+
+import java.io.IOException;
+import java.lang.reflect.*;
+
+// FIXME mock-up
+abstract class ReflectionBase {
+}
+
diff --git a/java/src/main/java/org/msgpack/ReflectionPacker.java b/java/src/main/java/org/msgpack/ReflectionPacker.java
new file mode 100644
index 0000000..72406aa
--- /dev/null
+++ b/java/src/main/java/org/msgpack/ReflectionPacker.java
@@ -0,0 +1,49 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009-2010 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack;
+
+import java.io.IOException;
+import java.lang.reflect.*;
+
+// FIXME mock-up
+public class ReflectionPacker extends ReflectionBase implements MessagePacker {
+	private Class<?> klass;
+
+	private ReflectionPacker(Class<?> klass) {
+		this.klass = klass;
+	}
+
+	static public ReflectionPacker create(Class klass) {
+		// FIXME code generation: generates subclass of ReflectionPacker
+		//       returned instance will be cached by Packer into CustomPacker
+		return new ReflectionPacker(klass);
+	}
+
+	public void pack(Packer pk, Object target) throws IOException {
+		Field[] fields = klass.getDeclaredFields();
+		pk.packArray(fields.length);
+		try {
+			for(int i=0; i < fields.length; i++) {
+				pk.pack(fields[i].get(target));
+			}
+		} catch(IllegalAccessException e) {
+			throw new MessageTypeException(e.getMessage());  // FIXME
+		}
+	}
+}
+
diff --git a/java/src/main/java/org/msgpack/ReflectionTemplate.java b/java/src/main/java/org/msgpack/ReflectionTemplate.java
new file mode 100644
index 0000000..5b49078
--- /dev/null
+++ b/java/src/main/java/org/msgpack/ReflectionTemplate.java
@@ -0,0 +1,74 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009-2010 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack;
+
+import java.io.IOException;
+import java.lang.reflect.*;
+import org.msgpack.template.ClassTemplate;
+
+// FIXME mock-up
+public class ReflectionTemplate extends ReflectionBase implements Template {
+	private Class klass;
+
+	private ReflectionTemplate(Class klass) {
+		this.klass = klass;
+	}
+
+	static public ReflectionTemplate create(Class klass) {
+		// FIXME code generation: generates subclass of ReflectionPacker
+		//       returned instance will be cached by ClassTemplate into CustomUnpacker/CustomConverter
+		return new ReflectionTemplate(klass);
+	}
+
+	public Object unpack(Unpacker pac) throws IOException, MessageTypeException {
+		// FIXME optimize it
+		return convert(pac.unpackObject());
+	}
+
+	public Object convert(MessagePackObject from) throws MessageTypeException {
+		Object obj;
+		try {
+			obj = klass.newInstance();
+		} catch (IllegalAccessException e) {
+			throw new MessageTypeException(e.getMessage());  // FIXME
+		} catch (InstantiationException e) {
+			throw new MessageTypeException(e.getMessage());  // FIXME
+		}
+
+		// FIXME check Requred/Optional
+
+		Field[] fields = klass.getDeclaredFields();
+		MessagePackObject[] array = from.asArray();
+		if(fields.length < array.length) {
+			throw new MessageTypeException();
+		}
+
+		try {
+			for(int i=0; i < fields.length; i++) {
+				// FIXME generics getDeclaringClass
+				Object value = new ClassTemplate(fields[i].getType()).convert(array[i]);
+				fields[i].set(obj, value);
+			}
+		} catch(IllegalAccessException e) {
+			throw new MessageTypeException(e.getMessage());  // FIXME
+		}
+
+		return obj;
+	}
+}
+
diff --git a/java/src/main/java/org/msgpack/Template.java b/java/src/main/java/org/msgpack/Template.java
new file mode 100644
index 0000000..71e64e0
--- /dev/null
+++ b/java/src/main/java/org/msgpack/Template.java
@@ -0,0 +1,22 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009-2010 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack;
+
+public interface Template extends MessageUnpacker, MessageConverter {
+}
+
diff --git a/java/src/main/java/org/msgpack/Templates.java b/java/src/main/java/org/msgpack/Templates.java
new file mode 100644
index 0000000..222f625
--- /dev/null
+++ b/java/src/main/java/org/msgpack/Templates.java
@@ -0,0 +1,86 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009-2010 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack;
+
+import org.msgpack.template.*;
+
+public class Templates {
+	public static Template tList(Template elementTemplate) {
+		return new ListTemplate(elementTemplate);
+	}
+
+	public static Template tMap(Template keyTemplate, Template valueTemplate) {
+		return new MapTemplate(keyTemplate, valueTemplate);
+	}
+
+	public static Template tClass(Class target) {
+		return new ClassTemplate(target);
+	}
+
+
+	public static final Template TByte = ByteTemplate.getInstance();
+	public static Template tByte() {
+		return TByte;
+	}
+
+	public static final Template TShort = ShortTemplate.getInstance();
+	public static Template tShort() {
+		return TShort;
+	}
+
+	public static final Template TInteger = IntegerTemplate.getInstance();
+	public static Template tInteger() {
+		return TInteger;
+	}
+
+	public static final Template TLong = LongTemplate.getInstance();
+	public static Template tLong() {
+		return TLong;
+	}
+
+	public static final Template TBigInteger = BigIntegerTemplate.getInstance();
+	public static Template tBigInteger() {
+		return TBigInteger;
+	}
+
+	public static final Template TFloat = FloatTemplate.getInstance();
+	public static Template tFloat() {
+		return TFloat;
+	}
+
+	public static final Template TDouble = DoubleTemplate.getInstance();
+	public static Template tDouble() {
+		return TDouble;
+	}
+
+	public static final Template TBoolean = BooleanTemplate.getInstance();
+	public static Template tBoolean() {
+		return TBoolean;
+	}
+
+	public static final Template TString = StringTemplate.getInstance();
+	public static Template tString() {
+		return TString;
+	}
+
+	public static final Template TByteArray = ByteArrayTemplate.getInstance();
+	public static Template tByteArray() {
+		return TByteArray;
+	}
+}
+
diff --git a/java/src/main/java/org/msgpack/Unpacker.java b/java/src/main/java/org/msgpack/Unpacker.java
index 3cae502..4e39748 100644
--- a/java/src/main/java/org/msgpack/Unpacker.java
+++ b/java/src/main/java/org/msgpack/Unpacker.java
@@ -561,12 +561,38 @@ public class Unpacker implements Iterable<MessagePackObject> {
 		return impl.unpackObject();
 	}
 
+	final public boolean tryUnpackNull() throws IOException {
+		return impl.tryUnpackNull();
+	}
+
+	final public Object unpack(MessageUnpacker unpacker) throws IOException, MessageTypeException {
+		return unpacker.unpack(this);
+	}
+
 	final public void unpack(MessageUnpackable obj) throws IOException, MessageTypeException {
 		obj.messageUnpack(this);
 	}
 
-	final public boolean tryUnpackNull() throws IOException {
-		return impl.tryUnpackNull();
+	final public Object unpack(Class klass) throws IOException, MessageTypeException, InstantiationException, IllegalAccessException {
+		if(MessageUnpackable.class.isAssignableFrom(klass)) {
+			Object obj = klass.newInstance();
+			((MessageUnpackable)obj).messageUnpack(this);
+			return obj;
+		}
+
+		MessageUnpacker unpacker = CustomUnpacker.get(klass);
+		if(unpacker != null) {
+			return unpacker.unpack(this);
+		}
+
+		// FIXME check annotations -> code generation -> CustomMessage.registerTemplate
+
+		MessageConverter converter = CustomConverter.get(klass);
+		if(converter != null) {
+			return converter.convert(unpackObject());
+		}
+
+		throw new MessageTypeException();
 	}
 }
 
diff --git a/java/src/main/java/org/msgpack/template/BigIntegerTemplate.java b/java/src/main/java/org/msgpack/template/BigIntegerTemplate.java
new file mode 100644
index 0000000..e8a2993
--- /dev/null
+++ b/java/src/main/java/org/msgpack/template/BigIntegerTemplate.java
@@ -0,0 +1,45 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009-2010 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack.template;
+
+import java.io.IOException;
+import java.math.BigInteger;
+import org.msgpack.*;
+
+public class BigIntegerTemplate implements Template {
+	private BigIntegerTemplate() { }
+
+	public Object unpack(Unpacker pac) throws IOException, MessageTypeException {
+		return pac.unpackBigInteger();
+	}
+
+	public Object convert(MessagePackObject from) throws MessageTypeException {
+		return from.asBigInteger();
+	}
+
+	static public BigIntegerTemplate getInstance() {
+		return instance;
+	}
+
+	static final BigIntegerTemplate instance = new BigIntegerTemplate();
+
+	static {
+		CustomMessage.registerTemplate(BigInteger.class, instance);
+	}
+}
+
diff --git a/java/src/main/java/org/msgpack/template/BooleanTemplate.java b/java/src/main/java/org/msgpack/template/BooleanTemplate.java
new file mode 100644
index 0000000..0d64ecc
--- /dev/null
+++ b/java/src/main/java/org/msgpack/template/BooleanTemplate.java
@@ -0,0 +1,44 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009-2010 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack.template;
+
+import java.io.IOException;
+import org.msgpack.*;
+
+public class BooleanTemplate implements Template {
+	private BooleanTemplate() { }
+
+	public Object unpack(Unpacker pac) throws IOException, MessageTypeException {
+		return pac.unpackBoolean();
+	}
+
+	public Object convert(MessagePackObject from) throws MessageTypeException {
+		return from.asBoolean();
+	}
+
+	static public BooleanTemplate getInstance() {
+		return instance;
+	}
+
+	static final BooleanTemplate instance = new BooleanTemplate();
+
+	static {
+		CustomMessage.registerTemplate(Boolean.class, instance);
+	}
+}
+
diff --git a/java/src/main/java/org/msgpack/template/ByteArrayTemplate.java b/java/src/main/java/org/msgpack/template/ByteArrayTemplate.java
new file mode 100644
index 0000000..fe26369
--- /dev/null
+++ b/java/src/main/java/org/msgpack/template/ByteArrayTemplate.java
@@ -0,0 +1,44 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009-2010 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack.template;
+
+import java.io.IOException;
+import org.msgpack.*;
+
+public class ByteArrayTemplate implements Template {
+	private ByteArrayTemplate() { }
+
+	public Object unpack(Unpacker pac) throws IOException, MessageTypeException {
+		return pac.unpackByteArray();
+	}
+
+	public Object convert(MessagePackObject from) throws MessageTypeException {
+		return from.asByteArray();
+	}
+
+	static public ByteArrayTemplate getInstance() {
+		return instance;
+	}
+
+	static final ByteArrayTemplate instance = new ByteArrayTemplate();
+
+	static {
+		CustomMessage.registerTemplate(byte[].class, instance);
+	}
+}
+
diff --git a/java/src/main/java/org/msgpack/template/ByteTemplate.java b/java/src/main/java/org/msgpack/template/ByteTemplate.java
new file mode 100644
index 0000000..8d0e6e6
--- /dev/null
+++ b/java/src/main/java/org/msgpack/template/ByteTemplate.java
@@ -0,0 +1,44 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009-2010 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack.template;
+
+import java.io.IOException;
+import org.msgpack.*;
+
+public class ByteTemplate implements Template {
+	private ByteTemplate() { }
+
+	public Object unpack(Unpacker pac) throws IOException, MessageTypeException {
+		return pac.unpackByte();
+	}
+
+	public Object convert(MessagePackObject from) throws MessageTypeException {
+		return from.asByte();
+	}
+
+	static public ByteTemplate getInstance() {
+		return instance;
+	}
+
+	static final ByteTemplate instance = new ByteTemplate();
+
+	static {
+		CustomMessage.registerTemplate(Byte.class, instance);
+	}
+}
+
diff --git a/java/src/main/java/org/msgpack/template/ClassTemplate.java b/java/src/main/java/org/msgpack/template/ClassTemplate.java
new file mode 100644
index 0000000..c529edd
--- /dev/null
+++ b/java/src/main/java/org/msgpack/template/ClassTemplate.java
@@ -0,0 +1,64 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009-2010 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack.template;
+
+import java.io.IOException;
+import org.msgpack.*;
+
+public class ClassTemplate implements Template {
+	private Class klass;
+
+	public ClassTemplate(Class klass) {
+		this.klass = klass;
+	}
+
+	public Object unpack(Unpacker pac) throws IOException, MessageTypeException {
+		try {
+			return pac.unpack(klass);
+		} catch (IllegalAccessException e) {
+			throw new MessageTypeException(e.getMessage());  // FIXME
+		} catch (InstantiationException e) {
+			throw new MessageTypeException(e.getMessage());  // FIXME
+		}
+	}
+
+	public Object convert(MessagePackObject from) throws MessageTypeException {
+		if(MessageConvertable.class.isAssignableFrom(klass)) {
+			Object obj;
+			try {
+				obj = klass.newInstance();
+			} catch (IllegalAccessException e) {
+				throw new MessageTypeException(e.getMessage());  // FIXME
+			} catch (InstantiationException e) {
+				throw new MessageTypeException(e.getMessage());  // FIXME
+			}
+			((MessageConvertable)obj).messageConvert(from);
+			return obj;
+		}
+
+		MessageConverter converter = CustomConverter.get(klass);
+		if(converter != null) {
+			return converter.convert(from);
+		}
+
+		// FIXME check annotations -> code generation -> CustomMessage.registerTemplate
+
+		throw new MessageTypeException();
+	}
+}
+
diff --git a/java/src/main/java/org/msgpack/template/DoubleTemplate.java b/java/src/main/java/org/msgpack/template/DoubleTemplate.java
new file mode 100644
index 0000000..2e26f50
--- /dev/null
+++ b/java/src/main/java/org/msgpack/template/DoubleTemplate.java
@@ -0,0 +1,44 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009-2010 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack.template;
+
+import java.io.IOException;
+import org.msgpack.*;
+
+public class DoubleTemplate implements Template {
+	private DoubleTemplate() { }
+
+	public Object unpack(Unpacker pac) throws IOException, MessageTypeException {
+		return pac.unpackDouble();
+	}
+
+	public Object convert(MessagePackObject from) throws MessageTypeException {
+		return from.asDouble();
+	}
+
+	static public DoubleTemplate getInstance() {
+		return instance;
+	}
+
+	static final DoubleTemplate instance = new DoubleTemplate();
+
+	static {
+		CustomMessage.registerTemplate(Double.class, instance);
+	}
+}
+
diff --git a/java/src/main/java/org/msgpack/template/FloatTemplate.java b/java/src/main/java/org/msgpack/template/FloatTemplate.java
new file mode 100644
index 0000000..8730172
--- /dev/null
+++ b/java/src/main/java/org/msgpack/template/FloatTemplate.java
@@ -0,0 +1,44 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009-2010 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack.template;
+
+import java.io.IOException;
+import org.msgpack.*;
+
+public class FloatTemplate implements Template {
+	private FloatTemplate() { }
+
+	public Object unpack(Unpacker pac) throws IOException, MessageTypeException {
+		return pac.unpackFloat();
+	}
+
+	public Object convert(MessagePackObject from) throws MessageTypeException {
+		return from.asFloat();
+	}
+
+	static public FloatTemplate getInstance() {
+		return instance;
+	}
+
+	static final FloatTemplate instance = new FloatTemplate();
+
+	static {
+		CustomMessage.registerTemplate(Float.class, instance);
+	}
+}
+
diff --git a/java/src/main/java/org/msgpack/template/IntegerTemplate.java b/java/src/main/java/org/msgpack/template/IntegerTemplate.java
new file mode 100644
index 0000000..c56c044
--- /dev/null
+++ b/java/src/main/java/org/msgpack/template/IntegerTemplate.java
@@ -0,0 +1,44 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009-2010 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack.template;
+
+import java.io.IOException;
+import org.msgpack.*;
+
+public class IntegerTemplate implements Template {
+	private IntegerTemplate() { }
+
+	public Object unpack(Unpacker pac) throws IOException, MessageTypeException {
+		return pac.unpackInt();
+	}
+
+	public Object convert(MessagePackObject from) throws MessageTypeException {
+		return from.asInt();
+	}
+
+	static public IntegerTemplate getInstance() {
+		return instance;
+	}
+
+	static final IntegerTemplate instance = new IntegerTemplate();
+
+	static {
+		CustomMessage.registerTemplate(Integer.class, instance);
+	}
+}
+
diff --git a/java/src/main/java/org/msgpack/template/ListTemplate.java b/java/src/main/java/org/msgpack/template/ListTemplate.java
new file mode 100644
index 0000000..54975f8
--- /dev/null
+++ b/java/src/main/java/org/msgpack/template/ListTemplate.java
@@ -0,0 +1,50 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009-2010 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack.template;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.io.IOException;
+import org.msgpack.*;
+
+public class ListTemplate implements Template {
+	private Template elementTemplate;
+
+	public ListTemplate(Template elementTemplate) {
+		this.elementTemplate = elementTemplate;
+	}
+
+	public Object unpack(Unpacker pac) throws IOException, MessageTypeException {
+		int length = pac.unpackArray();
+		List<Object> list = new ArrayList<Object>(length);
+		for(; length > 0; length--) {
+			list.add( elementTemplate.unpack(pac) );
+		}
+		return list;
+	}
+
+	public Object convert(MessagePackObject from) throws MessageTypeException {
+		MessagePackObject[] array = from.asArray();
+		List<Object> list = new ArrayList<Object>(array.length);
+		for(MessagePackObject element : array) {
+			list.add( elementTemplate.convert(element) );
+		}
+		return list;
+	}
+}
+
diff --git a/java/src/main/java/org/msgpack/template/LongTemplate.java b/java/src/main/java/org/msgpack/template/LongTemplate.java
new file mode 100644
index 0000000..a0c8210
--- /dev/null
+++ b/java/src/main/java/org/msgpack/template/LongTemplate.java
@@ -0,0 +1,44 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009-2010 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack.template;
+
+import java.io.IOException;
+import org.msgpack.*;
+
+public class LongTemplate implements Template {
+	private LongTemplate() { }
+
+	public Object unpack(Unpacker pac) throws IOException, MessageTypeException {
+		return pac.unpackLong();
+	}
+
+	public Object convert(MessagePackObject from) throws MessageTypeException {
+		return from.asLong();
+	}
+
+	static public LongTemplate getInstance() {
+		return instance;
+	}
+
+	static final LongTemplate instance = new LongTemplate();
+
+	static {
+		CustomMessage.registerTemplate(Long.class, instance);
+	}
+}
+
diff --git a/java/src/main/java/org/msgpack/template/MapTemplate.java b/java/src/main/java/org/msgpack/template/MapTemplate.java
new file mode 100644
index 0000000..d2b4eff
--- /dev/null
+++ b/java/src/main/java/org/msgpack/template/MapTemplate.java
@@ -0,0 +1,56 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009-2010 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack.template;
+
+import java.util.Map;
+import java.util.HashMap;
+import java.io.IOException;
+import org.msgpack.*;
+
+public class MapTemplate implements Template {
+	private Template keyTemplate;
+	private Template valueTemplate;
+
+	public MapTemplate(Template keyTemplate, Template valueTemplate) {
+		this.keyTemplate = keyTemplate;
+		this.valueTemplate = valueTemplate;
+	}
+
+	public Object unpack(Unpacker pac) throws IOException, MessageTypeException {
+		int length = pac.unpackMap();
+		Map<Object,Object> map = new HashMap<Object,Object>(length);
+		for(; length > 0; length--) {
+			Object key = keyTemplate.unpack(pac);
+			Object value = valueTemplate.unpack(pac);
+			map.put(key, value);
+		}
+		return map;
+	}
+
+	public Object convert(MessagePackObject from) throws MessageTypeException {
+		Map<MessagePackObject,MessagePackObject> src = from.asMap();
+		Map<Object,Object> map = new HashMap();
+		for(Map.Entry<MessagePackObject,MessagePackObject> pair : src.entrySet()) {
+			Object key = keyTemplate.convert(pair.getKey());
+			Object value = valueTemplate.convert(pair.getValue());
+			map.put(key, value);
+		}
+		return map;
+	}
+}
+
diff --git a/java/src/main/java/org/msgpack/template/ShortTemplate.java b/java/src/main/java/org/msgpack/template/ShortTemplate.java
new file mode 100644
index 0000000..b3bf43b
--- /dev/null
+++ b/java/src/main/java/org/msgpack/template/ShortTemplate.java
@@ -0,0 +1,44 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009-2010 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack.template;
+
+import java.io.IOException;
+import org.msgpack.*;
+
+public class ShortTemplate implements Template {
+	private ShortTemplate() { }
+
+	public Object unpack(Unpacker pac) throws IOException, MessageTypeException {
+		return pac.unpackShort();
+	}
+
+	public Object convert(MessagePackObject from) throws MessageTypeException {
+		return from.asShort();
+	}
+
+	static public ShortTemplate getInstance() {
+		return instance;
+	}
+
+	static final ShortTemplate instance = new ShortTemplate();
+
+	static {
+		CustomMessage.registerTemplate(Short.class, instance);
+	}
+}
+
diff --git a/java/src/main/java/org/msgpack/template/StringTemplate.java b/java/src/main/java/org/msgpack/template/StringTemplate.java
new file mode 100644
index 0000000..563112d
--- /dev/null
+++ b/java/src/main/java/org/msgpack/template/StringTemplate.java
@@ -0,0 +1,44 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009-2010 FURUHASHI Sadayuki
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+//
+package org.msgpack.template;
+
+import java.io.IOException;
+import org.msgpack.*;
+
+public class StringTemplate implements Template {
+	private StringTemplate() { }
+
+	public Object unpack(Unpacker pac) throws IOException, MessageTypeException {
+		return pac.unpackString();
+	}
+
+	public Object convert(MessagePackObject from) throws MessageTypeException {
+		return from.asString();
+	}
+
+	static public StringTemplate getInstance() {
+		return instance;
+	}
+
+	static final StringTemplate instance = new StringTemplate();
+
+	static {
+		CustomMessage.registerTemplate(String.class, instance);
+	}
+}
+
diff --git a/java/src/main/java/org/msgpack/util/annotation/PackUnpackUtil.java b/java/src/main/java/org/msgpack/util/annotation/PackUnpackUtil.java
index 5238444..0aeb6d8 100644
--- a/java/src/main/java/org/msgpack/util/annotation/PackUnpackUtil.java
+++ b/java/src/main/java/org/msgpack/util/annotation/PackUnpackUtil.java
@@ -11,6 +11,7 @@ import java.lang.reflect.ParameterizedType;
 import java.math.BigInteger;
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
@@ -25,6 +26,7 @@ import javassist.CtNewMethod;
 import javassist.NotFoundException;
 
 import org.msgpack.MessageConvertable;
+import org.msgpack.MessagePackObject;
 import org.msgpack.MessagePackable;
 import org.msgpack.MessageTypeException;
 import org.msgpack.MessageUnpackable;
@@ -39,40 +41,13 @@ public class PackUnpackUtil {
 
 		static final String KEYWORD_FOR = "for";
 
+		static final String KEYWORD_IF = "if";
+
 		static final String KEYWORD_THROWS = "throws";
 
 		static final String KEYWORD_NEW = "new";
 
-		static final String TYPE_NAME_VOID = void.class.getName();
-
-		static final String TYPE_NAME_OBJECT = Object.class.getName();
-
-		static final String TYPE_NAME_IOEXCEPTION = IOException.class.getName();
-
-		static final String TYPE_NAME_PACKER = Packer.class.getName();
-
-		static final String TYPE_NAME_UNPACKER = Unpacker.class.getName();
-
-		static final String TYPE_NAME_MSGPACKABLE = MessagePackable.class
-				.getName();
-
-		static final String TYPE_NAME_MSGUNPACKABLE = MessageUnpackable.class
-				.getName();
-
-		static final String TYPE_NAME_MSGCONVERTABLE = MessageConvertable.class
-				.getName();
-
-		static final String TYPE_NAME_MSGTYPEEXCEPTION = MessageTypeException.class
-				.getName();
-
-		static final String TYPE_NAME_MSGPACKUNPACKABLE = MessagePackUnpackable.class
-				.getName();
-
-		static final String TYPE_NAME_MSGPACKOPTIONAL = MessagePackOptional.class
-				.getName();
-
-		static final String TYPE_NAME_MSGPACKOREQUIRED = MessagePackRequired.class
-				.getName();
+		static final String KEYWORD_NULL = "null";
 
 		static final String CHAR_NAME_SPACE = " ";
 
@@ -92,15 +67,31 @@ public class PackUnpackUtil {
 
 		static final String CHAR_NAME_LEFT_CURLY_BRACHET = "{";
 
+		static final String CHAR_NAME_RIGHT_SQUARE_BRACKET = "]";
+
+		static final String CHAR_NAME_LEFT_SQUARE_BRACKET = "[";
+
 		static final String CHAR_NAME_DOT = ".";
 
 		static final String CHAR_NAME_SEMICOLON = ";";
 
-		static final String VARIABLE_NAME_PK = "pk";
+		static final String VARIABLE_NAME_PK = "_$$_pk";
+
+		static final String VARIABLE_NAME_SIZE = "_$$_len";
+
+		static final String VARIABLE_NAME_ARRAY = "_$$_ary";
+
+		static final String VARIABLE_NAME_LIST = "_$$_list";
+
+		static final String VARIABLE_NAME_MAP = "_$$_map";
+
+		static final String VARIABLE_NAME_KEY = "_$$_key";
 
-		static final String VARIABLE_NAME_OBJ = "obj";
+		static final String VARIABLE_NAME_VAL = "_$$_val";
 
-		static final String VARIABLE_NAME_SIZE = "len";
+		static final String VARIABLE_NAME_ITER = "_$$_iter";
+
+		static final String VARIABLE_NAME_MPO = "_$$_mpo";
 
 		static final String VARIABLE_NAME_I = "i";
 
@@ -110,6 +101,18 @@ public class PackUnpackUtil {
 
 		static final String METHOD_NAME_PUT = "put";
 
+		static final String METHOD_NAME_GET = "get";
+
+		static final String METHOD_NAME_SIZE = "size";
+
+		static final String METHOD_NAME_KEYSET = "keySet";
+
+		static final String METHOD_NAME_ITERATOR = "iterator";
+
+		static final String METHOD_NAME_HASNEXT = "hasNext";
+
+		static final String METHOD_NAME_NEXT = "next";
+
 		static final String METHOD_NAME_MSGPACK = "messagePack";
 
 		static final String METHOD_NAME_MSGUNPACK = "messageUnpack";
@@ -147,6 +150,28 @@ public class PackUnpackUtil {
 		static final String METHOD_NAME_UNPACKARRAY = "unpackArray";
 
 		static final String METHOD_NAME_UNPACKMAP = "unpackMap";
+
+		static final String METHOD_NAME_ASARRAY = "asArray";
+
+		static final String METHOD_NAME_ASBOOLEAN = "asBoolean";
+
+		static final String METHOD_NAME_ASBYTE = "asByte";
+
+		static final String METHOD_NAME_ASSHORT = "asShort";
+
+		static final String METHOD_NAME_ASINT = "asInt";
+
+		static final String METHOD_NAME_ASFLOAT = "asFloat";
+
+		static final String METHOD_NAME_ASLONG = "asLong";
+
+		static final String METHOD_NAME_ASDOUBLE = "asDouble";
+
+		static final String METHOD_NAME_ASSTRING = "asString";
+
+		static final String METHOD_NAME_ASBYTEARRAY = "asByteArray";
+
+		static final String METHOD_NAME_ASBIGINTEGER = "asBigInteger";
 	}
 
 	public static class Enhancer {
@@ -168,25 +193,26 @@ public class PackUnpackUtil {
 			classCache.putIfAbsent(origName, enhClass);
 		}
 
-		protected Class<?> generate(Class<?> origClass)
+		protected Class<?> generate(Class<?> origClass, boolean packUnpackable)
 				throws NotFoundException, CannotCompileException {
 			String origName = origClass.getName();
 			String enhName = origName + Constants.POSTFIX_TYPE_NAME_ENHANCER;
 			CtClass origCtClass = pool.get(origName);
-			checkClassValidation(origClass);
+			checkClassValidation(origClass, packUnpackable);
 			checkDefaultConstructorValidation(origClass);
 			CtClass enhCtClass = pool.makeClass(enhName);
 			setSuperclass(enhCtClass, origCtClass);
 			setInterfaces(enhCtClass);
 			addConstructor(enhCtClass);
 			Field[] fields = getDeclaredFields(origClass);
-			addMessagePackMethod(enhCtClass, origCtClass, fields);
-			addMessageUnpackMethod(enhCtClass, origCtClass, fields);
-			addMessageConvertMethod(enhCtClass, origCtClass, fields);
+			addMessagePackMethod(enhCtClass, fields);
+			addMessageUnpackMethod(enhCtClass, fields);
+			addMessageConvertMethod(enhCtClass, fields);
 			return createClass(enhCtClass);
 		}
 
-		private void checkClassValidation(Class<?> origClass) {
+		private void checkClassValidation(Class<?> origClass,
+				boolean packUnpackable) {
 			// not public, abstract, final
 			int mod = origClass.getModifiers();
 			if ((!(Modifier.isPublic(mod) || Modifier.isProtected(mod)))
@@ -198,7 +224,9 @@ public class PackUnpackUtil {
 				throwClassValidationException(origClass);
 			}
 			// annotation
-			checkPackUnpackAnnotation(origClass);
+			if (!packUnpackable) {
+				checkPackUnpackAnnotation(origClass);
+			}
 		}
 
 		private static void throwClassValidationException(Class<?> origClass) {
@@ -243,11 +271,11 @@ public class PackUnpackUtil {
 		}
 
 		private void setInterfaces(CtClass enhCtClass) throws NotFoundException {
-			CtClass pacCtClass = pool.get(Constants.TYPE_NAME_MSGPACKABLE);
+			CtClass pacCtClass = pool.get(MessagePackable.class.getName());
 			enhCtClass.addInterface(pacCtClass);
-			CtClass unpacCtClass = pool.get(Constants.TYPE_NAME_MSGUNPACKABLE);
+			CtClass unpacCtClass = pool.get(MessageUnpackable.class.getName());
 			enhCtClass.addInterface(unpacCtClass);
-			CtClass convCtClass = pool.get(Constants.TYPE_NAME_MSGCONVERTABLE);
+			CtClass convCtClass = pool.get(MessageConvertable.class.getName());
 			enhCtClass.addInterface(convCtClass);
 		}
 
@@ -296,24 +324,23 @@ public class PackUnpackUtil {
 					+ field.getName());
 		}
 
-		private void addMessagePackMethod(CtClass enhCtClass,
-				CtClass origCtClass, Field[] fields)
+		private void addMessagePackMethod(CtClass enhCtClass, Field[] fields)
 				throws CannotCompileException, NotFoundException {
 			StringBuilder sb = new StringBuilder();
 			sb.append(Constants.KEYWORD_MODIFIER_PUBLIC);
 			sb.append(Constants.CHAR_NAME_SPACE);
-			sb.append(Constants.TYPE_NAME_VOID);
+			sb.append(void.class.getName());
 			sb.append(Constants.CHAR_NAME_SPACE);
 			sb.append(Constants.METHOD_NAME_MSGPACK);
 			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
-			sb.append(Constants.TYPE_NAME_PACKER);
+			sb.append(Packer.class.getName());
 			sb.append(Constants.CHAR_NAME_SPACE);
 			sb.append(Constants.VARIABLE_NAME_PK);
 			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
 			sb.append(Constants.CHAR_NAME_SPACE);
 			sb.append(Constants.KEYWORD_THROWS);
 			sb.append(Constants.CHAR_NAME_SPACE);
-			sb.append(Constants.TYPE_NAME_IOEXCEPTION);
+			sb.append(IOException.class.getName());
 			sb.append(Constants.CHAR_NAME_SPACE);
 			sb.append(Constants.CHAR_NAME_LEFT_CURLY_BRACHET);
 			sb.append(Constants.CHAR_NAME_SPACE);
@@ -326,15 +353,15 @@ public class PackUnpackUtil {
 			sb.append(Constants.CHAR_NAME_SEMICOLON);
 			sb.append(Constants.CHAR_NAME_SPACE);
 			for (Field field : fields) {
-				insertCodeOfMessagePack(sb, field);
+				insertCodeOfMessagePackCall(sb, field);
 			}
 			sb.append(Constants.CHAR_NAME_RIGHT_CURLY_BRACHET);
-			//System.out.println("messagePack method: " + sb.toString());
+			// System.out.println("messagePack method: " + sb.toString());
 			CtMethod newCtMethod = CtNewMethod.make(sb.toString(), enhCtClass);
 			enhCtClass.addMethod(newCtMethod);
 		}
 
-		private void insertCodeOfMessagePack(StringBuilder sb, Field field) {
+		private void insertCodeOfMessagePackCall(StringBuilder sb, Field field) {
 			sb.append(Constants.VARIABLE_NAME_PK);
 			sb.append(Constants.CHAR_NAME_DOT);
 			sb.append(Constants.METHOD_NAME_PACK);
@@ -345,27 +372,26 @@ public class PackUnpackUtil {
 			sb.append(Constants.CHAR_NAME_SPACE);
 		}
 
-		private void addMessageUnpackMethod(CtClass enhCtClass,
-				CtClass origCtClass, Field[] fields)
+		private void addMessageUnpackMethod(CtClass enhCtClass, Field[] fields)
 				throws CannotCompileException, NotFoundException {
 			StringBuilder sb = new StringBuilder();
 			sb.append(Constants.KEYWORD_MODIFIER_PUBLIC);
 			sb.append(Constants.CHAR_NAME_SPACE);
-			sb.append(Constants.TYPE_NAME_VOID);
+			sb.append(void.class.getName());
 			sb.append(Constants.CHAR_NAME_SPACE);
 			sb.append(Constants.METHOD_NAME_MSGUNPACK);
 			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
-			sb.append(Constants.TYPE_NAME_UNPACKER);
+			sb.append(Unpacker.class.getName());
 			sb.append(Constants.CHAR_NAME_SPACE);
 			sb.append(Constants.VARIABLE_NAME_PK);
 			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
 			sb.append(Constants.CHAR_NAME_SPACE);
 			sb.append(Constants.KEYWORD_THROWS);
 			sb.append(Constants.CHAR_NAME_SPACE);
-			sb.append(Constants.TYPE_NAME_MSGTYPEEXCEPTION);
+			sb.append(MessageTypeException.class.getName());
 			sb.append(Constants.CHAR_NAME_COMMA);
 			sb.append(Constants.CHAR_NAME_SPACE);
-			sb.append(Constants.TYPE_NAME_IOEXCEPTION);
+			sb.append(IOException.class.getName());
 			sb.append(Constants.CHAR_NAME_SPACE);
 			sb.append(Constants.CHAR_NAME_LEFT_CURLY_BRACHET);
 			sb.append(Constants.CHAR_NAME_SPACE);
@@ -376,50 +402,57 @@ public class PackUnpackUtil {
 			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
 			sb.append(Constants.CHAR_NAME_SEMICOLON);
 			sb.append(Constants.CHAR_NAME_SPACE);
-			for (Field field : fields) {
-				insertCodeOfMessageUnpack(sb, field, field.getType());
-			}
+			insertCodeOfMessageUnpackCalls(sb, fields);
 			sb.append(Constants.CHAR_NAME_RIGHT_CURLY_BRACHET);
-			//System.out.println("messageUnpack method: " + sb.toString());
+			// System.out.println("messageUnpack method: " + sb.toString());
 			CtMethod newCtMethod = CtNewMethod.make(sb.toString(), enhCtClass);
 			enhCtClass.addMethod(newCtMethod);
 		}
 
-		private void insertCodeOfMessageUnpack(StringBuilder sb, Field field,
-				Class<?> type) throws NotFoundException {
-			if (type.isPrimitive()) {
+		private void insertCodeOfMessageUnpackCalls(StringBuilder sb,
+				Field[] fields) throws NotFoundException {
+			for (Field field : fields) {
+				insertCodeOfMessageUnpackCall(sb, field, field.getType());
+			}
+		}
+
+		private void insertCodeOfMessageUnpackCall(StringBuilder sb, Field f,
+				Class<?> c) throws NotFoundException {
+			if (c.isPrimitive()) {
 				// primitive type
-				insertCodeOfMessageUnpackForPrimitiveTypes(sb, field, type);
-			} else if (type.equals(Boolean.class) || // Boolean
-					type.equals(Byte.class) || // Byte
-					type.equals(Double.class) || // Double
-					type.equals(Float.class) || // Float
-					type.equals(Integer.class) || // Integer
-					type.equals(Long.class) || // Long
-					type.equals(Short.class)) { // Short
+				insertCodeOfMessageUnpackCallForPrimTypes(sb, f, c);
+			} else if (c.equals(Boolean.class) || // Boolean
+					c.equals(Byte.class) || // Byte
+					c.equals(Double.class) || // Double
+					c.equals(Float.class) || // Float
+					c.equals(Integer.class) || // Integer
+					c.equals(Long.class) || // Long
+					c.equals(Short.class)) { // Short
 				// reference type (wrapper type)
-				insertCodeOfMessageUnpackForWrapperTypes(sb, field, type);
-			} else if (type.equals(BigInteger.class) || // BigInteger
-					type.equals(String.class) || // String
-					type.equals(byte[].class)) { // byte[]
+				insertCodeOfMessageUnpackCallForWrapTypes(sb, f, c);
+			} else if (c.equals(BigInteger.class) || // BigInteger
+					c.equals(String.class) || // String
+					c.equals(byte[].class)) { // byte[]
 				// reference type (other type)
-				insertCodeOfMessageUnpackForPrimitiveTypes(sb, field, type);
-			} else if (List.class.isAssignableFrom(type)) {
+				insertCodeOfMessageUnpackCallForPrimTypes(sb, f, c);
+			} else if (List.class.isAssignableFrom(c)) {
 				// List
-				insertCodeOfMessageUnpackForListType(sb, field, type);
-			} else if (Map.class.isAssignableFrom(type)) {
+				insertCodeOfMessageUnpackCallForListType(sb, f, c);
+			} else if (Map.class.isAssignableFrom(c)) {
 				// Map
-				insertCodeOfMessageUnpackForMapType(sb, field, type);
-			} else if (MessageUnpackable.class.isAssignableFrom(type)
-					|| (getCache(type.getName()) != null)) {
+				insertCodeOfMessageUnpackCallForMapType(sb, f, c);
+			} else if (getCache(c.getName()) != null) {
+				// cached
+				insertCodeOfMessageUnpackCallForEnhancedType(sb, f, c);
+			} else if (MessageUnpackable.class.isAssignableFrom(c)) {
 				// MessageUnpackable
-				insertCodeOfMessageUnpackForMsgUnpackableType(sb, field, type);
+				insertCodeOfMessageUnpackCallForMsgUnpackableType(sb, f, c);
 			} else {
-				throw new NotFoundException("unknown type:  " + type.getName());
+				throw new NotFoundException("unknown type:  " + c.getName());
 			}
 		}
 
-		private void insertCodeOfMessageUnpackForPrimitiveTypes(
+		private void insertCodeOfMessageUnpackCallForPrimTypes(
 				StringBuilder sb, Field field, Class<?> type)
 				throws NotFoundException {
 			// insert a right variable
@@ -466,8 +499,9 @@ public class PackUnpackUtil {
 			}
 		}
 
-		private void insertCodeOfMessageUnpackForWrapperTypes(StringBuilder sb,
-				Field field, Class<?> type) throws NotFoundException {
+		private void insertCodeOfMessageUnpackCallForWrapTypes(
+				StringBuilder sb, Field field, Class<?> type)
+				throws NotFoundException {
 			// insert a right variable
 			if (field != null) {
 				sb.append(field.getName());
@@ -508,7 +542,7 @@ public class PackUnpackUtil {
 			}
 		}
 
-		private void insertCodeOfMessageUnpackForListType(StringBuilder sb,
+		private void insertCodeOfMessageUnpackCallForListType(StringBuilder sb,
 				Field field, Class<?> type) throws NotFoundException {
 			ParameterizedType generic = (ParameterizedType) field
 					.getGenericType();
@@ -575,7 +609,7 @@ public class PackUnpackUtil {
 			sb.append(Constants.CHAR_NAME_DOT);
 			sb.append(Constants.METHOD_NAME_ADD);
 			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
-			insertCodeOfMessageUnpack(sb, null, genericType);
+			insertCodeOfMessageUnpackCall(sb, null, genericType);
 			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
 			sb.append(Constants.CHAR_NAME_SEMICOLON);
 			sb.append(Constants.CHAR_NAME_SPACE);
@@ -584,7 +618,7 @@ public class PackUnpackUtil {
 			sb.append(Constants.CHAR_NAME_SPACE);
 		}
 
-		private void insertCodeOfMessageUnpackForMapType(StringBuilder sb,
+		private void insertCodeOfMessageUnpackCallForMapType(StringBuilder sb,
 				Field field, Class<?> type) throws NotFoundException {
 			ParameterizedType generic = (ParameterizedType) field
 					.getGenericType();
@@ -652,10 +686,10 @@ public class PackUnpackUtil {
 			sb.append(Constants.CHAR_NAME_DOT);
 			sb.append(Constants.METHOD_NAME_PUT);
 			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
-			insertCodeOfMessageUnpack(sb, null, genericType0);
+			insertCodeOfMessageUnpackCall(sb, null, genericType0);
 			sb.append(Constants.CHAR_NAME_COMMA);
 			sb.append(Constants.CHAR_NAME_SPACE);
-			insertCodeOfMessageUnpack(sb, null, genericType1);
+			insertCodeOfMessageUnpackCall(sb, null, genericType1);
 			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
 			sb.append(Constants.CHAR_NAME_SEMICOLON);
 			sb.append(Constants.CHAR_NAME_SPACE);
@@ -664,8 +698,42 @@ public class PackUnpackUtil {
 			sb.append(Constants.CHAR_NAME_SPACE);
 		}
 
-		private void insertCodeOfMessageUnpackForMsgUnpackableType(
-				StringBuilder sb, Field field, Class<?> type) {
+		private void insertCodeOfMessageUnpackCallForEnhancedType(
+				StringBuilder sb, Field f, Class<?> c) {
+			c = this.getCache(c.getName());
+			insertCodeOfMessageUnpackCallForMsgUnpackableType(sb, f, c);
+		}
+
+		private void insertCodeOfMessageUnpackCallForMsgUnpackableType(
+				StringBuilder sb, Field f, Class<?> c) {
+			// if (fi == null) { fi = new Foo_$$_Enhanced(); }
+			sb.append(Constants.KEYWORD_IF);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(f.getName());
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_EQUAL);
+			sb.append(Constants.CHAR_NAME_EQUAL);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.KEYWORD_NULL);
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_LEFT_CURLY_BRACHET);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(f.getName());
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_EQUAL);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.KEYWORD_NEW);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(c.getName());
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_SEMICOLON);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_RIGHT_CURLY_BRACHET);
+			sb.append(Constants.CHAR_NAME_SPACE);
+
 			// insert a right variable // ignore
 			sb.append(Constants.VARIABLE_NAME_PK);
 			sb.append(Constants.CHAR_NAME_DOT);
@@ -674,39 +742,511 @@ public class PackUnpackUtil {
 			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
 			sb.append(MessageUnpackable.class.getName());
 			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
-			sb.append(field.getName());
+			sb.append(f.getName());
 			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
 			sb.append(Constants.CHAR_NAME_SEMICOLON);
 			sb.append(Constants.CHAR_NAME_SPACE);
 		}
 
-		private void addMessageConvertMethod(CtClass enhCtClass,
-				CtClass origCtClass, Field[] fields)
+		private void addMessageConvertMethod(CtClass enhCtClass, Field[] fields)
 				throws CannotCompileException {
+			// messageConvert(MessagePackObject obj) throws MessageTypeException
 			StringBuilder sb = new StringBuilder();
-			sb.append(Constants.KEYWORD_MODIFIER_PUBLIC).append(
-					Constants.CHAR_NAME_SPACE).append(Constants.TYPE_NAME_VOID)
-					.append(Constants.CHAR_NAME_SPACE).append(
-							Constants.METHOD_NAME_MSGCONVERT).append(
-							Constants.CHAR_NAME_LEFT_PARENTHESIS).append(
-							Constants.TYPE_NAME_OBJECT).append(
-							Constants.CHAR_NAME_SPACE).append(
-							Constants.VARIABLE_NAME_OBJ).append(
-							Constants.CHAR_NAME_RIGHT_PARENTHESIS).append(
-							Constants.CHAR_NAME_SPACE).append(
-							Constants.KEYWORD_THROWS).append(
-							Constants.CHAR_NAME_SPACE).append(
-							Constants.TYPE_NAME_MSGTYPEEXCEPTION).append(
-							Constants.CHAR_NAME_SPACE).append(
-							Constants.CHAR_NAME_LEFT_CURLY_BRACHET).append(
-							Constants.CHAR_NAME_SPACE);
-			// TODO
+			sb.append(Constants.KEYWORD_MODIFIER_PUBLIC);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(void.class.getName());
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.METHOD_NAME_MSGCONVERT);
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(MessagePackObject.class.getName());
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.VARIABLE_NAME_MPO);
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.KEYWORD_THROWS);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(MessageTypeException.class.getName());
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_LEFT_CURLY_BRACHET);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			insertCodeOfMessagePackObjectArrayGet(sb);
+			insertCodeOfMesageConvertCalls(sb, fields);
 			sb.append(Constants.CHAR_NAME_RIGHT_CURLY_BRACHET);
-			//System.out.println("messageConvert method: " + sb.toString());
+			// System.out.println("messageConvert method: " + sb.toString());
 			CtMethod newCtMethod = CtNewMethod.make(sb.toString(), enhCtClass);
 			enhCtClass.addMethod(newCtMethod);
 		}
 
+		private void insertCodeOfMessagePackObjectArrayGet(StringBuilder sb) {
+			// MessagePackObject[] ary = obj.asArray();
+			sb.append(MessagePackObject.class.getName());
+			sb.append(Constants.CHAR_NAME_LEFT_SQUARE_BRACKET);
+			sb.append(Constants.CHAR_NAME_RIGHT_SQUARE_BRACKET);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.VARIABLE_NAME_ARRAY);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_EQUAL);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.VARIABLE_NAME_MPO);
+			sb.append(Constants.CHAR_NAME_DOT);
+			sb.append(Constants.METHOD_NAME_ASARRAY);
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_SEMICOLON);
+			sb.append(Constants.CHAR_NAME_SPACE);
+		}
+
+		private void insertCodeOfMesageConvertCalls(StringBuilder sb,
+				Field[] fields) {
+			for (int i = 0; i < fields.length; ++i) {
+				insertCodeOfMessageConvertCall(sb, fields[i], fields[i]
+						.getType(), i, null);
+			}
+		}
+
+		private void insertCodeOfMessageConvertCall(StringBuilder sb, Field f,
+				Class<?> c, int i, String v) {
+			if (c.isPrimitive()) { // primitive type
+				insertCodeOfMessageConvertCallForPrimTypes(sb, f, c, i, v);
+			} else { // reference type
+				if (c.equals(Boolean.class) || c.equals(Byte.class)
+						|| c.equals(Short.class) || c.equals(Integer.class)
+						|| c.equals(Float.class) || c.equals(Long.class)
+						|| c.equals(Double.class)) {
+					// wrapper type
+					insertCodeOfMessageConvertCallForWrapTypes(sb, f, c, i, v);
+				} else if (c.equals(String.class) || c.equals(byte[].class)
+						|| c.equals(BigInteger.class)) {
+					insertCodeOfMessageConvertCallForPrimTypes(sb, f, c, i, v);
+				} else if (List.class.isAssignableFrom(c)) {
+					insertCodeOfMessageConvertCallForList(sb, f, c, i);
+				} else if (Map.class.isAssignableFrom(c)) {
+					insertCodeOfMessageConvertCallForMap(sb, f, c, i);
+				} else if ((getCache(c.getName()) != null)) {
+					insertCodeOfMessageConvertCallForEnhancedType(sb, f, c, i);
+				} else if (MessageConvertable.class.isAssignableFrom(c)) {
+					insertCodeOfMessageConvertCallForMsgConvtblType(sb, f, c, i);
+				} else {
+					throw new MessageTypeException("Type error: " + c.getName());
+				}
+			}
+		}
+
+		private void insertCodeOfMessageConvertCallForEnhancedType(
+				StringBuilder sb, Field f, Class<?> c, int i) {
+			c = getCache(c.getName());
+			insertCodeOfMessageConvertCallForMsgConvtblType(sb, f, c, i);
+		}
+
+		private void insertCodeOfMessageConvertCallForMsgConvtblType(
+				StringBuilder sb, Field f, Class<?> c, int i) {
+			// if (fi == null) { fi = new Foo_$$_Enhanced(); }
+			sb.append(Constants.KEYWORD_IF);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(f.getName());
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_EQUAL);
+			sb.append(Constants.CHAR_NAME_EQUAL);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.KEYWORD_NULL);
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_LEFT_CURLY_BRACHET);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(f.getName());
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_EQUAL);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.KEYWORD_NEW);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(c.getName());
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_SEMICOLON);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_RIGHT_CURLY_BRACHET);
+			sb.append(Constants.CHAR_NAME_SPACE);
+
+			// ((MessageConvertable)f_i).messageConvert(ary[i]);
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(MessageConvertable.class.getName());
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(f.getName());
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_DOT);
+			sb.append(Constants.METHOD_NAME_MSGCONVERT);
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(Constants.VARIABLE_NAME_ARRAY);
+			sb.append(Constants.CHAR_NAME_LEFT_SQUARE_BRACKET);
+			sb.append(i);
+			sb.append(Constants.CHAR_NAME_RIGHT_SQUARE_BRACKET);
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_SEMICOLON);
+			sb.append(Constants.CHAR_NAME_SPACE);
+		}
+
+		private void insertCodeOfMessageConvertCallForPrimTypes(
+				StringBuilder sb, Field f, Class<?> c, int i, String name) {
+			// f0 = objs[0].intValue();
+			if (f != null) {
+				sb.append(f.getName());
+				sb.append(Constants.CHAR_NAME_SPACE);
+				sb.append(Constants.CHAR_NAME_EQUAL);
+				sb.append(Constants.CHAR_NAME_SPACE);
+				sb.append(Constants.VARIABLE_NAME_ARRAY);
+				sb.append(Constants.CHAR_NAME_LEFT_SQUARE_BRACKET);
+				sb.append(i);
+				sb.append(Constants.CHAR_NAME_RIGHT_SQUARE_BRACKET);
+			} else {
+				sb.append(name);
+			}
+			sb.append(Constants.CHAR_NAME_DOT);
+			if (c.equals(boolean.class)) {
+				sb.append(Constants.METHOD_NAME_ASBOOLEAN);
+			} else if (c.equals(byte.class)) {
+				sb.append(Constants.METHOD_NAME_ASBYTE);
+			} else if (c.equals(short.class)) {
+				sb.append(Constants.METHOD_NAME_ASSHORT);
+			} else if (c.equals(int.class)) {
+				sb.append(Constants.METHOD_NAME_ASINT);
+			} else if (c.equals(float.class)) {
+				sb.append(Constants.METHOD_NAME_ASFLOAT);
+			} else if (c.equals(long.class)) {
+				sb.append(Constants.METHOD_NAME_ASLONG);
+			} else if (c.equals(double.class)) {
+				sb.append(Constants.METHOD_NAME_ASDOUBLE);
+			} else if (c.equals(String.class)) {
+				sb.append(Constants.METHOD_NAME_ASSTRING);
+			} else if (c.equals(byte[].class)) {
+				sb.append(Constants.METHOD_NAME_ASBYTEARRAY);
+			} else if (c.equals(BigInteger.class)) {
+				sb.append(Constants.METHOD_NAME_ASBIGINTEGER);
+			} else {
+				throw new MessageTypeException("Type error: " + c.getName());
+			}
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			if (f != null) {
+				sb.append(Constants.CHAR_NAME_SEMICOLON);
+				sb.append(Constants.CHAR_NAME_SPACE);
+			}
+		}
+
+		private void insertCodeOfMessageConvertCallForWrapTypes(
+				StringBuilder sb, Field f, Class<?> c, int i, String v) {
+			if (f != null) {
+				sb.append(f.getName());
+				sb.append(Constants.CHAR_NAME_SPACE);
+				sb.append(Constants.CHAR_NAME_EQUAL);
+				sb.append(Constants.CHAR_NAME_SPACE);
+			}
+			sb.append(Constants.KEYWORD_NEW);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			if (c.equals(Boolean.class)) {
+				sb.append(Boolean.class.getName());
+			} else if (c.equals(Byte.class)) {
+				sb.append(Byte.class.getName());
+			} else if (c.equals(Short.class)) {
+				sb.append(Short.class.getName());
+			} else if (c.equals(Integer.class)) {
+				sb.append(Integer.class.getName());
+			} else if (c.equals(Float.class)) {
+				sb.append(Float.class.getName());
+			} else if (c.equals(Long.class)) {
+				sb.append(Long.class.getName());
+			} else if (c.equals(Double.class)) {
+				sb.append(Double.class.getName());
+			} else {
+				throw new MessageTypeException("Type error: " + c.getName());
+			}
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			if (f != null) {
+				sb.append(Constants.VARIABLE_NAME_ARRAY);
+				sb.append(Constants.CHAR_NAME_LEFT_SQUARE_BRACKET);
+				sb.append(i);
+				sb.append(Constants.CHAR_NAME_RIGHT_SQUARE_BRACKET);
+			} else {
+				sb.append(v);
+			}
+			sb.append(Constants.CHAR_NAME_DOT);
+			if (c.equals(Boolean.class)) {
+				sb.append(Constants.METHOD_NAME_ASBOOLEAN);
+			} else if (c.equals(Byte.class)) {
+				sb.append(Constants.METHOD_NAME_ASBYTE);
+			} else if (c.equals(Short.class)) {
+				sb.append(Constants.METHOD_NAME_ASSHORT);
+			} else if (c.equals(Integer.class)) {
+				sb.append(Constants.METHOD_NAME_ASINT);
+			} else if (c.equals(Float.class)) {
+				sb.append(Constants.METHOD_NAME_ASFLOAT);
+			} else if (c.equals(Long.class)) {
+				sb.append(Constants.METHOD_NAME_ASLONG);
+			} else if (c.equals(Double.class)) {
+				sb.append(Constants.METHOD_NAME_ASDOUBLE);
+			} else {
+				throw new MessageTypeException("Type error: " + c.getName());
+			}
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			if (f != null) {
+				sb.append(Constants.CHAR_NAME_SEMICOLON);
+				sb.append(Constants.CHAR_NAME_SPACE);
+			}
+		}
+
+		private void insertCodeOfMessageConvertCallForList(StringBuilder sb,
+				Field field, Class<?> type, int i) {
+			ParameterizedType generic = (ParameterizedType) field
+					.getGenericType();
+			Class<?> genericType = (Class<?>) generic.getActualTypeArguments()[0];
+
+			// List<MessagePackObject> list = ary[i].asList();
+			sb.append(List.class.getName());
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.VARIABLE_NAME_LIST);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_EQUAL);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.VARIABLE_NAME_ARRAY);
+			sb.append(Constants.CHAR_NAME_LEFT_SQUARE_BRACKET);
+			sb.append(i);
+			sb.append(Constants.CHAR_NAME_RIGHT_SQUARE_BRACKET);
+			sb.append(Constants.CHAR_NAME_DOT);
+			sb.append("asList");
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_SEMICOLON);
+			sb.append(Constants.CHAR_NAME_SPACE);
+
+			// int size = list.size();
+			sb.append(int.class.getName());
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.VARIABLE_NAME_SIZE);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_EQUAL);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.VARIABLE_NAME_LIST);
+			sb.append(Constants.CHAR_NAME_DOT);
+			sb.append(Constants.METHOD_NAME_SIZE);
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_SEMICOLON);
+			sb.append(Constants.CHAR_NAME_SPACE);
+
+			// field initializer
+			sb.append(field.getName());
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_EQUAL);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.KEYWORD_NEW);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(ArrayList.class.getName());
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_SEMICOLON);
+			sb.append(Constants.CHAR_NAME_SPACE);
+
+			// for loop
+			sb.append(Constants.KEYWORD_FOR);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(int.class.getName());
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.VARIABLE_NAME_I);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_EQUAL);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(0);
+			sb.append(Constants.CHAR_NAME_SEMICOLON);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.VARIABLE_NAME_I);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_LESSTHAN);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.VARIABLE_NAME_SIZE);
+			sb.append(Constants.CHAR_NAME_SEMICOLON);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_PLUS);
+			sb.append(Constants.CHAR_NAME_PLUS);
+			sb.append(Constants.VARIABLE_NAME_I);
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_SPACE);
+
+			// block begin
+			sb.append(Constants.CHAR_NAME_LEFT_CURLY_BRACHET);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(MessagePackObject.class.getName());
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.VARIABLE_NAME_VAL);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_EQUAL);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(MessagePackObject.class.getName());
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.VARIABLE_NAME_LIST);
+			sb.append(Constants.CHAR_NAME_DOT);
+			sb.append(Constants.METHOD_NAME_GET);
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(Constants.VARIABLE_NAME_I);
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_SEMICOLON);
+			sb.append(Constants.CHAR_NAME_SPACE);
+
+			sb.append(field.getName());
+			sb.append(Constants.CHAR_NAME_DOT);
+			sb.append(Constants.METHOD_NAME_ADD);
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			insertCodeOfMessageConvertCall(sb, null, genericType, -1,
+					Constants.VARIABLE_NAME_VAL);
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_SEMICOLON);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			// block end
+			sb.append(Constants.CHAR_NAME_RIGHT_CURLY_BRACHET);
+			sb.append(Constants.CHAR_NAME_SPACE);
+		}
+
+		private void insertCodeOfMessageConvertCallForMap(StringBuilder sb,
+				Field f, Class<?> c, int i) {
+			ParameterizedType generic = (ParameterizedType) f.getGenericType();
+			Class<?> genericType0 = (Class<?>) generic.getActualTypeArguments()[0];
+			Class<?> genericType1 = (Class<?>) generic.getActualTypeArguments()[1];
+
+			// Map<MessagePackObject, MessagePackObject> map = ary[i].asMap();
+			sb.append(Map.class.getName());
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.VARIABLE_NAME_MAP);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_EQUAL);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.VARIABLE_NAME_ARRAY);
+			sb.append(Constants.CHAR_NAME_LEFT_SQUARE_BRACKET);
+			sb.append(i);
+			sb.append(Constants.CHAR_NAME_RIGHT_SQUARE_BRACKET);
+			sb.append(Constants.CHAR_NAME_DOT);
+			sb.append("asMap");
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_SEMICOLON);
+			sb.append(Constants.CHAR_NAME_SPACE);
+
+			// int size = list.size();
+			sb.append(int.class.getName());
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.VARIABLE_NAME_SIZE);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_EQUAL);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.VARIABLE_NAME_MAP);
+			sb.append(Constants.CHAR_NAME_DOT);
+			sb.append(Constants.METHOD_NAME_SIZE);
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_SEMICOLON);
+			sb.append(Constants.CHAR_NAME_SPACE);
+
+			// field initializer
+			sb.append(f.getName());
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_EQUAL);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.KEYWORD_NEW);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(HashMap.class.getName());
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_SEMICOLON);
+			sb.append(Constants.CHAR_NAME_SPACE);
+
+			// for loop
+			sb.append(Constants.KEYWORD_FOR);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(Iterator.class.getName());
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.VARIABLE_NAME_ITER);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_EQUAL);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.VARIABLE_NAME_MAP);
+			sb.append(Constants.CHAR_NAME_DOT);
+			sb.append(Constants.METHOD_NAME_KEYSET);
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_DOT);
+			sb.append(Constants.METHOD_NAME_ITERATOR);
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_SEMICOLON);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.VARIABLE_NAME_ITER);
+			sb.append(Constants.CHAR_NAME_DOT);
+			sb.append(Constants.METHOD_NAME_HASNEXT);
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_SEMICOLON);
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_LEFT_CURLY_BRACHET);
+			sb.append(Constants.CHAR_NAME_SPACE);
+
+			// block map.
+			sb.append(MessagePackObject.class.getName());
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.VARIABLE_NAME_KEY);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_EQUAL);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(MessagePackObject.class.getName());
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.VARIABLE_NAME_ITER);
+			sb.append(Constants.CHAR_NAME_DOT);
+			sb.append(Constants.METHOD_NAME_NEXT);
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_SEMICOLON);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(MessagePackObject.class.getName());
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.VARIABLE_NAME_VAL);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_EQUAL);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(MessagePackObject.class.getName());
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.VARIABLE_NAME_MAP);
+			sb.append(Constants.CHAR_NAME_DOT);
+			sb.append(Constants.METHOD_NAME_GET);
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			sb.append(Constants.VARIABLE_NAME_KEY);
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_SEMICOLON);
+			sb.append(Constants.CHAR_NAME_SPACE);
+
+			sb.append(f.getName());
+			sb.append(Constants.CHAR_NAME_DOT);
+			sb.append(Constants.METHOD_NAME_PUT);
+			sb.append(Constants.CHAR_NAME_LEFT_PARENTHESIS);
+			insertCodeOfMessageConvertCall(sb, null, genericType0, -1,
+					Constants.VARIABLE_NAME_KEY);
+			sb.append(Constants.CHAR_NAME_COMMA);
+			sb.append(Constants.CHAR_NAME_SPACE);
+			insertCodeOfMessageConvertCall(sb, null, genericType1, -1,
+					Constants.VARIABLE_NAME_VAL);
+			sb.append(Constants.CHAR_NAME_RIGHT_PARENTHESIS);
+			sb.append(Constants.CHAR_NAME_SEMICOLON);
+			sb.append(Constants.CHAR_NAME_SPACE);
+
+			sb.append(Constants.CHAR_NAME_RIGHT_CURLY_BRACHET);
+			sb.append(Constants.CHAR_NAME_SPACE);
+		}
+
 		private Class<?> createClass(CtClass enhCtClass)
 				throws CannotCompileException {
 			return enhCtClass.toClass(null, null);
@@ -715,17 +1255,17 @@ public class PackUnpackUtil {
 
 	private static Enhancer enhancer;
 
-	public static Class<?> getEnhancedClass(Class<?> origClass) {
+	public static void registerEnhancedClass(Class<?> origClass,
+			boolean packUnpackable) {
 		if (enhancer == null) {
 			enhancer = new Enhancer();
 		}
-
 		String origName = origClass.getName();
 		Class<?> enhClass = enhancer.getCache(origName);
 		if (enhClass == null) {
 			// generate a class object related to the original class
 			try {
-				enhClass = enhancer.generate(origClass);
+				enhClass = enhancer.generate(origClass, packUnpackable);
 			} catch (NotFoundException e) {
 				throw new PackUnpackUtilException(e.getMessage(), e);
 			} catch (CannotCompileException e) {
@@ -734,12 +1274,35 @@ public class PackUnpackUtil {
 			// set the generated class to the cache
 			enhancer.setCache(origName, enhClass);
 		}
-		return enhClass;
 	}
 
-	public static Object newEnhancedInstance(Class<?> origClass) {
+	public static void registerEnhancedClass(Class<?> origClass) {
+		registerEnhancedClass(origClass, false);
+	}
+
+	public static boolean isRegistered(Class<?> origClass) {
+		if (enhancer == null) {
+			enhancer = new Enhancer();
+		}
+		return enhancer.getCache(origClass.getName()) != null;
+	}
+
+	public static Class<?> getEnhancedClass(Class<?> origClass,
+			boolean packUnpackable) {
+		if (!isRegistered(origClass)) {
+			registerEnhancedClass(origClass, packUnpackable);
+		}
+		return enhancer.getCache(origClass.getName());
+	}
+
+	public static Class<?> getEnhancedClass(Class<?> origClass) {
+		return getEnhancedClass(origClass, false);
+	}
+
+	public static Object newEnhancedInstance(Class<?> origClass,
+			boolean packUnpackable) {
 		try {
-			Class<?> enhClass = getEnhancedClass(origClass);
+			Class<?> enhClass = getEnhancedClass(origClass, packUnpackable);
 			// create a new object of the generated class
 			return enhClass.newInstance();
 		} catch (InstantiationException e) {
@@ -749,6 +1312,22 @@ public class PackUnpackUtil {
 		}
 	}
 
+	public static Object newEnhancedInstance(Class<?> origClass) {
+		return newEnhancedInstance(origClass, false);
+	}
+
+	public static Object initEnhancedInstance(MessagePackObject obj,
+			Class<?> origClass, boolean packUnpackable) {
+		Object ret = newEnhancedInstance(origClass, packUnpackable);
+		((MessageConvertable) ret).messageConvert(obj);
+		return ret;
+	}
+
+	public static Object initEnhancedInstance(MessagePackObject obj,
+			Class<?> origClass) {
+		return initEnhancedInstance(obj, origClass, false);
+	}
+
 	@MessagePackUnpackable
 	public static class Image {
 		public String uri = "";
@@ -776,7 +1355,6 @@ public class PackUnpackUtil {
 	}
 
 	public static void main(final String[] args) throws Exception {
-		PackUnpackUtil.getEnhancedClass(Image.class);
 		Image src = (Image) PackUnpackUtil.newEnhancedInstance(Image.class);
 		src.title = "msgpack";
 		src.uri = "http://msgpack.org/";
@@ -789,6 +1367,6 @@ public class PackUnpackUtil {
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
 		Unpacker pac = new Unpacker(in);
 		pac.unpack((MessageUnpackable) dst);
-		//System.out.println(src.equals(dst));
+		// System.out.println(src.equals(dst));
 	}
 }
diff --git a/java/src/test/java/org/msgpack/TestReflectionPackerTemplate.java b/java/src/test/java/org/msgpack/TestReflectionPackerTemplate.java
new file mode 100644
index 0000000..f361eb4
--- /dev/null
+++ b/java/src/test/java/org/msgpack/TestReflectionPackerTemplate.java
@@ -0,0 +1,46 @@
+package org.msgpack;
+
+import static org.msgpack.Templates.*;
+
+import java.util.*;
+import java.io.*;
+
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class TestReflectionPackerTemplate {
+
+	public static class StringFieldClass {
+		public String s1;
+		public String s2;
+		public StringFieldClass() { }
+	}
+
+	@Test
+	public void testPackConvert() throws Exception {
+		tString();  // FIXME link StringTemplate
+
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+
+		MessagePacker packer = ReflectionPacker.create(StringFieldClass.class);
+
+		StringFieldClass src = new StringFieldClass();
+
+		src.s1 = "kumofs";
+		src.s2 = "frsyuki";
+
+		packer.pack(new Packer(out), src);
+
+		Template tmpl = ReflectionTemplate.create(StringFieldClass.class);
+
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+
+		Object obj = tmpl.unpack(new Unpacker(in));
+		assertEquals(obj.getClass(), StringFieldClass.class);
+
+		StringFieldClass dst = (StringFieldClass)obj;
+		assertEquals(src.s1, dst.s1);
+		assertEquals(src.s2, dst.s2);
+	}
+}
+
diff --git a/java/src/test/java/org/msgpack/util/annotation/TestMessagePackUnpackable.java b/java/src/test/java/org/msgpack/util/annotation/TestMessagePackUnpackable.java
index dbea7cb..08c4fa8 100644
--- a/java/src/test/java/org/msgpack/util/annotation/TestMessagePackUnpackable.java
+++ b/java/src/test/java/org/msgpack/util/annotation/TestMessagePackUnpackable.java
@@ -12,6 +12,7 @@ import java.util.Map;
 import junit.framework.TestCase;
 
 import org.junit.Test;
+import org.msgpack.MessagePackObject;
 import org.msgpack.MessageUnpackable;
 import org.msgpack.Packer;
 import org.msgpack.Unpacker;
@@ -19,7 +20,7 @@ import org.msgpack.Unpacker;
 public class TestMessagePackUnpackable extends TestCase {
 
 	@Test
-	public void testPrimitiveTypeFields() throws Exception {
+	public void testPrimitiveTypeFields01() throws Exception {
 		PrimitiveTypeFieldsClass src = (PrimitiveTypeFieldsClass) PackUnpackUtil
 				.newEnhancedInstance(PrimitiveTypeFieldsClass.class);
 		src.f0 = (byte) 0;
@@ -45,6 +46,36 @@ public class TestMessagePackUnpackable extends TestCase {
 		assertEquals(src.f6, dst.f6);
 	}
 
+	@Test
+	public void testPrimitiveTypeFields02() throws Exception {
+		PrimitiveTypeFieldsClass src = (PrimitiveTypeFieldsClass) PackUnpackUtil
+				.newEnhancedInstance(PrimitiveTypeFieldsClass.class);
+		src.f0 = (byte) 0;
+		src.f1 = 1;
+		src.f2 = 2;
+		src.f3 = 3;
+		src.f4 = 4;
+		src.f5 = 5;
+		src.f6 = false;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		new Packer(out).pack(src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		PrimitiveTypeFieldsClass dst = (PrimitiveTypeFieldsClass) PackUnpackUtil
+				.initEnhancedInstance(mpo, PrimitiveTypeFieldsClass.class);
+		assertEquals(src.f0, dst.f0);
+		assertEquals(src.f1, dst.f1);
+		assertEquals(src.f2, dst.f2);
+		assertEquals(src.f3, dst.f3);
+		assertEquals(src.f4, dst.f4);
+		assertEquals(src.f5, dst.f5);
+		assertEquals(src.f6, dst.f6);
+		assertFalse(it.hasNext());
+	}
+
 	@MessagePackUnpackable
 	public static class PrimitiveTypeFieldsClass {
 		public byte f0;
@@ -60,7 +91,7 @@ public class TestMessagePackUnpackable extends TestCase {
 	}
 
 	@Test
-	public void testGeneralReferenceTypeFieldsClass() throws Exception {
+	public void testGeneralReferenceTypeFieldsClass01() throws Exception {
 		GeneralReferenceTypeFieldsClass src = (GeneralReferenceTypeFieldsClass) PackUnpackUtil
 				.newEnhancedInstance(GeneralReferenceTypeFieldsClass.class);
 		src.f0 = 0;
@@ -93,6 +124,44 @@ public class TestMessagePackUnpackable extends TestCase {
 		assertEquals(src.f9[1], dst.f9[1]);
 	}
 
+	@Test
+	public void testGeneralReferenceTypeFieldsClass02() throws Exception {
+		GeneralReferenceTypeFieldsClass src = (GeneralReferenceTypeFieldsClass) PackUnpackUtil
+				.newEnhancedInstance(GeneralReferenceTypeFieldsClass.class);
+		src.f0 = 0;
+		src.f1 = 1;
+		src.f2 = 2;
+		src.f3 = (long) 3;
+		src.f4 = (float) 4;
+		src.f5 = (double) 5;
+		src.f6 = false;
+		src.f7 = new BigInteger("7");
+		src.f8 = "8";
+		src.f9 = new byte[] { 0x01, 0x02 };
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		new Packer(out).pack(src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		GeneralReferenceTypeFieldsClass dst = (GeneralReferenceTypeFieldsClass) PackUnpackUtil
+				.initEnhancedInstance(mpo,
+						GeneralReferenceTypeFieldsClass.class);
+		assertEquals(src.f0, dst.f0);
+		assertEquals(src.f1, dst.f1);
+		assertEquals(src.f2, dst.f2);
+		assertEquals(src.f3, dst.f3);
+		assertEquals(src.f4, dst.f4);
+		assertEquals(src.f5, dst.f5);
+		assertEquals(src.f6, dst.f6);
+		assertEquals(src.f7, dst.f7);
+		assertEquals(src.f8, dst.f8);
+		assertEquals(src.f9[0], dst.f9[0]);
+		assertEquals(src.f9[1], dst.f9[1]);
+		assertFalse(it.hasNext());
+	}
+
 	@MessagePackUnpackable
 	public static class GeneralReferenceTypeFieldsClass {
 		public Byte f0;
@@ -110,7 +179,7 @@ public class TestMessagePackUnpackable extends TestCase {
 		}
 	}
 
-	public void testListTypes() throws Exception {
+	public void testListTypes01() throws Exception {
 		SampleListTypes src = (SampleListTypes) PackUnpackUtil
 				.newEnhancedInstance(SampleListTypes.class);
 		src.f0 = new ArrayList<Integer>();
@@ -140,6 +209,39 @@ public class TestMessagePackUnpackable extends TestCase {
 		}
 	}
 
+	public void testListTypes02() throws Exception {
+		SampleListTypes src = (SampleListTypes) PackUnpackUtil
+				.newEnhancedInstance(SampleListTypes.class);
+		src.f0 = new ArrayList<Integer>();
+		src.f1 = new ArrayList<Integer>();
+		src.f1.add(1);
+		src.f1.add(2);
+		src.f1.add(3);
+		src.f2 = new ArrayList<String>();
+		src.f2.add("e1");
+		src.f2.add("e2");
+		src.f2.add("e3");
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		new Packer(out).pack(src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		SampleListTypes dst = (SampleListTypes) PackUnpackUtil
+				.initEnhancedInstance(mpo, SampleListTypes.class);
+		assertEquals(src.f0.size(), dst.f0.size());
+		assertEquals(src.f1.size(), dst.f1.size());
+		for (int i = 0; i < src.f1.size(); ++i) {
+			assertEquals(src.f1.get(i), dst.f1.get(i));
+		}
+		assertEquals(src.f2.size(), dst.f2.size());
+		for (int i = 0; i < src.f2.size(); ++i) {
+			assertEquals(src.f2.get(i), dst.f2.get(i));
+		}
+		assertFalse(it.hasNext());
+	}
+
 	@MessagePackUnpackable
 	public static class SampleListTypes {
 		public List<Integer> f0;
@@ -150,7 +252,7 @@ public class TestMessagePackUnpackable extends TestCase {
 		}
 	}
 
-	public void testMapTypes() throws Exception {
+	public void testMapTypes01() throws Exception {
 		SampleMapTypes src = (SampleMapTypes) PackUnpackUtil
 				.newEnhancedInstance(SampleMapTypes.class);
 		src.f0 = new HashMap<Integer, Integer>();
@@ -190,6 +292,49 @@ public class TestMessagePackUnpackable extends TestCase {
 		}
 	}
 
+	public void testMapTypes02() throws Exception {
+		SampleMapTypes src = (SampleMapTypes) PackUnpackUtil
+				.newEnhancedInstance(SampleMapTypes.class);
+		src.f0 = new HashMap<Integer, Integer>();
+		src.f1 = new HashMap<Integer, Integer>();
+		src.f1.put(1, 1);
+		src.f1.put(2, 2);
+		src.f1.put(3, 3);
+		src.f2 = new HashMap<String, Integer>();
+		src.f2.put("k1", 1);
+		src.f2.put("k2", 2);
+		src.f2.put("k3", 3);
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		new Packer(out).pack(src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		SampleMapTypes dst = (SampleMapTypes) PackUnpackUtil
+				.initEnhancedInstance(mpo, SampleMapTypes.class);
+		assertEquals(src.f0.size(), dst.f0.size());
+		assertEquals(src.f1.size(), dst.f1.size());
+		Iterator<Integer> srcf1 = src.f1.keySet().iterator();
+		Iterator<Integer> dstf1 = dst.f1.keySet().iterator();
+		while (srcf1.hasNext()) {
+			Integer s1 = srcf1.next();
+			Integer d1 = dstf1.next();
+			assertEquals(s1, d1);
+			assertEquals(src.f1.get(s1), dst.f1.get(d1));
+		}
+		assertEquals(src.f2.size(), dst.f2.size());
+		Iterator<String> srcf2 = src.f2.keySet().iterator();
+		Iterator<String> dstf2 = dst.f2.keySet().iterator();
+		while (srcf2.hasNext()) {
+			String s2 = srcf2.next();
+			String d2 = dstf2.next();
+			assertEquals(s2, d2);
+			assertEquals(src.f2.get(s2), dst.f2.get(d2));
+		}
+		assertFalse(it.hasNext());
+	}
+
 	@MessagePackUnpackable
 	public static class SampleMapTypes {
 		public Map<Integer, Integer> f0;
@@ -351,7 +496,7 @@ public class TestMessagePackUnpackable extends TestCase {
 	}
 
 	@Test
-	public void testFieldModifiers() throws Exception {
+	public void testFieldModifiers01() throws Exception {
 		FieldModifiersClass src = (FieldModifiersClass) PackUnpackUtil
 				.newEnhancedInstance(FieldModifiersClass.class);
 		src.f0 = 0;
@@ -372,6 +517,31 @@ public class TestMessagePackUnpackable extends TestCase {
 		assertTrue(src.f4 != dst.f4);
 	}
 
+	@Test
+	public void testFieldModifiers02() throws Exception {
+		FieldModifiersClass src = (FieldModifiersClass) PackUnpackUtil
+				.newEnhancedInstance(FieldModifiersClass.class);
+		src.f0 = 0;
+		src.f2 = 2;
+		src.f3 = 3;
+		src.f4 = 4;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		new Packer(out).pack(src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		FieldModifiersClass dst = (FieldModifiersClass) PackUnpackUtil
+				.initEnhancedInstance(mpo, FieldModifiersClass.class);
+		assertTrue(src.f0 == dst.f0);
+		assertTrue(src.f1 == dst.f1);
+		assertTrue(src.f2 != dst.f2);
+		assertTrue(src.f3 == dst.f3);
+		assertTrue(src.f4 != dst.f4);
+		assertFalse(it.hasNext());
+	}
+
 	@MessagePackUnpackable
 	public static class FieldModifiersClass {
 		public int f0;
@@ -385,7 +555,7 @@ public class TestMessagePackUnpackable extends TestCase {
 	}
 
 	@Test
-	public void testNestedAnnotatedFieldClass() throws Exception {
+	public void testNestedAnnotatedFieldClass01() throws Exception {
 		NestedClass src2 = (NestedClass) PackUnpackUtil
 				.newEnhancedInstance(NestedClass.class);
 		BaseClass src = (BaseClass) PackUnpackUtil
@@ -395,11 +565,8 @@ public class TestMessagePackUnpackable extends TestCase {
 		src.f1 = src2;
 		ByteArrayOutputStream out = new ByteArrayOutputStream();
 		new Packer(out).pack(src);
-		NestedClass dst2 = (NestedClass) PackUnpackUtil
-				.newEnhancedInstance(NestedClass.class);
 		BaseClass dst = (BaseClass) PackUnpackUtil
 				.newEnhancedInstance(BaseClass.class);
-		dst.f1 = dst2;
 		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
 		Unpacker pac = new Unpacker(in);
 		pac.unpack((MessageUnpackable) dst);
@@ -407,6 +574,29 @@ public class TestMessagePackUnpackable extends TestCase {
 		assertTrue(src2.f2 == dst.f1.f2);
 	}
 
+	@Test
+	public void testNestedAnnotatedFieldClass02() throws Exception {
+		NestedClass src2 = (NestedClass) PackUnpackUtil
+				.newEnhancedInstance(NestedClass.class);
+		BaseClass src = (BaseClass) PackUnpackUtil
+				.newEnhancedInstance(BaseClass.class);
+		src.f0 = 0;
+		src2.f2 = 2;
+		src.f1 = src2;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		new Packer(out).pack(src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		BaseClass dst = (BaseClass) PackUnpackUtil.initEnhancedInstance(mpo,
+				BaseClass.class);
+		assertTrue(src.f0 == dst.f0);
+		assertTrue(src2.f2 == dst.f1.f2);
+		assertFalse(it.hasNext());
+	}
+
 	@MessagePackUnpackable
 	public static class BaseClass {
 		public int f0;
@@ -425,7 +615,7 @@ public class TestMessagePackUnpackable extends TestCase {
 	}
 
 	@Test
-	public void testExtendedClass() throws Exception {
+	public void testExtendedClass01() throws Exception {
 		SampleSubClass src = (SampleSubClass) PackUnpackUtil
 				.newEnhancedInstance(SampleSubClass.class);
 		src.f0 = 0;
@@ -453,6 +643,38 @@ public class TestMessagePackUnpackable extends TestCase {
 		assertTrue(src.f9 != dst.f9);
 	}
 
+	@Test
+	public void testExtendedClass02() throws Exception {
+		SampleSubClass src = (SampleSubClass) PackUnpackUtil
+				.newEnhancedInstance(SampleSubClass.class);
+		src.f0 = 0;
+		src.f2 = 2;
+		src.f3 = 3;
+		src.f4 = 4;
+		src.f5 = 5;
+		src.f8 = 8;
+		src.f9 = 9;
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		new Packer(out).pack(src);
+		ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
+		Unpacker pac = new Unpacker(in);
+		Iterator<MessagePackObject> it = pac.iterator();
+		assertTrue(it.hasNext());
+		MessagePackObject mpo = it.next();
+		SampleSubClass dst = (SampleSubClass) PackUnpackUtil
+				.initEnhancedInstance(mpo, SampleSubClass.class);
+		assertTrue(src.f0 == dst.f0);
+		assertTrue(src.f1 == dst.f1);
+		assertTrue(src.f2 != dst.f2);
+		assertTrue(src.f3 == dst.f3);
+		assertTrue(src.f4 != dst.f4);
+		assertTrue(src.f5 == dst.f5);
+		assertTrue(src.f6 == dst.f6);
+		assertTrue(src.f8 == dst.f8);
+		assertTrue(src.f9 != dst.f9);
+		assertFalse(it.hasNext());
+	}
+
 	@MessagePackUnpackable
 	public static class SampleSubClass extends SampleSuperClass {
 		public int f0;