import MessagePack for Java implementation plan 3

java-plan3/src/org/msgpack/schema/ArraySchema.java

@@ -0,0 +1,125 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009 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.schema;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Set;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.RandomAccess;
+import java.io.IOException;
+import org.msgpack.*;
+
+public class ArraySchema extends Schema implements IArraySchema {
+	private Schema elementSchema;
+
+	public ArraySchema(Schema elementSchema)
+	{
+		super("array");
+		this.elementSchema = elementSchema;
+	}
+
+	@Override
+	public String getFullName()
+	{
+		return "List<"+elementSchema.getFullName()+">";
+	}
+
+	@Override
+	public String getExpression()
+	{
+		return "(array "+elementSchema.getExpression()+")";
+	}
+
+	@Override
+	@SuppressWarnings("unchecked")
+	public void pack(Packer pk, Object obj) throws IOException
+	{
+		if(obj instanceof List) {
+			ArrayList<Object> d = (ArrayList<Object>)obj;
+			pk.packArray(d.size());
+			if(obj instanceof RandomAccess) {
+				for(int i=0; i < d.size(); ++i) {
+					elementSchema.pack(pk, d.get(i));
+				}
+			} else {
+				for(Object e : d) {
+					elementSchema.pack(pk, e);
+				}
+			}
+
+		} else if(obj instanceof Set) {
+			Set<Object> d = (Set<Object>)obj;
+			pk.packArray(d.size());
+			for(Object e : d) {
+				elementSchema.pack(pk, e);
+			}
+
+		} else if(obj == null) {
+			pk.packNil();
+
+		} else {
+			throw MessageTypeException.invalidConvert(obj, this);
+		}
+	}
+
+	@Override
+	@SuppressWarnings("unchecked")
+	public Object convert(Object obj) throws MessageTypeException
+	{
+		if(obj instanceof List) {
+			List d = (List)obj;
+			ArrayList ar = new ArrayList(d.size());
+			if(obj instanceof RandomAccess) {
+				for(int i=0; i < d.size(); ++i) {
+					ar.add( elementSchema.convert(d.get(i)) );
+				}
+			} else {
+				for(Object e : d) {
+					ar.add( elementSchema.convert(e) );
+				}
+			}
+			return ar;
+
+		} else if(obj instanceof Collection) {
+			Collection d = (Collection)obj;
+			ArrayList ar = new ArrayList(d.size());
+			for(Object e : (Collection)obj) {
+				ar.add( elementSchema.convert(e) );
+			}
+			return ar;
+
+		} else {
+			throw MessageTypeException.invalidConvert(obj, this);
+		}
+	}
+
+	@Override
+	public Schema getElementSchema(int index)
+	{
+		return elementSchema;
+	}
+
+	@Override
+	public Object createFromArray(Object[] obj)
+	{
+		return Arrays.asList(obj);
+	}
+}
+

java-plan3/src/org/msgpack/schema/ByteSchema.java

@@ -0,0 +1,89 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009 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.schema;
+
+import java.io.IOException;
+import org.msgpack.*;
+
+public class ByteSchema extends Schema {
+	public ByteSchema() {
+		super("Byte");
+	}
+
+	@Override
+	public String getExpression() {
+		return "byte";
+	}
+
+	@Override
+	public void pack(Packer pk, Object obj) throws IOException {
+		if(obj instanceof Number) {
+			pk.packByte( ((Number)obj).byteValue() );
+
+		} else if(obj == null) {
+			pk.packNil();
+
+		} else {
+			throw MessageTypeException.invalidConvert(obj, this);
+		}
+	}
+
+	@Override
+	public Object convert(Object obj) throws MessageTypeException {
+		if(obj instanceof Byte) {
+			return obj;
+
+		} else if(obj instanceof Number) {
+			return ((Number)obj).byteValue();
+
+		} else {
+			throw MessageTypeException.invalidConvert(obj, this);
+		}
+	}
+
+	@Override
+	public Object createFromByte(byte v) {
+		return (byte)v;
+	}
+
+	@Override
+	public Object createFromShort(short v) {
+		return (byte)v;
+	}
+
+	@Override
+	public Object createFromInt(int v) {
+		return (byte)v;
+	}
+
+	@Override
+	public Object createFromLong(long v) {
+		return (byte)v;
+	}
+
+	@Override
+	public Object createFromFloat(float v) {
+		return (byte)v;
+	}
+
+	@Override
+	public Object createFromDouble(double v) {
+		return (byte)v;
+	}
+}
+

java-plan3/src/org/msgpack/schema/ClassGenerator.java

@@ -0,0 +1,241 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009 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.schema;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.io.IOException;
+import java.io.File;
+import java.io.Writer;
+import org.msgpack.*;
+
+public class ClassGenerator {
+	private ClassSchema schema;
+	private Writer writer;
+	private int indent;
+
+	private ClassGenerator(Writer writer) {
+		this.writer = writer;
+		this.indent = 0;
+	}
+
+	public static void write(Schema schema, Writer dest) throws IOException {
+		if(!(schema instanceof ClassSchema)) {
+			throw new RuntimeException("schema is not class schema");
+		}
+		ClassSchema cs = (ClassSchema)schema;
+		new ClassGenerator(dest).run(cs);
+	}
+
+	private void run(ClassSchema cs) throws IOException {
+		List<ClassSchema> subclasses = new ArrayList<ClassSchema>();
+		for(FieldSchema f : cs.getFields()) {
+			findSubclassSchema(subclasses, f.getSchema());
+		}
+
+		for(ClassSchema sub : subclasses) {
+			sub.setNamespace(cs.getNamespace());
+			sub.setImports(cs.getImports());
+		}
+
+		this.schema = cs;
+
+		writeHeader();
+
+		writeClass();
+
+		for(ClassSchema sub : subclasses) {
+			this.schema = sub;
+			writeSubclass();
+		}
+
+		writeFooter();
+
+		this.schema = null;
+		writer.flush();
+	}
+
+	private void findSubclassSchema(List<ClassSchema> dst, Schema s) {
+		if(s instanceof ClassSchema) {
+			ClassSchema cs = (ClassSchema)s;
+			if(!dst.contains(cs)) { dst.add(cs); }
+			for(FieldSchema f : cs.getFields()) {
+				findSubclassSchema(dst, f.getSchema());
+			}
+		} else if(s instanceof ArraySchema) {
+			ArraySchema as = (ArraySchema)s;
+			findSubclassSchema(dst, as.getElementSchema(0));
+		} else if(s instanceof MapSchema) {
+			MapSchema as = (MapSchema)s;
+			findSubclassSchema(dst, as.getKeySchema());
+			findSubclassSchema(dst, as.getValueSchema());
+		}
+	}
+
+	private void writeHeader() throws IOException {
+		if(schema.getNamespace() != null) {
+			line("package "+schema.getNamespace()+";");
+			line();
+		}
+		line("import java.util.*;");
+		line("import java.io.*;");
+		line("import org.msgpack.*;");
+		line("import org.msgpack.schema.ClassSchema;");
+		line("import org.msgpack.schema.FieldSchema;");
+	}
+
+	private void writeFooter() throws IOException {
+		line();
+	}
+
+	private void writeClass() throws IOException {
+		line();
+		line("public final class "+schema.getName()+" implements MessagePackable, MessageMergeable");
+		line("{");
+		pushIndent();
+			writeSchema();
+			writeMemberVariables();
+			writeMemberFunctions();
+		popIndent();
+		line("}");
+	}
+
+	private void writeSubclass() throws IOException {
+		line();
+		line("final class "+schema.getName()+" implements MessagePackable, MessageMergeable");
+		line("{");
+		pushIndent();
+			writeSchema();
+			writeMemberVariables();
+			writeMemberFunctions();
+		popIndent();
+		line("}");
+	}
+
+	private void writeSchema() throws IOException {
+		line("private static final ClassSchema _SCHEMA = (ClassSchema)Schema.load(\""+schema.getExpression()+"\");");
+		line("public static ClassSchema getSchema() { return _SCHEMA; }");
+	}
+
+	private void writeMemberVariables() throws IOException {
+		line();
+		for(FieldSchema f : schema.getFields()) {
+			line("public "+f.getSchema().getFullName()+" "+f.getName()+";");
+		}
+	}
+
+	private void writeMemberFunctions() throws IOException {
+		// void messagePack(Packer pk)
+		// boolean equals(Object obj)
+		// int hashCode()
+		// void set(int _index, Object _value)
+		// Object get(int _index);
+		// getXxx()
+		// setXxx(Xxx xxx)
+		writeConstructors();
+		writeAccessors();
+		writePackFunction();
+		writeMergeFunction();
+		writeFactoryFunction();
+	}
+
+	private void writeConstructors() throws IOException {
+		line();
+		line("public "+schema.getName()+"() { }");
+	}
+
+	private void writeAccessors() throws IOException {
+		// FIXME
+		//line();
+		//for(FieldSchema f : schema.getFields()) {
+		//	line("");
+		//}
+	}
+
+	private void writePackFunction() throws IOException {
+		line();
+		line("@Override");
+		line("public void messagePack(Packer _pk) throws IOException");
+		line("{");
+		pushIndent();
+			line("_pk.packArray("+schema.getFields().length+");");
+			line("FieldSchema[] _fields = _SCHEMA.getFields();");
+			int i = 0;
+			for(FieldSchema f : schema.getFields()) {
+				line("_fields["+i+"].getSchema().pack(_pk, "+f.getName()+");");
+				++i;
+			}
+		popIndent();
+		line("}");
+	}
+
+	private void writeMergeFunction() throws IOException {
+		line();
+		line("@Override");
+		line("@SuppressWarnings(\"unchecked\")");
+		line("public void messageMerge(Object obj) throws MessageTypeException");
+		line("{");
+		pushIndent();
+			line("Object[] _source = ((List)obj).toArray();");
+			line("FieldSchema[] _fields = _SCHEMA.getFields();");
+			int i = 0;
+			for(FieldSchema f : schema.getFields()) {
+				line("if(_source.length <= "+i+") { return; } this."+f.getName()+" = ("+f.getSchema().getFullName()+")_fields["+i+"].getSchema().convert(_source["+i+"]);");
+				++i;
+			}
+		popIndent();
+		line("}");
+	}
+
+	private void writeFactoryFunction() throws IOException {
+		line();
+		line("@SuppressWarnings(\"unchecked\")");
+		line("public static "+schema.getName()+" createFromMessage(Object[] _message)");
+		line("{");
+		pushIndent();
+			line(schema.getName()+" _self = new "+schema.getName()+"();");
+			int i = 0;
+			for(FieldSchema f : schema.getFields()) {
+				line("if(_message.length <= "+i+") { return _self; } _self."+f.getName()+" = ("+f.getSchema().getFullName()+")_message["+i+"];");
+				++i;
+			}
+			line("return _self;");
+		popIndent();
+		line("}");
+	}
+
+	private void line(String str) throws IOException {
+		for(int i=0; i < indent; ++i) {
+			writer.write("\t");
+		}
+		writer.write(str+"\n");
+	}
+
+	private void line() throws IOException {
+		writer.write("\n");
+	}
+
+	private void pushIndent() {
+		indent += 1;
+	}
+
+	private void popIndent() {
+		indent -= 1;
+	}
+}
+

java-plan3/src/org/msgpack/schema/ClassSchema.java

@@ -0,0 +1,95 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009 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.schema;
+
+import java.util.Arrays;
+import java.util.List;
+import org.msgpack.*;
+
+public abstract class ClassSchema extends Schema implements IArraySchema {
+	protected FieldSchema[] fields;
+	protected List<String> imports;
+	protected String namespace;
+	protected String fqdn;
+
+	public ClassSchema(
+			String name, String namespace,
+			List<String> imports, List<FieldSchema> fields) {
+		super(name);
+		this.namespace = namespace;
+		this.imports = imports;  // FIXME clone?
+		this.fields = new FieldSchema[fields.size()];
+		System.arraycopy(fields.toArray(), 0, this.fields, 0, fields.size());
+		if(namespace == null) {
+			this.fqdn = name;
+		} else {
+			this.fqdn = namespace+"."+name;
+		}
+	}
+
+	public final FieldSchema[] getFields() {
+		return fields;
+	}
+
+	String getNamespace() {
+		return namespace;
+	}
+
+	List<String> getImports() {
+		return imports;
+	}
+
+	void setNamespace(String namespace) {
+		this.namespace = namespace;
+	}
+
+	void setImports(List<String> imports) {
+		this.imports = imports;  // FIXME clone?
+	}
+
+	//@Override
+	//public String getFullName()
+	//{
+	//	if(namespace == null) {
+	//		return getName();
+	//	} else {
+	//		return namespace+"."+getName();
+	//	}
+	//}
+
+	@Override
+	public String getExpression() {
+		StringBuffer b = new StringBuffer();
+		b.append("(class ");
+		b.append(getName());
+		if(namespace != null) {
+			b.append(" (package "+namespace+")");
+		}
+		for(FieldSchema f : fields) {
+			b.append(" "+f.getExpression());
+		}
+		b.append(")");
+		return b.toString();
+	}
+
+	public boolean equals(SpecificClassSchema o) {
+		return (namespace != null ? namespace.equals(o.getNamespace()) : o.getNamespace() == null) &&
+			getName().equals(o.getName());
+	}
+}
+

java-plan3/src/org/msgpack/schema/DoubleSchema.java

@@ -0,0 +1,84 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009 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.schema;
+
+import java.io.IOException;
+import org.msgpack.*;
+
+public class DoubleSchema extends Schema {
+	public DoubleSchema() {
+		super("Double");
+	}
+
+	@Override
+	public String getExpression() {
+		return "double";
+	}
+
+	@Override
+	public void pack(Packer pk, Object obj) throws IOException {
+		if(obj instanceof Number) {
+			pk.packDouble( ((Number)obj).doubleValue() );
+
+		} else if(obj == null) {
+			pk.packNil();
+
+		} else {
+			throw MessageTypeException.invalidConvert(obj, this);
+		}
+	}
+
+	@Override
+	public Object convert(Object obj) throws MessageTypeException {
+		if(obj instanceof Double) {
+			return obj;
+
+		} else if(obj instanceof Number) {
+			return ((Number)obj).doubleValue();
+
+		} else {
+			throw MessageTypeException.invalidConvert(obj, this);
+		}
+	}
+
+	@Override
+	public Object createFromByte(byte v) {
+		return (double)v;
+	}
+
+	@Override
+	public Object createFromShort(short v) {
+		return (double)v;
+	}
+
+	@Override
+	public Object createFromInt(int v) {
+		return (double)v;
+	}
+
+	@Override
+	public Object createFromFloat(float v) {
+		return (double)v;
+	}
+
+	@Override
+	public Object createFromDouble(double v) {
+		return (double)v;
+	}
+}
+

java-plan3/src/org/msgpack/schema/FieldSchema.java

@@ -0,0 +1,43 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009 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.schema;
+
+import org.msgpack.Schema;
+
+public class FieldSchema {
+	private String name;
+	private Schema schema;
+
+	public FieldSchema(String name, Schema schema) {
+		this.name = name;
+		this.schema = schema;
+	}
+
+	public final String getName() {
+		return name;
+	}
+
+	public final Schema getSchema() {
+		return schema;
+	}
+
+	public String getExpression() {
+		return "(field "+name+" "+schema.getExpression()+")";
+	}
+}
+

java-plan3/src/org/msgpack/schema/FloatSchema.java

@@ -0,0 +1,84 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009 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.schema;
+
+import java.io.IOException;
+import org.msgpack.*;
+
+public class FloatSchema extends Schema {
+	public FloatSchema() {
+		super("Float");
+	}
+
+	@Override
+	public String getExpression() {
+		return "float";
+	}
+
+	@Override
+	public void pack(Packer pk, Object obj) throws IOException {
+		if(obj instanceof Number) {
+			pk.packFloat( ((Number)obj).floatValue() );
+
+		} else if(obj == null) {
+			pk.packNil();
+
+		} else {
+			throw MessageTypeException.invalidConvert(obj, this);
+		}
+	}
+
+	@Override
+	public Object convert(Object obj) throws MessageTypeException {
+		if(obj instanceof Float) {
+			return obj;
+
+		} else if(obj instanceof Number) {
+			return ((Number)obj).floatValue();
+
+		} else {
+			throw MessageTypeException.invalidConvert(obj, this);
+		}
+	}
+
+	@Override
+	public Object createFromByte(byte v) {
+		return (float)v;
+	}
+
+	@Override
+	public Object createFromShort(short v) {
+		return (float)v;
+	}
+
+	@Override
+	public Object createFromInt(int v) {
+		return (float)v;
+	}
+
+	@Override
+	public Object createFromFloat(float v) {
+		return (float)v;
+	}
+
+	@Override
+	public Object createFromDouble(double v) {
+		return (float)v;
+	}
+}
+

java-plan3/src/org/msgpack/schema/GenericClassSchema.java

@@ -0,0 +1,91 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009 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.schema;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.HashMap;
+import java.io.IOException;
+import org.msgpack.*;
+
+public class GenericClassSchema extends ClassSchema {
+	public GenericClassSchema(
+			String name, String namespace,
+			List<String> imports, List<FieldSchema> fields) {
+		super(name, namespace, imports, fields);
+	}
+
+	@Override
+	@SuppressWarnings("unchecked")
+	public void pack(Packer pk, Object obj) throws IOException {
+		if(obj instanceof Map) {
+			Map d = (Map)obj;
+			pk.packArray(fields.length);
+			for(int i=0; i < fields.length; ++i) {
+				FieldSchema f = fields[i];
+				f.getSchema().pack(pk, d.get(f.getName()));
+			}
+
+		} else if(obj == null) {
+			pk.packNil();
+
+		} else {
+			throw MessageTypeException.invalidConvert(obj, this);
+		}
+	}
+
+	@Override
+	public Object convert(Object obj) throws MessageTypeException {
+		if(obj instanceof Collection) {
+			// FIXME optimize
+			return createFromArray( ((Collection)obj).toArray() );
+
+		} else if(obj instanceof Map) {
+			HashMap<String,Object> m = new HashMap<String,Object>(fields.length);
+			Map d = (Map)obj;
+			for(int i=0; i < fields.length; ++i) {
+				FieldSchema f = fields[i];
+				String fieldName = f.getName();
+				m.put(fieldName, f.getSchema().convert(d.get(fieldName)));
+			}
+			return m;
+
+		} else {
+			throw MessageTypeException.invalidConvert(obj, this);
+		}
+	}
+
+	public Schema getElementSchema(int index) {
+		// FIXME check index < fields.length
+		return fields[index].getSchema();
+	}
+
+	public Object createFromArray(Object[] obj) {
+		HashMap<String,Object> m = new HashMap<String,Object>(fields.length);
+		int i=0;
+		for(; i < obj.length; ++i) {
+			m.put(fields[i].getName(), obj[i]);
+		}
+		for(; i < fields.length; ++i) {
+			m.put(fields[i].getName(), null);
+		}
+		return m;
+	}
+}
+

java-plan3/src/org/msgpack/schema/GenericSchema.java

@@ -0,0 +1,192 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009 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.schema;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.HashMap;
+import java.io.IOException;
+import org.msgpack.*;
+//import org.msgpack.generic.*;
+
+public class GenericSchema extends Schema implements IArraySchema, IMapSchema {
+	public GenericSchema() {
+		super("Object");
+	}
+
+	@Override
+	public String getExpression() {
+		return "object";
+	}
+
+	@Override
+	public void pack(Packer pk, Object obj) throws IOException {
+		pk.pack(obj);
+	}
+
+	@Override
+	public Object convert(Object obj) throws MessageTypeException {
+		return obj;
+	}
+
+	@Override
+	public Schema getElementSchema(int index) {
+		return this;
+	}
+
+	@Override
+	public Schema getKeySchema() {
+		return this;
+	}
+
+	@Override
+	public Schema getValueSchema() {
+		return this;
+	}
+
+	@Override
+	public Object createFromNil() {
+		return null;
+	}
+
+	@Override
+	public Object createFromBoolean(boolean v) {
+		return v;
+	}
+
+	@Override
+	public Object createFromByte(byte v) {
+		return v;
+	}
+
+	@Override
+	public Object createFromShort(short v) {
+		return v;
+	}
+
+	@Override
+	public Object createFromInt(int v) {
+		return v;
+	}
+
+	@Override
+	public Object createFromLong(long v) {
+		return v;
+	}
+
+	@Override
+	public Object createFromFloat(float v) {
+		return v;
+	}
+
+	@Override
+	public Object createFromDouble(double v) {
+		return v;
+	}
+
+	@Override
+	public Object createFromRaw(byte[] b, int offset, int length) {
+		byte[] bytes = new byte[length];
+		System.arraycopy(b, offset, bytes, 0, length);
+		return bytes;
+	}
+
+	@Override
+	public Object createFromArray(Object[] obj) {
+		return Arrays.asList(obj);
+	}
+
+	@Override
+	@SuppressWarnings("unchecked")
+	public Object createFromMap(Object[] obj) {
+		HashMap m = new HashMap(obj.length / 2);
+		int i = 0;
+		while(i < obj.length) {
+			Object k = obj[i++];
+			Object v = obj[i++];
+			m.put(k, v);
+		}
+		return m;
+	}
+
+	/*
+   @Override
+	public Object createFromNil() {
+		return null;
+	}
+
+	@Override
+	public Object createFromBoolean(boolean v) {
+		return new GenericBoolean(v);
+	}
+
+	@Override
+	public Object createFromFromByte(byte v) {
+		return new GenericByte(v);
+	}
+
+	@Override
+	public Object createFromShort(short v) {
+		return new GenericShort(v);
+	}
+
+	@Override
+	public Object createFromInt(int v) {
+		return new GenericInt(v);
+	}
+
+	@Override
+	public Object createFromLong(long v) {
+		return new GenericLong(v);
+	}
+
+	@Override
+	public Object createFromFloat(float v) {
+		return new GenericFloat(v);
+	}
+
+	@Override
+	public Object createFromDouble(double v) {
+		return new GenericDouble(v);
+	}
+
+	@Override
+	public Object createFromRaw(byte[] b, int offset, int length) {
+		return new GenericRaw(b, offset, length);
+	}
+
+	@Override
+	public Object createFromArray(Object[] obj) {
+		// FIXME GenericArray
+		return Arrays.asList(obj);
+	}
+
+	@Override
+	public Object createFromMap(Object[] obj) {
+		GenericMap m = new GenericMap(obj.length / 2);
+		int i = 0;
+		while(i < obj.length) {
+			Object k = obj[i++];
+			Object v = obj[i++];
+			m.put(k, v);
+		}
+		return m;
+	}
+	*/
+}
+

java-plan3/src/org/msgpack/schema/IArraySchema.java

@@ -0,0 +1,26 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009 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.schema;
+
+import org.msgpack.Schema;
+
+public interface IArraySchema {
+	public Schema getElementSchema(int index);
+	public Object createFromArray(Object[] obj);
+}
+

java-plan3/src/org/msgpack/schema/IMapSchema.java

@@ -0,0 +1,27 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009 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.schema;
+
+import org.msgpack.Schema;
+
+public interface IMapSchema {
+	public Schema getKeySchema();
+	public Schema getValueSchema();
+	public Object createFromMap(Object[] obj);
+}
+

java-plan3/src/org/msgpack/schema/IntSchema.java

@@ -0,0 +1,89 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009 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.schema;
+
+import java.io.IOException;
+import org.msgpack.*;
+
+public class IntSchema extends Schema {
+	public IntSchema() {
+		super("Integer");
+	}
+
+	@Override
+	public String getExpression() {
+		return "int";
+	}
+
+	@Override
+	public void pack(Packer pk, Object obj) throws IOException {
+		if(obj instanceof Number) {
+			pk.packInt( ((Number)obj).intValue() );
+
+		} else if(obj == null) {
+			pk.packNil();
+
+		} else {
+			throw MessageTypeException.invalidConvert(obj, this);
+		}
+	}
+
+	@Override
+	public Object convert(Object obj) throws MessageTypeException {
+		if(obj instanceof Integer) {
+			return obj;
+
+		} else if(obj instanceof Number) {
+			return ((Number)obj).intValue();
+
+		} else {
+			throw MessageTypeException.invalidConvert(obj, this);
+		}
+	}
+
+	@Override
+	public Object createFromByte(byte v) {
+		return (int)v;
+	}
+
+	@Override
+	public Object createFromShort(short v) {
+		return (int)v;
+	}
+
+	@Override
+	public Object createFromInt(int v) {
+		return (int)v;
+	}
+
+	@Override
+	public Object createFromLong(long v) {
+		return (int)v;
+	}
+
+	@Override
+	public Object createFromFloat(float v) {
+		return (int)v;
+	}
+
+	@Override
+	public Object createFromDouble(double v) {
+		return (int)v;
+	}
+}
+

java-plan3/src/org/msgpack/schema/LongSchema.java

@@ -0,0 +1,89 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009 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.schema;
+
+import java.io.IOException;
+import org.msgpack.*;
+
+public class LongSchema extends Schema {
+	public LongSchema() {
+		super("Long");
+	}
+
+	@Override
+	public String getExpression() {
+		return "long";
+	}
+
+	@Override
+	public void pack(Packer pk, Object obj) throws IOException {
+		if(obj instanceof Number) {
+			pk.packLong( ((Number)obj).longValue() );
+
+		} else if(obj == null) {
+			pk.packNil();
+
+		} else {
+			throw MessageTypeException.invalidConvert(obj, this);
+		}
+	}
+
+	@Override
+	public Object convert(Object obj) throws MessageTypeException {
+		if(obj instanceof Long) {
+			return obj;
+
+		} else if(obj instanceof Number) {
+			return ((Number)obj).longValue();
+
+		} else {
+			throw MessageTypeException.invalidConvert(obj, this);
+		}
+	}
+
+	@Override
+	public Object createFromByte(byte v) {
+		return (long)v;
+	}
+
+	@Override
+	public Object createFromShort(short v) {
+		return (long)v;
+	}
+
+	@Override
+	public Object createFromInt(int v) {
+		return (long)v;
+	}
+
+	@Override
+	public Object createFromLong(long v) {
+		return (long)v;
+	}
+
+	@Override
+	public Object createFromFloat(float v) {
+		return (long)v;
+	}
+
+	@Override
+	public Object createFromDouble(double v) {
+		return (long)v;
+	}
+}
+

java-plan3/src/org/msgpack/schema/MapSchema.java

@@ -0,0 +1,102 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009 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.schema;
+
+import java.util.Map;
+import java.util.HashMap;
+import java.io.IOException;
+import org.msgpack.*;
+
+public class MapSchema extends Schema implements IMapSchema {
+	private Schema keySchema;
+	private Schema valueSchema;
+
+	public MapSchema(Schema keySchema, Schema valueSchema) {
+		super("map");
+		this.keySchema = keySchema;
+		this.valueSchema = valueSchema;
+	}
+
+	@Override
+	public String getFullName() {
+		return "HashList<"+keySchema.getFullName()+", "+valueSchema.getFullName()+">";
+	}
+
+	@Override
+	public String getExpression() {
+		return "(map "+keySchema.getExpression()+" "+valueSchema.getExpression()+")";
+	}
+
+	@Override
+	@SuppressWarnings("unchecked")
+	public void pack(Packer pk, Object obj) throws IOException {
+		if(obj instanceof Map) {
+			Map<Object,Object> d = (Map<Object,Object>)obj;
+			pk.packMap(d.size());
+			for(Map.Entry<Object,Object> e : d.entrySet()) {
+				keySchema.pack(pk, e.getKey());
+				valueSchema.pack(pk, e.getValue());
+			}
+
+		} else if(obj == null) {
+			pk.packNil();
+
+		} else {
+			throw MessageTypeException.invalidConvert(obj, this);
+		}
+	}
+
+	@Override
+	@SuppressWarnings("unchecked")
+	public Object convert(Object obj) throws MessageTypeException {
+		if(obj instanceof Map) {
+			Map<Object,Object> d = (Map<Object,Object>)obj;
+			Map<Object,Object> m = new HashMap<Object,Object>();
+			for(Map.Entry<Object,Object> e : d.entrySet()) {
+				m.put(keySchema.convert(e.getKey()), valueSchema.convert(e.getValue()));
+			}
+			return m;
+
+		} else {
+			throw MessageTypeException.invalidConvert(obj, this);
+		}
+	}
+
+	@Override
+	public Schema getKeySchema() {
+		return keySchema;
+	}
+
+	@Override
+	public Schema getValueSchema() {
+		return valueSchema;
+	}
+
+	@Override
+	public Object createFromMap(Object[] obj) {
+		HashMap m = new HashMap(obj.length / 2);
+		int i = 0;
+		while(i < obj.length) {
+			Object k = obj[i++];
+			Object v = obj[i++];
+			m.put(k, v);
+		}
+		return m;
+	}
+}
+

java-plan3/src/org/msgpack/schema/RawSchema.java

@@ -0,0 +1,105 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009 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.schema;
+
+import java.nio.ByteBuffer;
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import org.msgpack.*;
+
+public class RawSchema extends Schema {
+	public RawSchema() {
+		super("raw");
+	}
+
+	public String getFullName() {
+		return "byte[]";
+	}
+
+	@Override
+	public void pack(Packer pk, Object obj) throws IOException {
+		// FIXME instanceof GenericObject
+		if(obj instanceof byte[]) {
+			byte[] d = (byte[])obj;
+			pk.packRaw(d.length);
+			pk.packRawBody(d);
+
+		} else if(obj instanceof ByteBuffer) {
+			ByteBuffer d = (ByteBuffer)obj;
+			if(!d.hasArray()) {
+				throw MessageTypeException.invalidConvert(obj, this);
+			}
+			pk.packRaw(d.capacity());
+			pk.packRawBody(d.array(), d.position(), d.capacity());
+
+		} else if(obj instanceof String) {
+			try {
+				byte[] d = ((String)obj).getBytes("UTF-8");
+				pk.packRaw(d.length);
+				pk.packRawBody(d);
+			} catch (UnsupportedEncodingException e) {
+				throw MessageTypeException.invalidConvert(obj, this);
+			}
+
+		} else if(obj == null) {
+			pk.packNil();
+
+		} else {
+			throw MessageTypeException.invalidConvert(obj, this);
+		}
+	}
+
+	@Override
+	public Object convert(Object obj) throws MessageTypeException {
+		// FIXME instanceof GenericObject
+		if(obj instanceof byte[]) {
+			// FIXME copy?
+			//byte[] d = (byte[])obj;
+			//byte[] v = new byte[d.length];
+			//System.arraycopy(d, 0, v, 0, d.length);
+			//return v;
+			return obj;
+
+		} else if(obj instanceof ByteBuffer) {
+			ByteBuffer d = (ByteBuffer)obj;
+			byte[] v = new byte[d.capacity()];
+			int pos = d.position();
+			d.get(v);
+			d.position(pos);
+			return v;
+
+		} else if(obj instanceof String) {
+			try {
+				return ((String)obj).getBytes("UTF-8");
+			} catch (UnsupportedEncodingException e) {
+				throw MessageTypeException.invalidConvert(obj, this);
+			}
+
+		} else {
+			throw MessageTypeException.invalidConvert(obj, this);
+		}
+	}
+
+	@Override
+	public Object createFromRaw(byte[] b, int offset, int length) {
+		byte[] d = new byte[length];
+		System.arraycopy(b, offset, d, 0, length);
+		return d;
+	}
+}
+

java-plan3/src/org/msgpack/schema/ReflectionClassSchema.java

@@ -0,0 +1,64 @@
+package org.msgpack.schema;
+
+import java.util.Arrays;
+import java.util.List;
+import java.lang.reflect.*;
+import org.msgpack.*;
+
+// FIXME
+public abstract class ReflectionClassSchema extends ClassSchema {
+	private Constructor constructorCache;
+
+	public ReflectionClassSchema(String name, List<FieldSchema> fields, String namespace, List<String> imports) {
+		super(name, namespace, imports, fields);
+	}
+
+	/*
+	Schema getElementSchema(int index)
+	{
+		// FIXME check index < fields.length
+		fields[index].getSchema();
+	}
+
+	Object createFromArray(Object[] obj)
+	{
+		Object o = newInstance();
+		((MessageConvertable)o).messageConvert(obj);
+		return o;
+	}
+
+	Object newInstance()
+	{
+		if(constructorCache == null) {
+			cacheConstructor();
+		}
+		try {
+			return constructorCache.newInstance((Object[])null);
+		} catch (InvocationTargetException e) {
+			throw new RuntimeException("can't instantiate "+fqdn+": "+e.getMessage());
+		} catch (InstantiationException e) {
+			throw new RuntimeException("can't instantiate "+fqdn+": "+e.getMessage());
+		} catch (IllegalAccessException e) {
+			throw new RuntimeException("can't instantiate "+fqdn+": "+e.getMessage());
+		}
+	}
+
+	private void cacheConstructor()
+	{
+		try {
+			Class c = Class.forName(fqdn);
+			int index = 0;
+			for(SpecificFieldSchema f : fields) {
+				f.cacheField(c, index++);
+			}
+			constructorCache = c.getDeclaredConstructor((Class[])null);
+			constructorCache.setAccessible(true);
+		} catch(ClassNotFoundException e) {
+			throw new RuntimeException("class not found: "+fqdn);
+		} catch (NoSuchMethodException e) {
+			throw new RuntimeException("class not found: "+fqdn+": "+e.getMessage());
+		}
+	}
+	*/
+}
+

java-plan3/src/org/msgpack/schema/SSchemaParser.java

@@ -0,0 +1,254 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009 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.schema;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Stack;
+import java.util.regex.Pattern;
+import java.util.regex.Matcher;
+import org.msgpack.*;
+
+// FIXME exception class
+
+public class SSchemaParser {
+	public static Schema parse(String source) {
+		return new SSchemaParser(false).run(source);
+	}
+
+	public static Schema load(String source) {
+		return new SSchemaParser(true).run(source);
+	}
+
+	private static abstract class SExp {
+		boolean isAtom() { return false; }
+		public String getAtom() { return null; }
+
+		boolean isTuple() { return false; }
+		public SExp getTuple(int i) { return null; }
+		public int size() { return 0; }
+		public boolean empty() { return size() == 0; }
+		Iterator<SExp> iterator(int offset) { return null; }
+	}
+
+	private static class SAtom extends SExp {
+		private String atom;
+
+		SAtom(String atom) { this.atom = atom; }
+
+		boolean isAtom() { return true; }
+		public String getAtom() { return atom; }
+
+		public String toString() { return atom; }
+	}
+
+	private static class STuple extends SExp {
+		private List<SExp> tuple;
+
+		STuple() { this.tuple = new ArrayList<SExp>(); }
+
+		public void add(SExp e) { tuple.add(e); }
+
+		boolean isTuple() { return true; }
+		public SExp getTuple(int i) { return tuple.get(i); }
+		public int size() { return tuple.size(); }
+
+		Iterator<SExp> iterator(int skip) {
+			Iterator<SExp> i = tuple.iterator();
+			for(int s=0; s < skip; ++s) { i.next(); }
+			return i;
+		}
+
+		public String toString() {
+			if(tuple.isEmpty()) { return "()"; }
+			Iterator<SExp> i = tuple.iterator();
+			StringBuffer o = new StringBuffer();
+			o.append("(").append(i.next());
+			while(i.hasNext()) { o.append(" ").append(i.next()); }
+			o.append(")");
+			return o.toString();
+		}
+	}
+
+	boolean specificClass;
+
+	private SSchemaParser(boolean specificClass) {
+		this.specificClass = specificClass;
+	}
+
+	private static Pattern pattern = Pattern.compile(
+			"(?:\\s+)|([\\(\\)]|[\\d\\w\\.]+)");
+
+	private Schema run(String source) {
+		Matcher m = pattern.matcher(source);
+
+		Stack<STuple> stack = new Stack<STuple>();
+		String token;
+
+		while(true) {
+			while(true) {
+				if(!m.find()) { throw new RuntimeException("unexpected end of file"); }
+				token = m.group(1);
+				if(token != null) { break; }
+			}
+
+			if(token.equals("(")) {
+				stack.push(new STuple());
+			} else if(token.equals(")")) {
+				STuple top = stack.pop();
+				if(stack.empty()) {
+					stack.push(top);
+					break;
+				}
+				stack.peek().add(top);
+			} else {
+				if(stack.empty()) {
+					throw new RuntimeException("unexpected token '"+token+"'");
+				}
+				stack.peek().add(new SAtom(token));
+			}
+		}
+
+		while(true) {
+			if(!m.find()) { break; }
+			token = m.group(1);
+			if(token != null) { throw new RuntimeException("unexpected token '"+token+"'"); }
+		}
+
+		return readType( stack.pop() );
+	}
+
+	private Schema readType(SExp exp) {
+		if(exp.isAtom()) {
+			String type = exp.getAtom();
+			if(type.equals("string")) {
+				return new StringSchema();
+			} else if(type.equals("raw")) {
+				return new RawSchema();
+			} else if(type.equals("byte")) {
+				return new ByteSchema();
+			} else if(type.equals("short")) {
+				return new ShortSchema();
+			} else if(type.equals("int")) {
+				return new IntSchema();
+			} else if(type.equals("long")) {
+				return new LongSchema();
+			} else if(type.equals("float")) {
+				return new FloatSchema();
+			} else if(type.equals("double")) {
+				return new DoubleSchema();
+			} else if(type.equals("object")) {
+				return new GenericSchema();
+			} else {
+				throw new RuntimeException("byte, short, int, long, float, double, raw, string or object is expected but got '"+type+"': "+exp);
+			}
+		} else {
+			String type = exp.getTuple(0).getAtom();
+			if(type.equals("class")) {
+				return parseClass(exp);
+			} else if(type.equals("array")) {
+				return parseArray(exp);
+			} else if(type.equals("map")) {
+				return parseMap(exp);
+			} else {
+				throw new RuntimeException("class, array or map is expected but got '"+type+"': "+exp);
+			}
+		}
+	}
+
+	private ClassSchema parseClass(SExp exp) {
+		if(exp.size() < 3 || !exp.getTuple(1).isAtom()) {
+			throw new RuntimeException("class is (class NAME CLASS_BODY): "+exp);
+		}
+
+		String namespace = null;
+		List<String> imports = new ArrayList<String>();
+		String name = exp.getTuple(1).getAtom();
+		List<FieldSchema> fields = new ArrayList<FieldSchema>();
+
+		for(Iterator<SExp> i=exp.iterator(2); i.hasNext();) {
+			SExp subexp = i.next();
+			if(!subexp.isTuple() || subexp.empty() || !subexp.getTuple(0).isAtom()) {
+				throw new RuntimeException("field, package or import is expected: "+subexp);
+			}
+			String type = subexp.getTuple(0).getAtom();
+			if(type.equals("field")) {
+				fields.add( parseField(subexp) );
+			} else if(type.equals("package")) {
+				if(namespace != null) {
+					throw new RuntimeException("duplicated package definition: "+subexp);
+				}
+				namespace = parseNamespace(subexp);
+			} else if(type.equals("import")) {
+				imports.add( parseImport(subexp) );
+			} else {
+				throw new RuntimeException("field, package or import is expected but got '"+type+"': "+subexp);
+			}
+		}
+
+		if(specificClass) {
+			return new SpecificClassSchema(name, namespace, imports, fields);
+		} else {
+			return new GenericClassSchema(name, namespace, imports, fields);
+		}
+	}
+
+	private ArraySchema parseArray(SExp exp) {
+		if(exp.size() != 2) {
+			throw new RuntimeException("array is (array ELEMENT_TYPE): "+exp);
+		}
+		Schema elementType = readType(exp.getTuple(1));
+		return new ArraySchema(elementType);
+	}
+
+	private MapSchema parseMap(SExp exp) {
+		if(exp.size() != 3 || !exp.getTuple(1).isAtom()) {
+			throw new RuntimeException("map is (map KEY_TYPE VALUE_TYPE): "+exp);
+		}
+		Schema keyType   = readType(exp.getTuple(1));
+		Schema valueType = readType(exp.getTuple(2));
+		return new MapSchema(keyType, valueType);
+	}
+
+	private String parseNamespace(SExp exp) {
+		if(exp.size() != 2 || !exp.getTuple(1).isAtom()) {
+			throw new RuntimeException("package is (package NAME): "+exp);
+		}
+		String name = exp.getTuple(1).getAtom();
+		return name;
+	}
+
+	private String parseImport(SExp exp) {
+		if(exp.size() != 2 || !exp.getTuple(1).isAtom()) {
+			throw new RuntimeException("import is (import NAME): "+exp);
+		}
+		String name = exp.getTuple(1).getAtom();
+		return name;
+	}
+
+	private FieldSchema parseField(SExp exp) {
+		if(exp.size() != 3 || !exp.getTuple(1).isAtom()) {
+			throw new RuntimeException("field is (field NAME TYPE): "+exp);
+		}
+		String name = exp.getTuple(1).getAtom();
+		Schema type = readType(exp.getTuple(2));
+		return new FieldSchema(name, type);
+	}
+}
+

java-plan3/src/org/msgpack/schema/ShortSchema.java

@@ -0,0 +1,89 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009 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.schema;
+
+import java.io.IOException;
+import org.msgpack.*;
+
+public class ShortSchema extends Schema {
+	public ShortSchema() {
+		super("Short");
+	}
+
+	@Override
+	public String getExpression() {
+		return "short";
+	}
+
+	@Override
+	public void pack(Packer pk, Object obj) throws IOException {
+		if(obj instanceof Number) {
+			pk.packShort( ((Number)obj).shortValue() );
+
+		} else if(obj == null) {
+			pk.packNil();
+
+		} else {
+			throw MessageTypeException.invalidConvert(obj, this);
+		}
+	}
+
+	@Override
+	public Object convert(Object obj) throws MessageTypeException {
+		if(obj instanceof Short) {
+			return obj;
+
+		} else if(obj instanceof Number) {
+			return ((Number)obj).shortValue();
+
+		} else {
+			throw MessageTypeException.invalidConvert(obj, this);
+		}
+	}
+
+	@Override
+	public Object createFromByte(byte v) {
+		return (short)v;
+	}
+
+	@Override
+	public Object createFromShort(short v) {
+		return (short)v;
+	}
+
+	@Override
+	public Object createFromInt(int v) {
+		return (short)v;
+	}
+
+	@Override
+	public Object createFromLong(long v) {
+		return (short)v;
+	}
+
+	@Override
+	public Object createFromFloat(float v) {
+		return (short)v;
+	}
+
+	@Override
+	public Object createFromDouble(double v) {
+		return (short)v;
+	}
+}
+

java-plan3/src/org/msgpack/schema/SpecificClassSchema.java

@@ -0,0 +1,122 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009 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.schema;
+
+import java.util.Collection;
+import java.util.List;
+import java.lang.reflect.*;
+import java.io.IOException;
+import org.msgpack.*;
+
+public class SpecificClassSchema extends ClassSchema {
+	private Class classCache;
+	private Method factoryCache;
+	private Constructor constructorCache;
+
+	public SpecificClassSchema(
+			String name, String namespace,
+			List<String> imports, List<FieldSchema> fields) {
+		super(name, namespace, imports, fields);
+	}
+
+	@Override
+	@SuppressWarnings("unchecked")
+	public void pack(Packer pk, Object obj) throws IOException {
+		if(obj == null) {
+			pk.packNil();
+			return;
+		}
+		if(classCache == null) {
+			cacheFactory();
+		}
+		if(classCache.isInstance(obj)) {
+			((MessagePackable)obj).messagePack(pk);
+		} else {
+			// FIXME Map<String,Object>
+			throw MessageTypeException.invalidConvert(obj, this);
+		}
+	}
+
+	@Override
+	public Object convert(Object obj) throws MessageTypeException {
+		if(obj instanceof Collection) {
+			if(constructorCache == null) {
+				cacheConstructor();
+			}
+			try {
+				MessageMergeable o = (MessageMergeable)constructorCache.newInstance((Object[])null);
+				o.messageMerge(obj);
+				return o;
+			} catch (InvocationTargetException e) {
+				throw new RuntimeException("can't instantiate "+fqdn+": "+e.getMessage());
+			} catch (InstantiationException e) {
+				throw new RuntimeException("can't instantiate "+fqdn+": "+e.getMessage());
+			} catch (IllegalAccessException e) {
+				throw new RuntimeException("can't instantiate "+fqdn+": "+e.getMessage());
+			}
+
+		} else {
+			throw MessageTypeException.invalidConvert(obj, this);
+		}
+	}
+
+	public Schema getElementSchema(int index) {
+		// FIXME check index < fields.length
+		return fields[index].getSchema();
+	}
+
+	public Object createFromArray(Object[] obj) {
+		if(factoryCache == null) {
+			cacheFactory();
+		}
+		try {
+			return factoryCache.invoke(null, new Object[]{obj});
+		} catch (InvocationTargetException e) {
+			throw new RuntimeException("can't instantiate "+fqdn+": "+e.getCause());
+		} catch (IllegalAccessException e) {
+			throw new RuntimeException("can't instantiate "+fqdn+": "+e.getMessage());
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	private void cacheFactory() {
+		try {
+			classCache = Class.forName(fqdn);
+			factoryCache = classCache.getDeclaredMethod("createFromMessage", new Class[]{Object[].class});
+			factoryCache.setAccessible(true);
+		} catch(ClassNotFoundException e) {
+			throw new RuntimeException("class not found: "+fqdn);
+		} catch (NoSuchMethodException e) {
+			throw new RuntimeException("class not found: "+fqdn+": "+e.getMessage());
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	private void cacheConstructor() {
+		try {
+			classCache = Class.forName(fqdn);
+			constructorCache = classCache.getDeclaredConstructor((Class[])null);
+			constructorCache.setAccessible(true);
+		} catch(ClassNotFoundException e) {
+			throw new RuntimeException("class not found: "+fqdn);
+		} catch (NoSuchMethodException e) {
+			throw new RuntimeException("class not found: "+fqdn+": "+e.getMessage());
+		}
+	}
+}
+

java-plan3/src/org/msgpack/schema/StringSchema.java

@@ -0,0 +1,111 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009 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.schema;
+
+import java.nio.ByteBuffer;
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import org.msgpack.*;
+
+public class StringSchema extends Schema {
+	public StringSchema() {
+		super("string");
+	}
+
+	@Override
+	public String getFullName() {
+		return "String";
+	}
+
+	@Override
+	public void pack(Packer pk, Object obj) throws IOException {
+		// FIXME instanceof GenericObject
+		if(obj instanceof String) {
+			try {
+				byte[] d = ((String)obj).getBytes("UTF-8");
+				pk.packRaw(d.length);
+				pk.packRawBody(d);
+			} catch (UnsupportedEncodingException e) {
+				throw MessageTypeException.invalidConvert(obj, this);
+			}
+
+		} else if(obj instanceof byte[]) {
+			byte[] d = (byte[])obj;
+			pk.packRaw(d.length);
+			pk.packRawBody(d);
+
+		} else if(obj instanceof ByteBuffer) {
+			ByteBuffer d = (ByteBuffer)obj;
+			if(!d.hasArray()) {
+				throw MessageTypeException.invalidConvert(obj, this);
+			}
+			pk.packRaw(d.capacity());
+			pk.packRawBody(d.array(), d.position(), d.capacity());
+
+		} else if(obj == null) {
+			pk.packNil();
+
+		} else {
+			throw MessageTypeException.invalidConvert(obj, this);
+		}
+	}
+
+	@Override
+	public Object convert(Object obj) throws MessageTypeException {
+		// FIXME instanceof GenericObject
+		if(obj instanceof String) {
+			return obj;
+
+		} else if(obj instanceof byte[]) {
+			try {
+				return new String((byte[])obj, "UTF-8");
+			} catch (UnsupportedEncodingException e) {
+				throw MessageTypeException.invalidConvert(obj, this);
+			}
+
+		} else if(obj instanceof ByteBuffer) {
+			ByteBuffer d = (ByteBuffer)obj;
+			try {
+				if(d.hasArray()) {
+					return new String(d.array(), d.position(), d.capacity(), "UTF-8");
+				} else {
+					byte[] v = new byte[d.capacity()];
+					int pos = d.position();
+					d.get(v);
+					d.position(pos);
+					return new String(v, "UTF-8");
+				}
+			} catch (UnsupportedEncodingException e) {
+				throw MessageTypeException.invalidConvert(obj, this);
+			}
+
+		} else {
+			throw MessageTypeException.invalidConvert(obj, this);
+		}
+	}
+
+	@Override
+	public Object createFromRaw(byte[] b, int offset, int length) {
+		try {
+			return new String(b, offset, length, "UTF-8");
+		} catch (Exception e) {
+			throw new RuntimeException(e.getMessage());
+		}
+	}
+}
+