game_machine 0.0.11 → 1.0.2

data/games/tutorial/object_store.rb

@@ -0,0 +1,55 @@
+module Tutorial
+  class ObjectStore
+    include GameMachine
+    include GameMachine::Commands
+
+    attr_reader :player_items_cache
+
+    def initialize
+      @player_items_cache = {}
+    end
+
+    def all_for_player(player_id)
+      if entity = MessageLib::Entity.store_get(player_id,'player_items',5000)
+        player_items_cache[player_id] = entity.get_player_items
+      else
+        player_items_cache[player_id] = MessageLib::PlayerItems.new
+        save_player_items(player_items_cache[player_id],player_id)
+      end
+
+      player_items_cache[player_id].get_player_item_list || []
+    end
+
+    def delete_player_item(id,player_id)
+      ensure_player_cache(player_id)
+      player_items = player_items_cache[player_id]
+      player_item = MessageLib::PlayerItem.new.set_id(id)
+      player_items.remove_player_item_by_id(player_item)
+      save_player_items(player_items,player_id)
+    end
+
+    def save_player_item(player_item,player_id)
+      ensure_player_cache(player_id)
+      player_items = player_items_cache[player_id]
+      player_items.remove_player_item_by_id(player_item)
+      player_items.add_player_item(player_item)
+      save_player_items(player_items,player_id)
+    end
+
+    private
+
+    def ensure_player_cache(player_id)
+      unless player_items_cache.has_key?(player_id)
+        all_for_player(player_id)
+      end
+    end
+
+    def save_player_items(player_items,player_id)
+      entity = MessageLib::Entity.new
+      entity.set_player_items(player_items)
+      entity.set_id('player_items')
+      entity.store_set(player_id)
+    end
+
+  end
+end

data/games/tutorial/seed.rb

@@ -0,0 +1,52 @@
+
+items = [
+  {
+    'id' => 'hp',
+    'name' => 'Healing Potion',
+    'quantity' => -1,
+    'consumable' => GameMachine::MessageLib::Consumable.new.set_type('health').set_size('small')
+  },
+
+  {
+    'id' => 'sw',
+    'name' => 'Sword',
+    'quantity' => 100,
+    'weapon' => GameMachine::MessageLib::Weapon.new.set_attack(5).set_delay(3),
+    'cost' => GameMachine::MessageLib::Cost.new.set_amount(5).set_currency('gold')
+  },
+
+  {
+    'id' => 'helm',
+    'name' => 'Helm',
+    'quantity' => 1000
+  },
+
+  {
+    'id' => 'shoes',
+    'name' => 'Shoes',
+    'quantity' => -1
+  },
+
+  {
+    'id' => 'gold',
+    'name' => 'Gold',
+    'quantity' => -1
+  }
+]
+
+items.each do |item|
+  player_item = GameMachine::MessageLib::PlayerItem.new
+  player_item.set_id(item['id'])
+  player_item.set_name(item['name'])
+  player_item.set_quantity(item['quantity'])
+
+  ['consumable','weapon','cost'].each do |component|
+    if item[component]
+      player_item.send("set_#{component}".to_sym,item[component])
+    end
+  end
+
+  unless player_item.db_save('global')
+    puts player_item.dbErrors.inspect
+  end
+end

data/games/tutorial/sql_store.rb

@@ -0,0 +1,30 @@
+module Tutorial
+  class SqlStore
+    include GameMachine
+    
+    def all_for_player(player_id)
+      MessageLib::PlayerItem.db_find_all(player_id)
+    end
+
+    def find_by_id(id,player_id,in_transaction=false)
+      if in_transaction
+        MessageLib::PlayerItem.db_find(id,player_id,true)
+      else
+        MessageLib::PlayerItem.db_find(id,player_id)
+      end
+    end
+
+    def save_player_item(player_item,player_id,in_transaction=false)
+      if in_transaction
+        player_item.db_save(player_id,true)
+      else
+        player_item.db_save_async(player_id)
+      end
+    end
+
+    def delete_player_item(id,player_id)
+      MessageLib::PlayerItem.db_delete_async(id,player_id)
+    end
+
+  end
+end

data/java/project/build.gradle

@@ -0,0 +1,134 @@
+apply plugin: 'java'
+apply plugin: 'maven'
+apply plugin: 'eclipse'
+apply plugin:'scala'
+
+
+buildscript {
+  repositories { jcenter() }
+  dependencies {
+    classpath 'com.github.jengelman.gradle.plugins:shadow:1.0.2'
+    classpath group: 'org.javalite', name: 'activejdbc', version: '1.4.9'
+    classpath group: 'org.javalite', name: 'activejdbc-instrumentation', version: '1.4.9'
+  }
+}
+apply plugin: 'com.github.johnrengelman.shadow'
+
+group = 'game_machine'
+  version = '0.0.1'
+  
+
+description = """"""
+
+sourceCompatibility = 1.7
+targetCompatibility = 1.7
+
+repositories {
+  flatDir(dirs: 'third_party')
+  mavenCentral()
+  maven {
+        url "https://oss.sonatype.org/content/repositories/snapshots/"
+    }
+  
+}
+
+dependencies {
+  compile 'org.slf4j:slf4j-api:1.7.7'
+  compile 'ch.qos.logback:logback-classic:1.1.2'
+  compile 'ch.qos.logback:logback-core:1.1.2'
+  compile 'org.codehaus.janino:janino:2.7.5'
+  compile group: 'com.typesafe.akka', name: "akka-actor_$scala_version", version:"$akka_version"
+  compile group: 'com.typesafe.akka', name: "akka-remote_$scala_version", version:"$akka_version"
+  compile group: 'com.typesafe.akka', name: "akka-testkit_$scala_version", version:"$akka_version"
+  compile group: 'com.typesafe.akka', name: "akka-kernel_$scala_version", version:"$akka_version"
+  compile group: 'com.typesafe.akka', name: "akka-agent_$scala_version", version:"$akka_version"
+  compile group: 'com.typesafe.akka', name: "akka-contrib_$scala_version", version:"$akka_version"
+  compile group: 'com.typesafe.akka', name: "akka-cluster_$scala_version", version:"$akka_version"
+  
+  compile 'com.dyuproject.protostuff:protostuff-uberjar:1.0.8'
+  compile 'com.dyuproject.protostuff:protostuff:1.0.8'
+  compile 'com.dyuproject.protostuff:protostuff-json:1.0.8'
+  
+  //compile group: 'com.google.code.findbugs', name: 'jsr305', version:'2.0.1'
+  //compile group: 'org.javassist', name: 'javassist', version:'3.17.1-GA'
+  compile 'com.couchbase.client:couchbase-client:1.4.2'
+  //compile 'redis.clients:jedis:2.2.1'
+  //compile 'org.mapdb:mapdb:1.0.3'
+  compile 'org.postgresql:postgresql:9.3-1102-jdbc41'
+  compile 'io.netty:netty-all:4.0.21.Final'
+  //compile 'com.jolbox:bonecp:0.8.0.RELEASE'
+  compile 'com.zaxxer:HikariCP-java6:2.0.1'
+  compile 'mysql:mysql-connector-java:5.1.32'
+  compile 'org.javalite:activejdbc:1.4.10-SNAPSHOT'
+  compile 'org.javalite:activejdbc-instrumentation:1.4.10-SNAPSHOT'
+  //compile 'org.apache.httpcomponents:httpclient:4.4-alpha1'
+  compile 'org.apache.httpcomponents:httpclient:4.3.5'
+  compile 'org.mindrot:jbcrypt:0.3m'
+  compile 'org.fusesource:sigar:1.6.4'
+}
+
+import com.github.jengelman.gradle.plugins.shadow.transformers.AppendingTransformer
+import org.javalite.instrumentation.Instrumentation
+
+sourceSets {
+    main {
+        java.srcDirs = ['src/main/java', '../src/main/java'] 
+    }
+}
+
+
+shadowJar {
+  transform(AppendingTransformer) {
+    resource = 'reference.conf'
+  }
+}
+
+task wrapper(type: Wrapper) {
+  gradleVersion = '2.0'
+}
+
+test {
+  //useTestNG()
+  //outputs.upToDateWhen { false }
+  //testLogging.showStandardStreams = true
+  //dependsOn cleanTest
+  //testLogging { exceptionFormat "full" }
+}
+ 
+task install_libs(type: Copy) {
+  into "$buildDir/../lib"
+    
+  from configurations.runtime
+  from "$buildDir/libs"
+  from "$buildDir/../local_lib/sigar"
+}
+
+def addUrlIfNotPresent( to, what ) {
+    if ( !to || !what ) { return } 
+    def urls = to.URLs.toList()
+    switch( what.class ) { 
+      case URL: what = new File( what.toURI() ); break
+      case String: what = new File( what ); break
+      case GString: what = new File( what.toString() ); break
+      case File: break; // ok
+      default:
+        println "Don't know how to deal with $what as it is not an URL nor a File"
+        System.exit( 1 )
+    }
+
+    if ( what.directory && !what.exists() ) { what.mkdirs() }
+    def url = what.toURI().toURL()
+    if ( !urls.contains( url ) && ( what.directory || !urls.find{ it.path.endsWith( what.name ) } ) ) { 
+        to.addURL( url )
+    }
+}
+
+compileJava.doLast {
+    Instrumentation instrumentation = new Instrumentation()
+    
+    instrumentation.outputDirectory = sourceSets.main.output.classesDir.getPath()
+    addUrlIfNotPresent this.class.classLoader.rootLoader, sourceSets.main.output.classesDir.getPath()
+    addUrlIfNotPresent Instrumentation.class.classLoader, sourceSets.main.output.classesDir.getPath()
+    instrumentation.instrument()
+}
+

data/java/project/component.erb

@@ -0,0 +1,719 @@
+
+package GameMachine.Messages;
+
+import com.game_machine.core.GameMachineLoader;
+import com.game_machine.core.ActorUtil;
+import scala.concurrent.Await;
+import scala.concurrent.Future;
+import scala.concurrent.duration.Duration;
+import akka.actor.ActorSelection;
+import akka.pattern.AskableActorSelection;
+import akka.util.Timeout;
+import java.util.concurrent.TimeUnit;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+
+import java.io.Externalizable;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.io.UnsupportedEncodingException;
+
+import com.dyuproject.protostuff.ByteString;
+import com.dyuproject.protostuff.GraphIOUtil;
+import com.dyuproject.protostuff.Input;
+import com.dyuproject.protostuff.Message;
+import com.dyuproject.protostuff.Output;
+import com.dyuproject.protostuff.ProtobufOutput;
+
+import java.io.ByteArrayOutputStream;
+import com.dyuproject.protostuff.JsonIOUtil;
+import com.dyuproject.protostuff.LinkedBuffer;
+import com.dyuproject.protostuff.ProtobufIOUtil;
+import com.dyuproject.protostuff.runtime.RuntimeSchema;
+
+import GameMachine.Messages.Entity;
+import com.game_machine.core.LocalLinkedBuffer;
+import java.nio.charset.Charset;
+
+import com.game_machine.core.DatastoreCommands;
+
+<% if persistent %>
+import com.game_machine.core.PersistentMessage;
+import com.game_machine.core.ActorUtil;
+import akka.actor.ActorSelection;
+import org.javalite.activejdbc.Errors;
+<% end %>
+
+import org.javalite.activejdbc.Model;
+import com.dyuproject.protostuff.Schema;
+import com.dyuproject.protostuff.UninitializedMessageException;
+
+
+<% if persistent %>
+public final class <%=klass%>  implements Externalizable, Message<<%=klass%>>, Schema<<%=klass%>>, PersistentMessage
+<% else %>
+public final class <%=klass%>  implements Externalizable, Message<<%=klass%>>, Schema<<%=klass%>>
+<% end %>
+
+{
+
+<% message.nestedEnumGroups.each do |group| %>
+	public enum <%=group.name %> implements com.dyuproject.protostuff.EnumLite<<%=group.name %>>
+    {
+    	<% group.values.each do |value| %>
+    	<%= "#{value.getName}(#{value.getNumber})" %><%= value.getNumber == (group.values.length - 1) ? ";" : "," %>
+    	<% end %>
+        
+        public final int number;
+        
+        private Corpus (int number)
+        {
+            this.number = number;
+        }
+        
+        public int getNumber()
+        {
+            return number;
+        }
+        
+        public static Corpus valueOf(int number)
+        {
+            switch(number) 
+            {
+            	<% group.values.each do |value| %>
+    			case <%= "#{value.getNumber}: return (#{value.getName})" %>;
+    			<% end %>
+                default: return null;
+            }
+        }
+    }
+<% end %>
+
+
+    public static Schema<<%=klass%>> getSchema()
+    {
+        return DEFAULT_INSTANCE;
+    }
+
+    public static <%=klass%> getDefaultInstance()
+    {
+        return DEFAULT_INSTANCE;
+    }
+
+    static final <%=klass%> DEFAULT_INSTANCE = new <%=klass%>();
+
+<% if persistent %>
+	public Errors dbErrors;
+	public String persistPlayerId;
+	public String getPersistPlayerId() {
+		return persistPlayerId;
+	}
+	
+	public String persistAction;
+	public String getPersistAction() {
+		return persistAction;
+	}
+<% end %>
+
+<% message.getFields.each do |field| %>
+    <% if field.isRepeated %>
+    public List<<%=get_type(field)%>> <%=field.name %>;
+	<% else %>
+	<% if field.default_value.nil? %>
+		public <%=get_type(field)%> <%=field.name %>;
+	<% else %>
+		public <%=get_type(field)%> <%=field.name %>; // = <%= field.default_value %>;
+	<% end %>
+    
+    <% end %>
+<% end %>
+    
+
+
+    public <%=klass%>()
+    {
+        
+    }
+
+	
+ 
+<% message.getFields.each do |field| %>
+	<% if field.name == 'id' %>
+	public static String scopeId(String playerId, String id) {
+    	return playerId + "##" + id;
+    }
+    
+    public static String unscopeId(String id) {
+    	if (id.contains("##")) {
+    		String[] parts = id.split("##");
+        	return parts[1];
+    	} else {
+    		throw new RuntimeException("Expected "+id+" to contain ##");
+    	}
+    }
+    
+    public void storeSet(String scope) {
+    	<%=klass%> clone = this.clone();
+		clone.id = scopeId(scope,this.id);
+		ActorSelection sel = ActorUtil.findDistributed("GameMachine::ObjectDb", clone.id);
+		sel.tell(clone, null);
+	}
+		
+	public static void storeDelete(String scope, String id) {
+		String scopedId = scopeId(scope,id);
+		ActorSelection sel = ActorUtil.findDistributed("GameMachine::ObjectDb", scopedId);
+		ObjectdbDel del = new ObjectdbDel().setEntityId(scopedId);
+		sel.tell(del, null);
+	}
+		
+	public static <%=klass%> storeGet(String scope, String id, int timeout) {
+		String scopedId = scopeId(scope,id);
+		ObjectdbGet get = new ObjectdbGet().setEntityId(scopedId).setKlass("<%=klass%>");
+		ActorSelection sel = ActorUtil.findDistributed("GameMachine::ObjectDb", scopedId);
+		Timeout t = new Timeout(Duration.create(timeout, TimeUnit.MILLISECONDS));
+		AskableActorSelection askable = new AskableActorSelection(sel);
+		<%=klass%> message;
+		Future<Object> future = askable.ask(get,t);
+		try {
+			message = (<%=klass%>) Await.result(future, t.duration());
+		} catch (Exception e) {
+			return null;
+		}
+		if (message == null) {
+			return null;
+		}
+		message.id = unscopeId(message.id);
+		return message;
+	}
+
+	<% end %>
+<% end %>
+
+	
+<% if persistent %>
+
+	public void dbSaveAsync(String playerId) {
+		persistPlayerId = playerId;
+		persistAction = "save";
+		ActorSelection sel = ActorUtil.getSelectionByName("message_persister");
+		sel.tell(this, null);
+    }
+        
+    public Boolean dbSave(String playerId) {
+    	return dbSave(playerId,false);
+    }
+        
+    public Boolean dbSave(String playerId, boolean inTransaction) {
+    	if (!inTransaction) {
+    		com.game_machine.orm.models.<%=klass%>.open();
+    	}
+    	
+    	com.game_machine.orm.models.<%=klass%> model = com.game_machine.orm.models.<%=klass%>.findFirst("<%=klass.underscore%>_id = ? and player_id = ?", this.id, playerId);
+    	if (model == null) {
+    		model = new com.game_machine.orm.models.<%=klass%>();
+    		toModel(model,playerId);
+    	} else {
+    		toModel(model,null);
+    	}
+    	<% message_fields.each do |message_field| %>
+    	if (this.has<%= message_field %>()) {
+    		this.<%= varname(message_field) %>.toModel(model,null);
+    	} else {
+    		<%= message_field %>.clearModel(model);
+    	}
+    	<% end %>
+    	
+    	Boolean res = model.save();
+    	if (!res) {
+    		dbErrors = model.errors();
+    	}
+    	if (!inTransaction) {
+    		com.game_machine.orm.models.<%=klass%>.close();
+    	}
+    	return res;
+    }
+    
+    public static void dbDeleteAsync(String id, String playerId) {
+    	<%=klass%> message = new <%=klass%>();
+    	message.setId(id);
+		message.persistPlayerId = playerId;
+		message.persistAction = "delete";
+		ActorSelection sel = ActorUtil.getSelectionByName("message_persister");
+		sel.tell(message, null);
+    }
+    
+    public Boolean dbDelete(String playerId) {
+    	Boolean result;
+    	com.game_machine.orm.models.<%=klass%>.open();
+    	com.game_machine.orm.models.<%=klass%> model = com.game_machine.orm.models.<%=klass%>.findFirst("<%=klass.underscore%>_id = ? and player_id = ?", this.id, playerId);
+    	if (model != null) {
+    		result = model.delete();
+    	} else {
+    		result = false;
+    	}
+    	com.game_machine.orm.models.<%=klass%>.close();
+    	return result;
+    }
+    
+    public static <%=klass%> dbFind(String id, String playerId) {
+    	return dbFind(id, playerId, false);
+    }
+    
+    public static <%=klass%> dbFind(String id, String playerId, boolean inTransaction) {
+    	if (!inTransaction) {
+    		com.game_machine.orm.models.<%=klass%>.open();
+    	}
+    	
+    	com.game_machine.orm.models.<%=klass%> model = com.game_machine.orm.models.<%=klass%>.findFirst("<%=klass.underscore%>_id = ? and player_id = ?", id, playerId);
+    	
+    	if (!inTransaction) {
+    		com.game_machine.orm.models.<%=klass%>.close();
+    	}
+    	
+    	if (model == null) {
+    		return null;
+    	} else {
+    		<%=klass%> <%= varname(klass) %> = fromModel(model);
+    		<% message_fields.each do |message_field| %>
+    		<%= varname(klass) %>.<%= varname(message_field) %> = <%= message_field %>.fromModel(model);
+    		<% end %>
+    		return <%= varname(klass) %>;
+    	}
+    }
+    
+    public static List<<%=klass%>> dbFindAll(String playerId) {
+    	com.game_machine.orm.models.<%=klass%>.open();
+    	List<com.game_machine.orm.models.<%=klass%>> models = com.game_machine.orm.models.<%=klass%>.where("player_id = ?", playerId);
+    	List<<%=klass%>> messages = new ArrayList<<%=klass%>>();
+    	for (com.game_machine.orm.models.<%=klass%> model : models) {
+    		<%=klass%> <%= varname(klass) %> = fromModel(model);
+    		<% message_fields.each do |message_field| %>
+    		<%= varname(klass) %>.<%= varname(message_field) %> = <%= message_field %>.fromModel(model);
+    		<% end %>
+    		messages.add(<%= varname(klass) %>);
+    	}
+    	com.game_machine.orm.models.<%=klass%>.close();
+    	return messages;
+    }
+    
+    public static List<<%=klass%>> dbWhere(String query, Object ... params) {
+    	com.game_machine.orm.models.<%=klass%>.open();
+    	List<com.game_machine.orm.models.<%=klass%>> models = com.game_machine.orm.models.<%=klass%>.where(query, params);
+    	List<<%=klass%>> messages = new ArrayList<<%=klass%>>();
+    	for (com.game_machine.orm.models.<%=klass%> model : models) {
+    		<%=klass%> <%= varname(klass) %> = fromModel(model);
+    		<% message_fields.each do |message_field| %>
+    		<%= varname(klass) %>.<%= varname(message_field) %> = <%= message_field %>.fromModel(model);
+    		<% end %>
+    		messages.add(<%= varname(klass) %>);
+    	}
+    	com.game_machine.orm.models.<%=klass%>.close();
+    	return messages;
+    }
+    
+    
+<% end %>
+
+<% unless klass == 'Entity' %>
+
+	public static void clearModel(Model model) {
+    	<% message.getFields.each do |field| %>
+    	<% next unless simple_value?(field) %>
+    	<% next if field.isRepeated %>
+    	<% field_name = field.name.slice(0,1).capitalize + field.name.slice(1..-1) %>
+    	model.set("<%=sql_column_name(klass,field)%>",null);
+    	<% end %>
+    }
+    
+	public void toModel(Model model, String playerId) {
+    	<% message.getFields.each do |field| %>
+    	<% next unless simple_value?(field) %>
+    	<% next if field.isRepeated %>
+    	<% field_name = field.name.slice(0,1).capitalize + field.name.slice(1..-1) %>
+    	if (<%= field.name %> != null) {
+    		model.set<%=get_type(field) %>("<%=sql_column_name(klass,field)%>",<%= field.name %>);
+    	}
+    	<% end %>
+    	
+    	if (playerId != null) {
+    		model.set("player_id",playerId);
+    	}
+    }
+    
+	public static <%=klass%> fromModel(Model model) {
+		boolean hasFields = false;
+    	<%=klass%> message = new <%=klass%>();
+    	<% message.getFields.each do |field| %>
+    	<% next unless simple_value?(field) %>
+    	<% next if field.isRepeated %>
+    	<% field_name = field.name.slice(0,1).capitalize + field.name.slice(1..-1) %>
+    	
+    	<%=get_type(field) %> <%= field.name %>Field = model.get<%=get_type(field) %>("<%=sql_column_name(klass,field)%>");
+    	if (<%= field.name %>Field != null) {
+    		message.set<%= field_name %>(<%= field.name %>Field);
+    		hasFields = true;
+    	}
+    	<% end %>
+    	if (hasFields) {
+    		return message;
+    	} else {
+    		return null;
+    	}
+    }
+<% end %>
+
+<% if klass == 'Entity' %>
+	public ArrayList<String> componentNames() {
+		ArrayList<String> names = new ArrayList<String>();
+	<% messages.each do |m| %>
+	  <% if message.getFields.collect {|f| f.name}.include?(varname(m.getName)) %>
+		if (this.has<%=m.getName%>()) {
+			names.add(this.<%=varname(m.getName)%>.getClass().getSimpleName());
+		}
+	  <% end %>
+	<% end %>
+		return names;
+	}
+<% end %>
+
+<% message.getFields.each do |field| %>
+	<% field_name = field.name.slice(0,1).capitalize + field.name.slice(1..-1) %>
+    
+	<% if field.isRepeated %>
+	public List<<%=get_type(field)%>> get<%=field_name %>List() {
+		return <%= field.name %>;
+	}
+
+	public <%=klass%> set<%=field_name %>List(List<<%=get_type(field)%>> <%=field.name%>) {
+		this.<%=field.name%> = <%=field.name%>;
+		return this;
+	}
+
+	public <%=get_type(field) %> get<%=field_name %>(int index)  {
+        return <%=field.name%> == null ? null : <%=field.name%>.get(index);
+    }
+
+    public int get<%=field_name %>Count()  {
+        return <%=field.name%> == null ? 0 : <%=field.name%>.size();
+    }
+
+    public <%=klass%> add<%=field_name %>(<%=get_type(field) %> <%=field.name%>)  {
+        if(this.<%=field.name%> == null)
+            this.<%=field.name%> = new ArrayList<<%=get_type(field) %>>();
+        this.<%=field.name%>.add(<%=field.name%>);
+        return this;
+    }
+    <% if messages_index.has_key?(get_type(field)) %>
+    <% messages_index[get_type(field)].getFields.each do |simple_field| %>
+    	<% next unless simple_value?(simple_field) %>
+    	<% next if simple_field.isRepeated %>
+    	<% simple_field_name = simple_field.name.slice(0,1).capitalize + simple_field.name.slice(1..-1) %>
+    	
+    public <%=klass%> remove<%=field_name %>By<%=simple_field_name %>(<%=get_type(field) %> <%=field.name%>)  {
+    	if(this.<%=field.name%> == null)
+           return this;
+            
+       	Iterator<<%=get_type(field) %>> itr = this.<%=field.name%>.iterator();
+       	while (itr.hasNext()) {
+    	<%=get_type(field) %> obj = itr.next();
+    	
+    	<% if simple_field.getJavaType.to_s == 'String' %>
+    		if (<%=field.name%>.<%=simple_field.name%>.equals(obj.<%=simple_field.name%>)) {
+    	<% else %>
+    		if (<%=field.name%>.<%=simple_field.name%>.equals(obj.<%=simple_field.name%>)) {
+    	<% end %>
+      			itr.remove();
+    		}
+		}
+        return this;
+    }
+    
+    <% end %>
+    <% end %>
+    	
+    
+    
+    
+	<% else %>
+	public <%=get_type(field)%> get<%=field_name %>() {
+		return <%= field.name %>;
+	}
+	
+	public <%= field_name == '_EntityId' ? 'void' : klass%> set<%=field_name %>(<%=get_type(field)%> <%=field.name%>) {
+		this.<%=field.name%> = <%=field.name%>;
+		<%= field_name == '_EntityId' ? '' : 'return this;'%>
+	}
+	
+	public Boolean has<%=field_name %>()  {
+        return <%=field.name%> == null ? false : true;
+    }
+	<% end %>
+<% end %>
+
+  
+    // java serialization
+
+    public void readExternal(ObjectInput in) throws IOException
+    {
+        GraphIOUtil.mergeDelimitedFrom(in, this, this);
+    }
+
+    public void writeExternal(ObjectOutput out) throws IOException
+    {
+        GraphIOUtil.writeDelimitedTo(out, this, this);
+    }
+
+    // message method
+
+    public Schema<<%=klass%>> cachedSchema()
+    {
+        return DEFAULT_INSTANCE;
+    }
+
+    // schema methods
+
+    public <%=klass%> newMessage()
+    {
+        return new <%=klass%>();
+    }
+
+    public Class<<%=klass%>> typeClass()
+    {
+        return <%=klass%>.class;
+    }
+
+    public String messageName()
+    {
+        return <%=klass%>.class.getSimpleName();
+    }
+
+    public String messageFullName()
+    {
+        return <%=klass%>.class.getName();
+    }
+
+    public boolean isInitialized(<%=klass%> message)
+    {
+        return true;
+    }
+
+    public void mergeFrom(Input input, <%=klass%> message) throws IOException
+    {
+        for(int number = input.readFieldNumber(this);; number = input.readFieldNumber(this))
+        {
+            switch(number)
+            {
+                case 0:
+                    return;
+                <% message.getFields.each do |field| %>
+            	case <%=field.number%>:
+            	<% if field.isRepeated %>
+            		if(message.<%=field.name%> == null)
+                        message.<%=field.name%> = new ArrayList<<%=get_type(field)%>>();
+                    <% if field.isMessageField %>
+                    message.<%=field.name%>.add(input.mergeObject(null, <%=get_type(field)%>.getSchema()));
+                    <% elsif field.enumField %>
+                    message.<%=field.name%>.add(<%=get_type(field)%>.valueOf(input.readEnum()));
+                    <% else %>
+                	message.<%=field.name%>.add(input.read<%=field.getClass.getSimpleName%>());
+                	<% end %>
+                    break;
+                <% else %>
+                	<% if field.isMessageField %>
+                	message.<%=field.name%> = input.mergeObject(message.<%=field.name%>, <%=get_type(field)%>.getSchema());
+                    break;
+                    <% elsif field.enumField %>
+                    message.<%=field.name%> = <%=classname(field.name)%>.valueOf(input.readEnum());
+                    break;
+                	<% else %>
+                	message.<%=field.name%> = input.read<%=field.getClass.getSimpleName%>();
+                	break;
+                	<% end %>
+                	
+                <% end %>
+            	<% end %>
+            
+                default:
+                    input.handleUnknownField(number, this);
+            }   
+        }
+    }
+
+
+    public void writeTo(Output output, <%=klass%> message) throws IOException
+    {
+    	<% message.getFields.each do |field| %>
+    	
+    	<% if field.isRequired %>
+    	if(message.<%=field.name%> == null)
+            throw new UninitializedMessageException(message);
+    	<% end %>
+    	
+    	<% if field.isRepeated %>
+    	if(message.<%=field.name%> != null)
+        {
+            for(<%=get_type(field)%> <%=field.name%> : message.<%=field.name%>)
+            {
+                if(<%=field.name%> != null) {
+                   	<% if field.isMessageField %>
+    				output.writeObject(<%=field.number%>, <%=field.name%>, <%=get_type(field)%>.getSchema(), true);
+    				<% elsif field.enumField %>
+    				output.writeEnum(<%=field.number%>, <%=field.name%>.number, true);
+    				<% else %>
+            		output.write<%=field.getClass.getSimpleName%>(<%=field.number%>, <%=field.name%>, true);
+    				<% end %>
+    			}
+            }
+        }
+    	<% else %>
+    	<% if field.isMessageField %>
+    	if(message.<%=field.name%> != null)
+    		output.writeObject(<%=field.number%>, message.<%=field.name%>, <%=get_type(field)%>.getSchema(), false);
+    	<% elsif field.enumField %>
+    	 	output.writeEnum(<%=field.number%>, message.<%=field.name%>.number, false);
+    	<% else %>
+    	if(message.<%=field.name%> != null)
+            output.write<%=field.getClass.getSimpleName%>(<%=field.number%>, message.<%=field.name%>, false);
+    	<% end %>
+    	
+    	<% end %>
+        <% end %>
+    	
+    }
+
+    public String getFieldName(int number)
+    {
+        switch(number)
+        {
+        	<% message.getFields.each do |field| %>
+        	case <%=field.number%>: return "<%=field.name%>";
+        	<% end %>
+            default: return null;
+        }
+    }
+
+    public int getFieldNumber(String name)
+    {
+        final Integer number = __fieldMap.get(name);
+        return number == null ? 0 : number.intValue();
+    }
+
+    private static final java.util.HashMap<String,Integer> __fieldMap = new java.util.HashMap<String,Integer>();
+    static
+    {
+    	<% message.getFields.each do |field| %>
+    	__fieldMap.put("<%=field.name%>", <%=field.number%>);
+    	<% end %>
+    }
+   
+   public static List<String> getFields() {
+	ArrayList<String> fieldNames = new ArrayList<String>();
+	String fieldName = null;
+	Integer i = 1;
+	
+    while(true) { 
+		fieldName = <%=klass%>.getSchema().getFieldName(i);
+		if (fieldName == null) {
+			break;
+		}
+		fieldNames.add(fieldName);
+		i++;
+	}
+	return fieldNames;
+}
+
+public static <%=klass%> parseFrom(byte[] bytes) {
+	<%=klass%> message = new <%=klass%>();
+	ProtobufIOUtil.mergeFrom(bytes, message, RuntimeSchema.getSchema(<%=klass%>.class));
+	return message;
+}
+
+public static <%=klass%> parseFromJson(String json) throws IOException {
+	byte[] bytes = json.getBytes(Charset.forName("UTF-8"));
+	<%=klass%> message = new <%=klass%>();
+	JsonIOUtil.mergeFrom(bytes, message, RuntimeSchema.getSchema(<%=klass%>.class), false);
+	return message;
+}
+
+public <%=klass%> clone() {
+	byte[] bytes = this.toByteArray();
+	<%=klass%> <%=varname(klass)%> = <%=klass%>.parseFrom(bytes);
+	return <%=varname(klass)%>;
+}
+	
+public byte[] toByteArray() {
+	return toProtobuf();
+	//return toJson();
+}
+
+public String toJson() throws UnsupportedEncodingException {
+	boolean numeric = false;
+	ByteArrayOutputStream out = new ByteArrayOutputStream();
+	try {
+		JsonIOUtil.writeTo(out, this, <%=klass%>.getSchema(), numeric);
+	} catch (IOException e) {
+		e.printStackTrace();
+		throw new RuntimeException("Json encoding failed");
+	}
+	String json = new String(out.toByteArray(), Charset.forName("UTF-8"));
+	return json;
+}
+
+public byte[] toPrefixedByteArray() {
+	LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
+  Schema<<%=klass%>> schema = RuntimeSchema.getSchema(<%=klass%>.class);
+    
+	final ByteArrayOutputStream out = new ByteArrayOutputStream();
+    final ProtobufOutput output = new ProtobufOutput(buffer);
+    try
+    {
+    	schema.writeTo(output, this);
+        final int size = output.getSize();
+        ProtobufOutput.writeRawVarInt32Bytes(out, size);
+        final int msgSize = LinkedBuffer.writeTo(out, buffer);
+        assert size == msgSize;
+        
+        buffer.clear();
+        return out.toByteArray();
+    }
+    catch (IOException e)
+    {
+        throw new RuntimeException("Serializing to a byte array threw an IOException " + 
+                "(should never happen).", e);
+    }
+ 
+}
+
+public byte[] toProtobuf() {
+	LinkedBuffer buffer = LocalLinkedBuffer.get();
+	byte[] bytes = null;
+
+	try {
+		bytes = ProtobufIOUtil.toByteArray(this, RuntimeSchema.getSchema(<%=klass%>.class), buffer);
+		buffer.clear();
+	} catch (Exception e) {
+		e.printStackTrace();
+		throw new RuntimeException("Protobuf encoding failed");
+	}
+	return bytes;
+}
+
+public ByteBuf toByteBuf() {
+	ByteBuf bb = Unpooled.buffer(512, 2048);
+	LinkedBuffer buffer = LinkedBuffer.use(bb.array());
+
+	try {
+		ProtobufIOUtil.writeTo(buffer, this, RuntimeSchema.getSchema(<%=klass%>.class));
+	} catch (Exception e) {
+		e.printStackTrace();
+		throw new RuntimeException("Protobuf encoding failed");
+	}
+	return bb;
+}
+
+}