msgpack-idl-java 0.1.0

data/AUTHORS

@@ -0,0 +1 @@
+FURUHASHI Sadayuki <frsyuki _at_ users.sourceforge.jp>

data/README

@@ -0,0 +1,27 @@
+
+= MessagePack IDL Language Module for Java
+
+== Description
+
+== Installation
+
+=== Archive Installation
+
+  rake
+  gem install pkg/msgpack-idl-java-*
+
+=== Gem Installation
+
+  gem install msgpack-idl-java
+
+or
+
+  gem install msgpack-idl
+  msgpack-idl-install java
+
+== Copyright
+
+Author::    frsyuki <frsyuki@users.sourceforge.jp>
+Copyright:: Copyright (c) 2011 FURUHASHI Sadayuki
+License::   Apache License, Version 2.0
+

data/lib/msgpack/idl/lang/java/client/application.java

@@ -0,0 +1,35 @@
+#{format_package("client")}
+
+import java.io.Closeable;
+import org.msgpack.rpc.Session;
+import org.msgpack.rpc.Client;
+
+public class #{@name} implements Closeable {
+	private Session session;
+
+	public #{@name}(Session session) {
+		this.session = session;
+	}
+
+	public void close() {
+		if(session instanceof Client) {
+			((Client)session).close();
+		}
+	}
+
+	<?rb @scopes.each {|c| ?>
+		<?rb s = c.service ?>
+		public #{s.name}_#{c.version} #{c.name}() {
+			return new #{s.name}_#{c.version}(this.session, "#{c.name}");
+		}
+		<?rb s.versions_upto(c.version-1) {|sv| ?>
+		public #{s.name}_#{sv.version} #{c.name}_#{sv.version}() {
+			return #{c.name}().version#{sv.version}();
+		}
+		<?rb } ?>
+		public #{s.name}_#{c.version} #{c.name}_#{c.version}() {
+			return #{c.name}();
+		}
+	<?rb } ?>
+}
+

data/lib/msgpack/idl/lang/java/client/service_version.java

@@ -0,0 +1,95 @@
+#{format_package("client")}
+
+import java.io.IOException;
+import java.io.Closeable;
+import org.msgpack.MessageTypeException;
+import org.msgpack.MessagePackObject;
+import org.msgpack.rpc.Session;
+import org.msgpack.rpc.Client;
+import org.msgpack.rpc.error.RemoteError;
+import static #{@message_class}.*;
+
+public class #{@name} implements Closeable {
+	private Session session;
+
+	<?rb if @version ?>
+	private String scope;
+	private String suffix;
+
+	public #{@name}(Session session) {
+		this(session, null);
+	}
+
+	public #{@name}(Session session, String scope) {
+		this.session = session;
+		this.scope = scope;
+		if(scope != null) {
+			this.suffix = ":"+scope+":#{@version}";
+		} else {
+			this.suffix = ":#{@version}";
+		}
+	}
+
+	<?rb @service.versions_upto(@version-1) {|sv| ?>
+	public #{@service.name}_#{sv.version} version#{sv.version}() {
+		return new #{@service.name}_#{sv.version}(this.session, this.scope);
+	}
+	<?rb } ?>
+
+	private String scopedMethodName(String methodName) {
+		return methodName + this.suffix;
+	}
+
+	<?rb else  # if @version ?>
+	public #{@name}(Session session) {
+		this.session = session;
+	}
+
+	private String scopedMethodName(String methodName) {
+		return methodName;
+	}
+	<?rb end  # if @version ?>
+
+	<?rb @functions.each {|f| ?>
+	public #{format_type(f.return_type)} #{f.name}(A#{f.name} args) {
+		<?rb if f.return_type.void_type? ?>
+			session.callApply(scopedMethodName("#{f.name}"), args);
+		<?rb else ?>
+			MessagePackObject obj = session.callApply(scopedMethodName("#{f.name}"), args);
+			#{format_type(f.return_type)} r;
+			#{format_convert("r", "obj", f.return_type)}
+			return r;
+		<?rb end ?>
+	}
+
+	<?rb args = f.args ?>
+	public #{format_type(f.return_type)} #{f.name}(#{ args.map {|arg| format_type(arg.type) +" "+ arg.name }.join(', ') }) {
+		A#{f.name} args = new A#{f.name}(#{ args.map {|arg| arg.name }.join(', ') });
+		<?rb if f.return_type.void_type? ?>
+			this.#{f.name}(args);
+		<?rb else ?>
+			return this.#{f.name}(args);
+		<?rb end ?>
+	}
+
+	<?rb if f.max_id != f.max_required_id && f.max_required_id > 0 ?>
+	<?rb args = f.args[0, f.max_required_id] ?>
+	public #{format_type(f.return_type)} #{f.name}(#{ args.map {|arg| format_type(arg.type) +" "+ arg.name }.join(', ') }) {
+		A#{f.name} args = new A#{f.name}(#{ args.map {|arg| arg.name }.join(', ') });
+		<?rb if f.return_type.void_type? ?>
+			this.#{f.name}(args);
+		<?rb else ?>
+			return this.#{f.name}(args);
+		<?rb end ?>
+	}
+	<?rb end ?>
+
+	<?rb } ?>
+
+	public void close() {
+		if(session instanceof Client) {
+			((Client)session).close();
+		}
+	}
+}
+

data/lib/msgpack/idl/lang/java/enum.java

@@ -0,0 +1,39 @@
+#{format_package}
+
+import java.io.IOException;
+import org.msgpack.MessageTypeException;
+import org.msgpack.Packer;
+import org.msgpack.MessagePackable;
+
+public enum #{@name} implements MessagePackable {
+	<?rb @fields.each {|f| ?>
+	#{f.name}(#{f.id}),
+	<?rb } ?>
+	;
+
+	public static #{@name} enumOf(int id) {
+		switch(id) {
+		<?rb @fields.each {|f| ?>
+		case #{f.id}:
+			return #{f.name};
+		<?rb } ?>
+		default:
+			throw new MessageTypeException();
+		}
+	}
+
+	public void messagePack(Packer pk) throws IOException {
+		pk.packInt(this.id);
+	}
+
+	private int id;
+
+	public int id() {
+		return this.id;
+	}
+
+	private #{@name}(int id) {
+		this.id = id;
+	}
+}
+

data/lib/msgpack/idl/lang/java/message.java

@@ -0,0 +1,19 @@
+#{format_package}
+
+import java.util.List;
+import java.util.Map;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.math.BigInteger;
+import java.io.IOException;
+import org.msgpack.Packer;
+import org.msgpack.Unpacker;
+import org.msgpack.MessageTypeException;
+import org.msgpack.MessagePackObject;
+import org.msgpack.MessagePackable;
+import org.msgpack.MessageUnpackable;
+import org.msgpack.MessageConvertable;
+import org.msgpack.rpc.error.RemoteError;
+
+public #{format_message(@message, @message.name)}
+

data/lib/msgpack/idl/lang/java/message_body.java

@@ -0,0 +1,138 @@
+class #{@name}
+<?rb if @super_class ?>
+		extends #{@super_class}
+<?rb end ?>
+		implements MessagePackable, MessageUnpackable, MessageConvertable {
+
+	<?rb @message.new_fields.each {|f| ?>
+	protected #{format_type(f.type)} #{f.name};
+	<?rb } ?>
+
+	public #{@name}() {
+	<?rb if @super_class ?>
+		super();
+	<?rb end ?>
+	<?rb @message.new_fields.each {|f| ?>
+		#{format_initial_value("this.#{f.name}", f)}
+	<?rb } ?>
+	}
+
+	<?rb fields = @message.all_fields ?>
+	<?rb unless fields.empty? ?>
+	public #{@name}(#{ fields.map {|f| format_type(f.type)+" "+f.name }.join(', ') }) {
+		<?rb fields.each {|f| ?>
+		this.#{f.name} = #{f.name};
+		<?rb } ?>
+	}
+	<?rb end ?>
+
+	<?rb if @message.max_id != @message.max_required_id && @message.max_required_id > 0 ?>
+		<?rb fields = @message.all_fields[0, @message.max_required_id] ?>
+		public #{@name}(#{ fields.map {|f| format_type(f.type)+" "+f.name }.join(', ') }) {
+			<?rb fields.each {|f| ?>
+				this.#{f.name} = #{f.name};
+			<?rb } ?>
+			<?rb @message.all_fields[@message.max_required_id..-1].each {|f| ?>
+				#{format_initial_value("this.#{f.name}", f)}
+			<?rb } ?>
+		}
+		<?rb end ?>
+
+	<?rb @message.new_fields.each {|f| ?>
+	public void set#{f.name.capitalize}(#{format_type(f.type)} #{f.name}) {
+		this.#{f.name} = #{f.name};
+	}
+	public #{format_type(f.type)} get#{f.name.capitalize}() {
+		return this.#{f.name};
+	}
+	<?rb } ?>
+
+	public void messagePack(Packer pk) throws IOException {
+		pk.packArray(#{@message.max_id});
+		<?rb 1.upto(@message.max_id) {|i| ?>
+			<?rb if f = @message[i]; ?>
+				pk.pack(this.#{f.name});
+			<?rb else ?>
+				pk.packNil();
+			<?rb end ?>
+		<?rb } ?>
+	}
+
+	public void messageUnpack(Unpacker pac) throws IOException, MessageTypeException {
+		int len = pac.unpackArray();
+
+		if(len < #{@message.max_required_id}) {
+			throw new MessageTypeException("#{@message.name} requires at least #{@message.max_required_id} elements.");
+		}
+
+		<?rb 1.upto(@message.max_id) {|i| ?>
+			<?rb f = @message[i] ?>
+			<?rb if !f ?>
+				<?rb if i > @message.max_required_id ?>
+				if(len < #{i}) { return; }
+				<?rb end ?>
+				pac.unpackObject();
+			<?rb elsif f.required? ?>
+				<?rb if f.type.nullable_type? ?>
+					if(!pac.tryUnpackNull()) {
+						#{format_unpack("this.#{f.name}", "pac", f.type.real_type)}
+					}
+				<?rb else ?>
+					if(!pac.tryUnpackNull()) {
+						throw new MessageTypeException("#{@message.name}.#{f.name} is not nullable bug got nil");
+					}
+					#{format_unpack("this.#{f.name}", "pac", f.type.real_type)}
+				<?rb end ?>
+			<?rb elsif f.optional? ?>
+				<?rb if i > @message.max_required_id ?>
+				if(len < #{i}) { return; }
+				<?rb end ?>
+				if(!pac.tryUnpackNull()) {
+					#{format_unpack("this.#{f.name}", "pac", f.type.real_type)}
+				}
+			<?rb end ?>
+		<?rb } ?>
+
+		for(int i=#{@message.max_id}; i < len; ++i) {
+			pac.unpackObject();
+		}
+	}
+
+	public void messageConvert(MessagePackObject obj) throws MessageTypeException {
+		if(!obj.isArrayType()) {
+			throw new MessageTypeException("target is not array");
+		}
+		MessagePackObject[] arr = obj.asArray();
+		int len = arr.length;
+
+		if(len < #{@message.max_required_id}) {
+			throw new MessageTypeException("#{@message.name} requires at least #{@message.max_required_id} elements.");
+		}
+
+		<?rb 1.upto(@message.max_id) {|i| ?>
+			<?rb f = @message[i] ?>
+			<?rb if !f ?>
+			<?rb elsif f.required? ?>
+				obj = arr[#{i-1}];
+				<?rb if f.type.nullable_type? ?>
+					if(!obj.isNil()) {
+						#{format_convert("this.#{f.name}", "obj", f.type.real_type)}
+					}
+				<?rb else ?>
+					if(!obj.isNil()) {
+						throw new MessageTypeException("#{@message.name}.#{f.name} is not nullable bug got nil");
+					}
+					#{format_convert("this.#{f.name}", "obj", f.type.real_type)}
+				<?rb end ?>
+			<?rb elsif f.optional? ?>
+				<?rb if i > @message.max_required_id ?>
+				if(len < #{i}) { return; }
+				<?rb end ?>
+				obj = arr[#{i-1}];
+				if(!obj.isNil()) {
+					#{format_convert("this.#{f.name}", "obj", f.type.real_type)}
+				}
+			<?rb end ?>
+		<?rb } ?>
+	}
+}

data/lib/msgpack/idl/lang/java/server/application.java

@@ -0,0 +1,95 @@
+#{format_package("server")}
+
+import java.util.Map;
+import java.util.HashMap;
+import java.io.IOException;
+import org.msgpack.MessageTypeException;
+import org.msgpack.rpc.dispatcher.Dispatcher;
+import org.msgpack.rpc.Request;
+
+public class #{@name} implements Dispatcher {
+	<?rb @scopes.each {|c| ?>
+		<?rb s = c.service ?>
+		<?rb s.versions_upto(c.version) {|sv| ?>
+			private #{s.name}_#{sv.version} #{c.name}_#{sv.version};
+		<?rb } ?>
+	<?rb } ?>
+
+	<?rb @scopes.each {|c| ?>
+		<?rb s = c.service ?>
+		<?rb s.versions_upto(c.version) {|sv| ?>
+			public #{s.name}_#{sv.version} #{c.name}_#{sv.version}() {
+				return this.#{c.name}_#{sv.version};
+			}
+		<?rb } ?>
+	<?rb } ?>
+
+	<?rb @scopes.each {|c| ?>
+		<?rb s = c.service ?>
+		<?rb s.versions_upto(c.version) {|sv| ?>
+			<?rb sv.functions.each {|f| ?>
+				private class Default_#{s.name}_#{sv.version}_#{f.name} implements #{s.name}_#{sv.version}.I#{f.name} {
+					public #{format_type(f.return_type)} #{f.name}(#{format_message_class(s, sv.version)}.A#{f.name} args) {
+						<?rb if f.super_version ?>
+							<?rb if f.return_type.void_type? ?>
+								#{@name}.this.#{c.name}_#{f.super_version}.get#{f.name.capitalize}().#{f.name}(args);
+							<?rb else ?>
+								return #{@name}.this.#{c.name}_#{f.super_version}.get#{f.name.capitalize}().#{f.name}(args);
+							<?rb end ?>
+						<?rb else ?>
+							throw new RPCError(".NotImplemented");  // TODO
+						<?rb end ?>
+					}
+				}
+			<?rb } ?>
+		<?rb } ?>
+	<?rb } ?>
+
+	private HashMap<String, Dispatcher> scopeDispatchTable;
+
+	public #{@name}() {
+		this.scopeDispatchTable = new HashMap<String, Dispatcher>();
+	<?rb @scopes.each {|c| ?>
+		<?rb s = c.service ?>
+		<?rb s.versions_upto(c.version) {|sv| ?>
+			this.scopeDispatchTable.put("#{c.name}:#{sv.version}", this.#{c.name}_#{sv.version});
+		<?rb } ?>
+		this.scopeDispatchTable.put("#{c.name}", this.#{c.name}_#{c.version});
+	<?rb } ?>
+
+	this.scopeDispatchTable.put("", this.#{@default_scope.name}_#{@default_scope.version});
+	<?rb @default_scope.service.versions_upto(@default_scope.version) {|sv| ?>
+	this.scopeDispatchTable.put("#{sv.version}", this.#{@default_scope.name}_#{sv.version});
+	<?rb } ?>
+
+	<?rb @scopes.each {|c| ?>
+		<?rb s = c.service ?>
+		<?rb s.versions_upto(c.version) {|sv| ?>
+
+			<?rb sv.functions.each {|f| ?>
+				this.#{c.name}_#{sv.version}.set#{f.name.capitalize}(new Default_#{s.name}_#{sv.version}_#{f.name}());
+			<?rb } ?>
+
+		<?rb } ?>
+	<?rb } ?>
+	}
+
+	public void dispatch(Request request) throws Exception {
+		String methodName = request.getMethodName();
+		int ic = methodName.indexOf(':');
+		if(ic < 0) {
+			this.#{@default_scope.name}_#{@default_scope.version}.dispatch(methodName, request);
+			return;
+		}
+
+		String scope = methodName.substring(ic+1);
+		methodName = methodName.substring(0, ic);
+		Dispatcher dp = this.scopeDispatchTable.get(scope);
+		if(dp == null) {
+			throw new MessageTypeException("FIXME");
+		}
+
+		dp.dispatch(methodName, request);
+	}
+}
+

data/lib/msgpack/idl/lang/java/server/service_version.java

@@ -0,0 +1,73 @@
+#{format_package("server")}
+
+import java.util.Map;
+import java.util.HashMap;
+import java.io.IOException;
+import org.msgpack.MessageTypeException;
+import org.msgpack.rpc.dispatcher.Dispatcher;
+import org.msgpack.rpc.Request;
+import static #{@message_class}.*;
+
+public class #{@name} implements Dispatcher {
+	<?rb @functions.each {|f| ?>
+	public interface I#{f.name} {
+		public #{format_type(f.return_type)} #{f.name}(A#{f.name} args);
+	}
+	<?rb } ?>
+
+	<?rb @functions.each {|f| ?>
+	public void set#{f.name.capitalize}(I#{f.name} #{f.name}) {
+		this.#{f.name} = #{f.name};
+	}
+	public I#{f.name} get#{f.name.capitalize}() {
+		return this.#{f.name};
+	}
+	<?rb } ?>
+
+	public void set(Object o) {
+		<?rb @functions.each {|f| ?>
+		if(o instanceof I#{f.name}) {
+			this.set#{f.name.capitalize}((I#{f.name})o);
+		}
+		<?rb } ?>
+	}
+
+	<?rb @functions.each {|f| ?>
+	private I#{f.name} #{f.name};
+	<?rb } ?>
+
+
+	private HashMap<String, Dispatcher> dispatchTable;
+
+	public #{@name}() {
+		this.dispatchTable = new HashMap<String, Dispatcher>();
+		<?rb functions.each {|f| ?>
+			this.dispatchTable.put("#{f.name}", new Dispatcher() {
+				public void dispatch(Request request) throws Exception {
+					A#{f.name} args = new A#{f.name}();
+					args.messageConvert(request.getArguments());
+					<?rb if f.return_type.void_type? ?>
+						#{f.name}.#{f.name}(args);
+						request.sendResult(null);
+					<?rb else ?>
+						#{format_type(f.return_type)} r = #{f.name}.#{f.name}(args);
+						request.sendResult(r);
+					<?rb end ?>
+				}
+			});
+		<?rb } ?>
+	}
+
+	public void dispatch(Request request) throws Exception {
+		dispatch(request.getMethodName(), request);
+	}
+
+	public void dispatch(String methodName, Request request) throws Exception {
+		Dispatcher dp = this.dispatchTable.get(methodName);
+		if(dp == null) {
+			throw new MessageTypeException("FIXME");
+		}
+		dp.dispatch(request);
+	}
+}
+

data/lib/msgpack/idl/lang/java/service_version.java

@@ -0,0 +1,26 @@
+#{format_package}
+
+import java.util.List;
+import java.util.Map;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.io.IOException;
+import org.msgpack.Packer;
+import org.msgpack.Unpacker;
+import org.msgpack.MessageTypeException;
+import org.msgpack.MessagePackObject;
+import org.msgpack.MessagePackable;
+import org.msgpack.MessageUnpackable;
+import org.msgpack.MessageConvertable;
+
+public abstract class #{@name} {
+	<?rb @functions.each {|f| ?>
+		<?rb if f.super_version  # FIXME ?>
+			public static class A#{f.name} extends #{@service.name}_#{f.super_version}.A#{f.name} {
+			}
+		<?rb else ?>
+			public static #{format_message(f, "A#{f.name}")}
+		<?rb end ?>
+	<?rb } ?>
+}
+

data/lib/msgpack/idl/lang/java/version.rb

@@ -0,0 +1,11 @@
+module MessagePack
+module IDL
+module Lang
+module Java
+
+VERSION = '0.1.0'
+
+end
+end
+end
+end

data/lib/msgpack/idl/lang/java.rb

@@ -0,0 +1,490 @@
+#
+# MessagePack IDL Generator for Java
+#
+# Copyright (C) 2011 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.
+#
+module MessagePack
+module IDL
+module Lang
+
+require 'fileutils'
+require 'tenjin'
+
+class JavaGenerator < GeneratorModule
+	Generator.register('java', self)
+
+	def initialize(ir, outdir)
+		@ir = ir
+		@outdir = outdir
+	end
+
+	def generate!
+		gen_init
+		gen_enums
+		gen_messages
+		gen_services
+		gen_server_services
+		gen_server_applications
+		gen_client_services
+		gen_client_applications
+	end
+
+	def gen_init
+		@datadir = File.join(File.dirname(__FILE__), 'java')
+		@pkgoutdir = File.join(@outdir, @ir.namespace)
+
+		@engine = Tenjin::Engine.new(:cache => false)
+	end
+
+	def gen_enums
+		ctx = Context.new(self, :namespace, :enum, :fields, :name)
+		ctx.namespace = @ir.namespace
+
+		@ir.enums.each {|t|
+			ctx.enum = t
+			ctx.name = t.name
+			ctx.fields = t.fields
+			render_file('enum.java', ctx, "#{ctx.name}")
+		}
+	end
+
+	def gen_messages
+		ctx = Context.new(self, :namespace, :message, :super_class, :name)
+		ctx.namespace = @ir.namespace
+
+		@ir.messages.each {|t|
+			ctx.message = t
+			if t.super_class
+				ctx.super_class = t.super_class.name
+			end
+			ctx.name = t.name
+			render_file('message.java', ctx, "#{ctx.name}")
+		}
+	end
+
+	def gen_services
+		ctx = Context.new(self, :namespace, :service, :version, :functions, :name)
+		ctx.namespace = @ir.namespace
+
+		@ir.services.each {|s|
+			ctx.service = s
+			s.versions.each {|v|
+				ctx.version  = v.version
+				ctx.functions = v.functions
+				ctx.name = "#{s.name}_#{v.version}"
+				render_file('service_version.java', ctx, "#{ctx.name}")
+			}
+		}
+	end
+
+	def gen_server_services
+		ctx = Context.new(self, :namespace, :service, :version, :functions, :name, :message_class)
+		ctx.namespace = @ir.namespace
+
+		@ir.services.each {|s|
+			ctx.service = s
+			s.versions.each {|v|
+				ctx.version  = v.version
+				ctx.functions = v.functions
+				ctx.name = "#{s.name}_#{v.version}"
+				ctx.message_class = (@ir.namespace + ["#{s.name}_#{v.version}"]).join('.')
+				render_file('server/service_version.java', ctx, "server/#{ctx.name}")
+			}
+		}
+	end
+
+	def gen_server_applications
+		ctx = Context.new(self, :namespace, :name, :scopes, :default_scope)
+		ctx.namespace = @ir.namespace
+
+		service_apps = @ir.services.map {|s|
+			scopes = [IR::Scope.new("", s, s.versions.last.version, true)]
+			IR::Application.new(s.name, scopes)
+		}
+
+		(@ir.applications + service_apps).each {|app|
+			ctx.name = app.name
+			ctx.scopes = app.scopes
+			ctx.default_scope = app.default_scope
+			render_file('server/application.java', ctx, "server/#{ctx.name}")
+		}
+	end
+
+	def gen_client_services
+		ctx = Context.new(self, :namespace, :service, :version, :functions, :name, :message_class)
+		ctx.namespace = @ir.namespace
+
+		@ir.services.each {|s|
+			ctx.service = s
+			s.versions.each {|v|
+				ctx.version = v.version
+				ctx.functions = v.functions
+				ctx.name = "#{s.name}_#{v.version}"
+				ctx.message_class = (@ir.namespace + ["#{s.name}_#{v.version}"]).join('.')
+				render_file('client/service_version.java', ctx, "client/#{ctx.name}")
+			}
+			v = s.versions.last
+			ctx.version = nil
+			ctx.functions = v.functions
+			ctx.name = "#{s.name}"
+			ctx.message_class = (@ir.namespace + ["#{s.name}_#{v.version}"]).join('.')
+			render_file('client/service_version.java', ctx, "client/#{ctx.name}")
+		}
+	end
+
+	def gen_client_applications
+		ctx = Context.new(self, :namespace, :name, :scopes, :default_scope)
+		ctx.namespace = @ir.namespace
+
+		@ir.applications.each {|app|
+			ctx.name = app.name
+			ctx.scopes = app.scopes
+			ctx.default_scope = app.default_scope
+			render_file('client/application.java', ctx, "client/#{ctx.name}")
+		}
+	end
+
+	def render(template_fname, ctx)
+		template_path = File.join(@datadir, template_fname)
+		@engine.render(template_path, ctx)
+	end
+
+	def render_file(template_fname, ctx, fname)
+		code = render(template_fname, ctx)
+		path = File.join(@pkgoutdir, fname) + '.java'
+		FileUtils.mkdir_p(File.dirname(path))
+		File.open(path, "w") {|f|
+			f.write(code)
+		}
+	end
+
+	def format_message(t, name = t.name)
+		ctx = Context.new(self, :message, :super_class, :name)
+		ctx.message = t
+		if t.super_class
+			ctx.super_class = t.super_class.name
+		elsif t.is_a?(IR::Exception)
+			ctx.super_class = "RemoteError"
+		end
+		ctx.name = name
+		render('message_body.java', ctx)
+	end
+
+
+	class Context
+		include Tenjin::ContextHelper
+
+		def initialize(gen, *member)
+			@gen = gen
+
+			(class << self; self; end).module_eval {
+				member.each {|m|
+					define_method("#{m}") {
+						instance_variable_get("@#{m}")
+					}
+					define_method("#{m}=") {|v|
+						instance_variable_set("@#{m}", v)
+					}
+				}
+			}
+		end
+
+		def format_package(*extra)
+			name = format_package_name(*extra)
+			if name.empty?
+				""
+			else
+				"package #{name};"
+			end
+		end
+
+		def format_package_name(*extra)
+			package = namespace + extra
+			package.join('.')
+		end
+
+		PRIMITIVE_TYPEMAP = {
+			'void'   => 'void',
+			'byte'   => 'byte',
+			'short'  => 'short',
+			'int'    => 'int',
+			'long'   => 'long',
+			'ubyte'  => 'short',
+			'ushort' => 'int',
+			'uint'   => 'long',
+			'ulong'  => 'BigInteger',
+			'float'  => 'float',
+			'double' => 'double',
+			'bool'   => 'boolean',
+			'raw'    => 'byte[]',
+			'string' => 'String',
+			'list'   => 'List',
+			'map'    => 'Map',
+		}
+
+		NULLABLE_REMAP = {
+			'byte'    => 'Byte',
+			'short'   => 'Short',
+			'int'     => 'Integer',
+			'long'    => 'Long',
+			'float'   => 'Float',
+			'double'  => 'Double',
+			'boolean' => 'Boolean',
+		}
+
+		TYPE_PARAMETER_REMAP = NULLABLE_REMAP.merge({
+			:void     => 'Void',
+		})
+
+		IFACE_CLASS_REMAP = {
+			'Map'     => 'HashMap',
+			'List'    => 'ArrayList',
+		}
+
+		def format_nullable_type(t)
+			if t.nullable_type?
+				real_type = t.real_type
+				name = PRIMITIVE_TYPEMAP[real_type.name] || real_type.name
+				name = NULLABLE_REMAP[name] || name
+				return real_type, name
+			else
+				name = PRIMITIVE_TYPEMAP[t.name] || t.name
+				return t, name
+			end
+		end
+
+		def format_parameterized_type(t, name)
+			if t.parameterized_type?
+				name + '<' +
+					t.type_params.map {|tp|
+						n = format_type(tp)
+						TYPE_PARAMETER_REMAP[n] || n
+					}.join(', ') + '>'
+			else
+				name
+			end
+		end
+
+		def format_type(t)
+			t, name = format_nullable_type(t)
+			format_parameterized_type(t, name)
+		end
+
+		def format_message(t, name = t.name)
+			@gen.format_message(t, name)
+		end
+
+		def format_type_parameter(t)
+			t, name = format_nullable_type(t)
+			name = TYPE_PARAMETER_REMAP[name] || name
+			format_parameterized_type(t, name)
+		end
+
+		def format_type_impl(t)
+			t, name = format_nullable_type(t)
+			name = IFACE_CLASS_REMAP[name] || name
+			format_parameterized_type(t, name)
+		end
+
+		PRIMITIVE_DEFAULT = {
+			'byte'    => '0',
+			'short'   => '0',
+			'int'     => '0',
+			'long'    => '0',
+			'float'   => '0.0f',
+			'double'  => '0.0',
+			'boolean' => 'false',
+			'byte[]'  => 'new byte[0]',
+			'String'  => '""',
+		}
+
+		def format_initial_value(to, f)
+			v = f.value
+			case v
+			when IR::NilValue
+				"#{to} = null;"
+
+			when IR::IntValue
+				tt, name = format_nullable_type(f.type)
+				if name == "BigInteger"
+					"#{to} = BigInteger.valueOf(#{v.int}L);"
+				elsif name == "long"
+					"#{to} = #{v.int}L;"
+				else
+					"#{to} = #{v.int};"
+				end
+
+			when IR::BoolValue
+				if v.bool
+					"#{to} = true;"
+				else
+					"#{to} = false;"
+				end
+
+			when IR::EnumValue
+				"#{to} = #{v.enum.name}.#{v.field.name};"
+			when IR::EmptyValue
+				tt, name = format_nullable_type(f.type)
+				v = PRIMITIVE_DEFAULT[name]
+				v ||= "new #{format_type_impl(f.type)}()"
+				"#{to} = #{v};"
+			else
+				raise SemanticsError, "unknown initial value type: #{v.class}"
+			end
+		end
+
+		PRIMITIVE_UNPACK = {
+			'byte'   => 'unpackByte()',
+			'short'  => 'unpackShort()',
+			'int'    => 'unpackInt()',
+			'long'   => 'unpackLong()',
+			'ubyte'  => 'unpackShort()',
+			'ushort' => 'unpackInt()',
+			'uint'   => 'unpackLong()',
+			'ulong'  => 'unpackBigInteger()',
+			'float'  => 'unpackFloat()',
+			'double' => 'unpackDouble()',
+			'bool'   => 'unpackBoolean()',
+			'raw'    => 'unpackByteArray()',
+			'string' => 'unpackString()',
+		}
+
+		def format_unpack(to, pac, t)
+			if t.parameterized_type?
+				if t.list_type?
+					e = t.type_params[0]
+					anon_id = next_anon_id
+					vn = "n#{anon_id}"
+					ve = "e#{anon_id}"
+					vi = "i#{anon_id}"
+					return %[{
+						#{to} = new #{format_type_impl(t)}();
+						int #{vn} = #{pac}.unpackArray();
+						#{format_type(e)} #{ve};
+						for(int #{vi}=0; #{vi} < #{vn}; #{vi}++) {
+							#{format_unpack("#{ve}", pac, e)}
+							#{to}.add(#{ve});
+						}
+					}]
+				elsif t.map_type?
+					anon_id = next_anon_id
+					k = t.type_params[0]
+					v = t.type_params[1]
+					vn = "n#{anon_id}"
+					vk = "k#{anon_id}"
+					vv = "v#{anon_id}"
+					vi = "i#{anon_id}"
+					return %[{
+						#{to} = new #{format_type_impl(t)}();
+						int #{vn} = #{pac}.unpackMap();
+						#{format_type(k)} #{vk};
+						#{format_type(v)} #{vv};
+						for(int #{vi}=0; #{vi} < #{vn}; #{vi}++) {
+							#{format_unpack("#{vk}", pac, k)}
+							#{format_unpack("#{vv}", pac, v)}
+							#{to}.put(#{vk}, #{vv});
+						}
+					}]
+				end
+
+			elsif t.is_a?(IR::Message)
+				return %[#{to} = new #{t.name}();
+					#{to}.messageUnpack(#{pac});]
+
+			elsif t.is_a?(IR::Enum)
+				return "#{to} = #{t.name}.enumOf(#{pac}.unpackInt());"
+			end
+
+			method = PRIMITIVE_UNPACK[t.name] || "unpack(#{t.name}.class)"
+			"#{to} = #{pac}.#{method};"
+		end
+
+		PRIMITIVE_CONVERT = {
+			'byte'   => 'asByte()',
+			'short'  => 'asShort()',
+			'int'    => 'asInt()',
+			'long'   => 'asLong()',
+			'ubyte'  => 'asShort()',
+			'ushort' => 'asInt()',
+			'uint'   => 'asLong()',
+			'ulong'  => 'asBigInteger()',
+			'float'  => 'asFloat()',
+			'double' => 'asDouble()',
+			'bool'   => 'asBoolean()',
+			'raw'    => 'asByteArray()',
+			'string' => 'asString()',
+		}
+
+		def format_convert(to, obj, t)
+			if t.parameterized_type?
+				if t.list_type?
+					e = t.type_params[0]
+					anon_id = next_anon_id
+					ve = "e#{anon_id}"
+					vo = "o#{anon_id}"
+					return %[{
+						#{to} = new #{format_type_impl(t)}();
+						#{format_type(e)} #{ve};
+						for(MessagePackObject #{vo} : #{obj}.asArray()) {
+							#{format_convert("#{ve}", "#{vo}", e)}
+							#{to}.add(#{ve});
+						}
+					}]
+				elsif t.map_type?
+					k = t.type_params[0]
+					v = t.type_params[1]
+					anon_id = next_anon_id
+					vk = "k#{anon_id}"
+					vv = "v#{anon_id}"
+					vkv = "kv#{anon_id}"
+					return %[{
+						#{to} = new #{format_type_impl(t)}();
+						#{format_type(k)} #{vk};
+						#{format_type(v)} #{vv};
+						for(Map.Entry<MessagePackObject,MessagePackObject> #{vkv} : #{obj}.asMap().entrySet()) {
+							#{format_convert("#{vk}", "#{vkv}.getKey()", k)}
+							#{format_convert("#{vv}", "#{vkv}.getValue()", v)}
+							#{to}.put(#{vk}, #{vv});
+						}
+					}]
+				end
+
+			elsif t.is_a?(IR::Message)
+				return %[#{to} = new #{t.name}();
+					#{to}.messageConvert(#{obj});]
+
+			elsif t.is_a?(IR::Enum)
+				return "#{to} = #{t.name}.enumOf(#{obj}.asInt());"
+			end
+
+			method = PRIMITIVE_CONVERT[t.name] || "convert(new #{t.name}())"
+			"#{to} = #{obj}.#{method};"
+		end
+
+		def next_anon_id
+			@anon_id ||= -1
+			@anon_id += 1
+		end
+
+		def format_message_class(s, version)
+			(namespace + ["#{s.name}_#{version}"]).join('.')
+		end
+	end
+end
+
+
+end
+end
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification 
+name: msgpack-idl-java
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- FURUHASHI Sadayuki
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-23 00:00:00 +09:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: msgpack-idl
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 0
+        - 1
+        - 0
+        version: 0.1.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: tenjin
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 0
+        - 6
+        - 1
+        version: 0.6.1
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: 
+email: frsyuki@users.sourceforge.jp
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- AUTHORS
+- README
+- lib/msgpack/idl/lang/java.rb
+- lib/msgpack/idl/lang/java/client/application.java
+- lib/msgpack/idl/lang/java/client/service_version.java
+- lib/msgpack/idl/lang/java/enum.java
+- lib/msgpack/idl/lang/java/message.java
+- lib/msgpack/idl/lang/java/message_body.java
+- lib/msgpack/idl/lang/java/server/application.java
+- lib/msgpack/idl/lang/java/server/service_version.java
+- lib/msgpack/idl/lang/java/service_version.java
+- lib/msgpack/idl/lang/java/version.rb
+has_rdoc: true
+homepage: http://msgpack.org/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: msgpack
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: MessagePack IDL Processor Language Module for Java
+test_files: []
+