added TemplateReference class and changed template building mechanism again

muga · muga · commit 56473bef2ed6 · 2011-08-12T23:38:28.000+09:00
diff --git a/src/main/java/org/msgpack/template/TemplateReference.java b/src/main/java/org/msgpack/template/TemplateReference.java
@@ -0,0 +1,53 @@
+//
+// MessagePack for Java
+//
+// Copyright (C) 2009-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.
+//
+package org.msgpack.template;
+
+import java.io.IOException;
+
+import org.msgpack.packer.Packer;
+import org.msgpack.unpacker.Unpacker;
+
+
+public class TemplateReference<T> extends AbstractTemplate<T> {
+
+    private Template<T> actualTemplate;
+
+    public void setTemplate(Template<T> actualTemplate) {
+	this.actualTemplate = actualTemplate;
+    }
+
+    @Override
+    public void write(Packer pk, T v, boolean required) throws IOException {
+	actualTemplate.write(pk, v, required);
+    }
+
+    @Override
+    public void write(Packer pk, T v) throws IOException {
+	actualTemplate.write(pk, v, false);
+    }
+
+    @Override
+    public T read(Unpacker u, T to, boolean required) throws IOException {
+	return actualTemplate.read(u, to, required);
+    }
+
+    @Override
+    public T read(Unpacker u, T to) throws IOException {
+        return actualTemplate.read(u, to, false);
+    }
+}
diff --git a/src/main/java/org/msgpack/template/TemplateRegistry.java b/src/main/java/org/msgpack/template/TemplateRegistry.java
@@ -17,6 +17,7 @@
 //
 package org.msgpack.template;
 
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
@@ -62,6 +63,8 @@ public class TemplateRegistry {
 
     private Map<Type, GenericTemplate> genericCache;
 
+    private Map<Type, List<TemplateReference>> templateReferences;
+
     public TemplateRegistry() {
 	this(null);
     }
@@ -70,6 +73,7 @@ public TemplateRegistry(TemplateRegistry registry) {
 	parent = registry;
 	cache = new HashMap<Type, Template<Type>>();
 	genericCache = new HashMap<Type, GenericTemplate>();
+	templateReferences = new HashMap<Type, List<TemplateReference>>();
 	if (parent == null) {
 	    registerTemplates();
 	    chain = new TemplateBuilderChain();
@@ -79,6 +83,29 @@ public TemplateRegistry(TemplateRegistry registry) {
 	}
     }
 
+    private boolean notBuilding(Type targetType) {
+	return !templateReferences.containsKey(targetType);
+    }
+
+    private void startBuilding(Type targetType) {
+	List<TemplateReference> list = new ArrayList<TemplateReference>();
+	templateReferences.put(targetType, list);
+    }
+
+    private Template getTemplateReference(Type targetType) {
+	List<TemplateReference> list = templateReferences.get(targetType);
+	TemplateReference tmpl = new TemplateReference();
+	list.add(tmpl);
+	return tmpl;
+    }
+
+    private void finishBuilding(Type targetType, Template actualTemplate) {
+	List<TemplateReference> list = templateReferences.remove(targetType);
+	for (TemplateReference tmpl : list) {
+	    tmpl.setTemplate(actualTemplate);
+	}
+    }
+
     private void registerTemplates() {
         register(boolean.class, BooleanTemplate.getInstance());
         register(Boolean.class, BooleanTemplate.getInstance());
@@ -123,7 +150,15 @@ public void register(final Class<?> targetClass, final FieldList flist) {
 	if (flist == null) {
 	    throw new NullPointerException("FieldList object is null");
 	}
-	register(targetClass, chain.select(targetClass, false).buildTemplate(targetClass, flist));
+	Template<?> tmpl;
+	if (notBuilding(targetClass)) {
+	    startBuilding(targetClass);
+	    tmpl = chain.select(targetClass, false).buildTemplate(targetClass, flist);
+	    finishBuilding(targetClass, tmpl);
+	} else {
+	    tmpl = getTemplateReference(targetClass);
+	}
+	register(targetClass, tmpl);
     }
 
     public synchronized void register(final Type targetType, final Template tmpl) {
@@ -173,6 +208,18 @@ public synchronized Template tryLookup(Type targetType, final boolean forceBuild
 
     private synchronized Template lookupImpl(Type targetType, final boolean forceLoad, final boolean forceBuild) {
 	Template tmpl;
+	if (notBuilding(targetType)) {
+	    startBuilding(targetType);
+	    tmpl = lookupImpl0(targetType, forceLoad, forceBuild);
+	    finishBuilding(targetType, tmpl);
+	} else {
+	    tmpl = getTemplateReference(targetType);
+	}
+	return tmpl;
+    }
+
+    private synchronized Template lookupImpl0(Type targetType, final boolean forceLoad, final boolean forceBuild) {
+	Template tmpl;
 
 	if (targetType instanceof ParameterizedType) {
 	    ParameterizedType pType = (ParameterizedType) targetType;
