DefaultBuildContext.java

//
// 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.builder;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Modifier;

import org.msgpack.*;
import org.msgpack.packer.Packer;
import org.msgpack.template.*;
import org.msgpack.unpacker.Unpacker;

import javassist.CannotCompileException;
import javassist.CtClass;
import javassist.CtConstructor;
import javassist.CtNewConstructor;
import javassist.NotFoundException;


@SuppressWarnings({ "rawtypes", "unchecked" })
public class DefaultBuildContext extends BuildContext<FieldEntry> {
    protected FieldEntry[] entries;

    protected Class<?> origClass;

    protected String origName;

    protected Template<?>[] templates;

    public DefaultBuildContext(JavassistTemplateBuilder director) {
	super(director);
    }

    public Template buildTemplate(Class targetClass, FieldEntry[] entries, Template[] templates) {
	this.entries = entries;
	this.templates = templates;
	this.origClass = targetClass;
	this.origName = origClass.getName();
	return build(origName);
    }

    protected void setSuperClass() throws CannotCompileException, NotFoundException {
	tmplCtClass.setSuperclass(director.getCtClass(
		JavassistTemplateBuilder.JavassistTemplate.class.getName()));
    }

    protected void buildConstructor() throws CannotCompileException,
	    NotFoundException {
	// Constructor(Class targetClass, Template[] templates)
	CtConstructor newCtCons = CtNewConstructor.make(
		new CtClass[] {
			director.getCtClass(Class.class.getName()),
			director.getCtClass(Template.class.getName() + "[]")
		}, new CtClass[0], tmplCtClass);
	tmplCtClass.addConstructor(newCtCons);
    }

    protected Template buildInstance(Class<?> c) throws NoSuchMethodException,
	    InstantiationException, IllegalAccessException, InvocationTargetException {
	Constructor<?> cons = c.getConstructor(new Class[] { Class.class, Template[].class });
	Object tmpl = cons.newInstance(new Object[] { origClass, templates });
	return (Template) tmpl;
    }

    protected void buildMethodInit() {
    }

    protected String buildWriteMethodBody() {
	resetStringBuilder();
	buildString("\n{\n");

        buildString("  if ($2 == null) {\n");
        buildString("    if ($3) {\n");
        buildString("      throw new %s(\"Attempted to write null\");\n", MessageTypeException.class.getName());
        buildString("    }\n");
        buildString("    $1.writeNil();\n");
        buildString("    return;\n");
        buildString("  }\n");

	buildString("  %s _$$_t = (%s) $2;\n", origName, origName);
	buildString("  $1.writeArrayBegin(%d);\n", entries.length);

	for (int i = 0; i < entries.length; i++) {
	    FieldEntry e = entries[i];
	    if (!e.isAvailable()) {
		buildString("  $1.writeNil();\n");
		continue;
	    }
	    DefaultFieldEntry de = (DefaultFieldEntry) e;
	    boolean isPrivate = Modifier.isPrivate(de.getField().getModifiers());
	    Class<?> type = de.getType();
	    if (type.isPrimitive()) { // primitive types
		if (!isPrivate) {
		    buildString("  $1.%s(_$$_t.%s);\n", primitiveWriteName(type), de.getName());
		} else {
		    buildString("  %s.writePrivateField($1, _$$_t, %s.class, \"%s\", templates[%d]);\n",
			    DefaultBuildContext.class.getName(), de.getField().getDeclaringClass().getName(), de.getName(), i);
		}
	    } else { // reference types
	        if (!isPrivate) {
                    buildString("  if (_$$_t.%s == null) {\n", de.getName());
	        } else {
                    buildString("  if (%s.readPrivateField(_$$_t, %s.class, \"%s\") == null) {\n",
                            DefaultBuildContext.class.getName(), de.getField().getDeclaringClass().getName(), de.getName());
	        }
		if (de.isNotNullable()) {
		    buildString("    throw new %s(\"%s cannot be null by @NotNullable\");\n",
			    MessageTypeException.class.getName(), de.getName());
		} else {
		    buildString("    $1.writeNil();\n");
		}
		buildString("  } else {\n");
		if (!isPrivate) {
		    buildString("    templates[%d].write($1, _$$_t.%s);\n", i, de.getName());
		} else {
		    buildString("    %s.writePrivateField($1, _$$_t, %s.class, \"%s\", templates[%d]);\n",
			    DefaultBuildContext.class.getName(), de.getField().getDeclaringClass().getName(), de.getName(), i);
		}
		buildString("  }\n");
	    }
	}

	buildString("  $1.writeArrayEnd();\n");
	buildString("}\n");
	return getBuiltString();
    }

    public static Object readPrivateField(Object target, Class targetClass, String fieldName) {
	Field field = null;
	try {
	    field = targetClass.getDeclaredField(fieldName);
	    field.setAccessible(true);
	    Object valueReference = field.get(target);
	    return valueReference;
	} catch (Exception e) {
	    throw new MessageTypeException(e);
	} finally {
	    if (field != null) {
		field.setAccessible(false);
	    }
	}
    }

    public static void writePrivateField(Packer packer, Object target, Class targetClass, String fieldName, Template tmpl) {
	Field field = null;
	try {
	    field = targetClass.getDeclaredField(fieldName);
	    field.setAccessible(true);
	    Object valueReference = field.get(target);
	    tmpl.write(packer, valueReference);
	} catch (Exception e) {
	    throw new MessageTypeException(e);
	} finally {
	    if (field != null) {
		field.setAccessible(false);
	    }
	}
    }

    protected String buildReadMethodBody() {
	resetStringBuilder();
	buildString("\n{\n");

        buildString("  if (!$3 && $1.trySkipNil()) {\n");
        buildString("    return null;\n");
        buildString("  }\n");

	buildString("  %s _$$_t;\n", origName);
	buildString("  if ($2 == null) {\n");
	buildString("    _$$_t = new %s();\n", origName);
	buildString("  } else {\n");
	buildString("    _$$_t = (%s) $2;\n", origName);
	buildString("  }\n");
	buildString("  $1.readArrayBegin();\n");

	int i;
	for (i = 0; i < entries.length; i++) {
	    FieldEntry e = entries[i];
	    if (!e.isAvailable()) {
		buildString("  $1.skip();\n");
		continue;
	    }

            if (e.isOptional()) {
	        buildString("  if ($1.trySkipNil()) {");
	        // if Optional and nil, then keep default value
	        buildString("  } else {\n");
            }

	    DefaultFieldEntry de = (DefaultFieldEntry) e;
	    boolean isPrivate = Modifier.isPrivate(de.getField().getModifiers());
	    Class<?> type = de.getType();
	    if (type.isPrimitive()) {
		if (!isPrivate) {
		    buildString("    _$$_t.%s = $1.%s();\n", de.getName(), primitiveReadName(type));
		} else {
		    buildString("    %s.readPrivateField($1, _$$_t, %s.class, \"%s\", templates[%d]);\n",
			    DefaultBuildContext.class.getName(), de.getField().getDeclaringClass().getName(), de.getName(), i);
		}
	    } else {
		if (!isPrivate) {
		    buildString("    _$$_t.%s = (%s) this.templates[%d].read($1, _$$_t.%s);\n",
			    de.getName(), de.getJavaTypeName(), i, de.getName());
		} else {
		    buildString("    %s.readPrivateField($1, _$$_t, %s.class, \"%s\", templates[%d]);\n",
			    DefaultBuildContext.class.getName(), de.getField().getDeclaringClass().getName(), de.getName(), i);
		}
	    }

            if (de.isOptional()) {
	        buildString("  }\n");
            }
	}

	buildString("  $1.readArrayEnd();\n");
	buildString("  return _$$_t;\n");

	buildString("}\n");
	return getBuiltString();
    }

    public static void readPrivateField(Unpacker unpacker, Object target, Class targetClass, String fieldName, Template tmpl) {
	Field field = null;
	try {
	    field = targetClass.getDeclaredField(fieldName);
	    field.setAccessible(true);
	    Object fieldReference = field.get(target);
	    Object valueReference = tmpl.read(unpacker, fieldReference);
	    if (valueReference != fieldReference) {
		field.set(target, valueReference);
	    }
	} catch (Exception e) {
	    throw new MessageTypeException(e);
	} finally {
	    if (field != null) {
		field.setAccessible(false);
	    }
	}
    }

    @Override
    public void writeTemplate(Class<?> targetClass, FieldEntry[] entries, Template[] templates, String directoryName) {
	this.entries = entries;
	this.templates = templates;
	this.origClass = targetClass;
	this.origName = origClass.getName();
	write(origName, directoryName);
    }

    @Override
    public Template loadTemplate(Class<?> targetClass, FieldEntry[] entries, Template[] templates) {
	this.entries = entries;
	this.templates = templates;
	this.origClass = targetClass;
	this.origName = origClass.getName();
	return load(origName);
    }
}