com.jrodeo.bson.generator.MarshallerGenerator Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of bson-marshaller Show documentation
Show all versions of bson-marshaller Show documentation
A tool to create Java marshallers to and from bson. Currently used in a data access
layer serialize Json to Bson for MongoDB storage.
package com.jrodeo.bson.generator;
import com.fasterxml.jackson.annotation.*;
import com.jrodeo.bson.annotation.BsonIgnore;
import org.apache.commons.lang3.ClassUtils;
import org.bson.types.ObjectId;
import java.io.File;
import java.io.FileWriter;
import java.lang.annotation.Annotation;
import java.lang.reflect.*;
import java.math.BigDecimal;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.*;
/**
* The MarshallerGenerator can be used by calling the main()
* method with two system properties set. -Doutput.dir=[path/to/output/directory]
* -Dclass.names=[comma separated list of top level classes to build marshallers for]
* and an optional 3rd jar file list containing those classes-Djar.files=[comma separated
* list of jar files to add to classpath]. It is easy to use during your maven build
* with something like:
*
* {@code
*
* org.codehaus.mojo
* exec-maven-plugin
* 1.4.0
*
* true
* true
*
*
* com.jrodeo
* bson-marshaller
*
* com.jrodeo.bson.generator.MarshallerGenerator
*
*
* output.dir
* ${project.build.directory}/generated-sources/annotations
*
*
* class.names
* com.example.MyBean,com.example.Bean2
*
*
*
*
*
* create-marshallers
* generate-sources
*
* java
*
*
*
*
*
* com.jrodeo
* bson-marshaller
* ${jrodeo.marshaller.version}
*
*
*
* }
*
*
* If you have downloaded the project from github
* jrodeo-bson
* you may build this project all at once with maven and a running mongod on default port, use
*
* {@code
* mvn clean install test-compile failsafe:integration-test}
*
*
* See the tests and test resources for how to configure runtimes with Spring.
* First mvn clean install will run the MarshallerGeneratorTest that builds some
* Marshallers
* . Next, the IT can be run with mvn test-compile failsafe:integration-test.
* The Spring config mongo-example-context.xml sets up the Marshallers, wires
* up a MongoClient and then sets up the MongoDB codecs.
*
* If you do not have the project, you may find the test sources with the following dependency
*
* {@code
*
* com.jrodeo
* bson-marshaller
* 0.9
* test-sources
*
* }
*
*/
public class MarshallerGenerator {
static String outputPath = "path.to.output";
public static void setOutputPath(String outputPath) {
MarshallerGenerator.outputPath = outputPath;
}
String beanPackage;
String factoryName;
public String getBeanPackage() {
return beanPackage;
}
public void setBeanPackage(String beanPackage) {
this.beanPackage = beanPackage;
}
public String getFactoryName() {
return factoryName;
}
public void setFactoryName(String factoryName) {
this.factoryName = factoryName;
}
public void buildCodec(Class clazz) throws Exception {
String packageToDirs = beanPackage.replace(".", File.separator)
+ File.separator;
if (!outputPath.endsWith(File.separator)) {
outputPath += File.separator;
}
File outputDir = new File(outputPath + packageToDirs);
outputDir.mkdirs();
String s;
s = "package " + beanPackage + ";\n";
s += "\n";
s += "import com.jrodeo.bson.marshallers.*;\n";
s += "import java.util.*;\n";
s += "import org.bson.*;\n";
s += "import org.bson.codecs.*;\n";
s += "\n";
s += "public class " + clazz.getSimpleName()
+ "Codec implements Codec<" + clazz.getSimpleName() + "> {\n";
s += "\n";
s += "Marshaller<" + clazz.getSimpleName()
+ "> marshaller = MarshallerRegistry.getInstance().lookupMarshaller("
+ clazz.getName() + ".class);\n";
s += "\n";
s += "@Override\n";
s += "public "
+ clazz.getSimpleName()
+ " decode(BsonReader reader, DecoderContext decoderContext) {\n";
s += " try {\n";
s += " return marshaller.read(reader);\n";
s += " } catch(Exception e) {\n";
s += " throw new RuntimeException(e);\n";
s += " }\n";
s += "}\n";
s += "\n";
s += "@Override\n";
s += "public void encode(BsonWriter writer, " + clazz.getSimpleName()
+ " value, EncoderContext encoderContext) {\n";
s += " marshaller.write(writer, value);\n";
s += "}\n";
s += "\n";
s += "@Override\n";
s += "public Class<" + clazz.getSimpleName()
+ "> getEncoderClass() {\n";
s += " return " + clazz.getSimpleName() + ".class;\n";
s += "}\n";
s += "\n";
s += "}\n";
// System.out.println(s);
String fullPath = outputPath + packageToDirs + clazz.getSimpleName()
+ "Codec.java";
FileWriter fileWriter = new FileWriter(fullPath);
fileWriter.write(s);
fileWriter.close();
}
public void buildMarshallerFactory(List classes) throws Exception {
String packageToDirs = beanPackage.replace(".", File.separator)
+ File.separator;
if (!outputPath.endsWith(File.separator)) {
outputPath += File.separator;
}
File outputDir = new File(outputPath + packageToDirs);
outputDir.mkdirs();
String s;
s = "package " + beanPackage + ";\n";
s += "\n";
s += "import com.jrodeo.bson.marshallers.*;\n";
s += "import java.util.*;\n";
s += "import org.bson.*;\n";
s += "import org.bson.codecs.*;\n";
s += "\n";
s += "public class " + factoryName + "MarshallerFactory extends AbstractMarshallerFactory {\n";
s += "\n";
s += "public " + factoryName + "MarshallerFactory() {\n";
s += " super();\n";
for (Class clazz : classes) {
String classname = clazz.getName();
String marshaller = classname + "Marshaller";
s += " registerMarshaller(new " + marshaller + "());\n";
}
s += "}\n";
s += "\n";
s += "}\n";
// System.out.println(s);
String fullPath = outputPath + packageToDirs + factoryName + "MarshallerFactory.java";
FileWriter fileWriter = new FileWriter(fullPath);
fileWriter.write(s);
fileWriter.close();
}
public boolean buildMarshaller(Class clazz, List fieldInfos)
throws Exception {
/*
if(Modifier.isAbstract(clazz.getModifiers())) {
return false;
}
*/
if (isAList(clazz) || clazz.isArray()) {
return false;
}
if (isAMap(clazz)) {
return false;
}
if (ClassUtils.isPrimitiveOrWrapper(clazz)) {
return false;
}
if (clazz.equals(String.class)) {
return false;
}
if (clazz.equals(Date.class)) {
return false;
}
if (clazz.equals(BigDecimal.class)) {
return false;
}
String packageToDirs = beanPackage.replace(".", File.separator)
+ File.separator;
if (!outputPath.endsWith(File.separator)) {
outputPath += File.separator;
}
File outputDir = new File(outputPath + packageToDirs);
outputDir.mkdirs();
String s;
variableNameCnt = 0;
s = "package " + beanPackage + ";\n";
s += "\n";
s += "import com.jrodeo.bson.marshallers.*;\n";
s += "import java.util.*;\n";
s += "import org.bson.*;\n";
s += "\n";
s += "public class "
+ clazz.getSimpleName()
+ "Marshaller implements com.jrodeo.bson.marshallers.Marshaller<"
+ clazz.getName() + "> {\n";
s += "\n";
s += "MarshallerRegistry registry;";
s += "\n";
s += "public void setRegistry(MarshallerRegistry registry) {\n";
s += " this.registry = registry;\n";
s += "}\n";
s += "\n";
s += "public Class getForClass() {\n";
s += " return " + clazz.getName() + ".class;\n";
s += "}\n";
SubTypeInfo subTypeInfo = mapOfSubTypeInfo.get(clazz);
s += "public String subTypeName() {\n";
if (subTypeInfo != null) {
s += "return \"" + subTypeInfo.name + "\";\n";
} else {
s += "return null;\n";
}
s += "}\n";
s += "\n";
s += "public Class getSuperType() {\n";
if (subTypeInfo != null) {
s += "return " + subTypeInfo.parentClass.getName() + ".class;\n";
} else {
s += "return null;\n";
}
s += "}\n";
s += "\n";
s += "public void write(BsonWriter writer, " + clazz.getName() + " obj) {\n";
if (clazz.isEnum()) {
s += " writer.writeString(obj.name());\n";
} else {
s += "writer.writeStartDocument();\n";
if (subTypeInfo != null) {
s += "writer.writeString(\"" + subTypeInfo.fieldName + "\", \"" + subTypeInfo.name + "\");\n";
} else if (hasSubTypesMap.get(clazz) != null && !Modifier.isAbstract(clazz.getModifiers())) {
String fieldName = hasSubTypesMap.get(clazz);
String classTypeName = getClassTypeName(clazz);
s += "writer.writeString(\"" + fieldName + "\", \"" + classTypeName + "\");\n";
}
FieldInfo idFieldInfo = getIdFieldInfo(fieldInfos);
if (idFieldInfo != null) {
s += idFieldInfo.getMarshallCode("obj");
}
for (FieldInfo fieldInfo : fieldInfos) {
if (fieldInfo == idFieldInfo) {
continue;
}
s += fieldInfo.getMarshallCode("obj");
}
s += "writer.writeEndDocument();\n";
}
s += "}\n";
s += "\n";
s += "public "
+ clazz.getName()
+ " read(BsonReader reader) {\n";
FieldInfo skipIdFieldInfo = null;
if (clazz.isEnum()) {
s += " return " + clazz.getName() + ".valueOf(reader.readString());\n";
} else {
if (subTypeInfo == null) {
s += "reader.readStartDocument();\n";
}
if (hasSubTypesMap.get(clazz) != null) {
skipIdFieldInfo = getIdFieldInfo(fieldInfos);
String _idFieldValue = "";
if(skipIdFieldInfo!=null) {
s += "String _idFieldName = reader.readName();\n";
CodeBlock codeBlock = skipIdFieldInfo.getUnmarshallerCode(null);
s += codeBlock.s;
_idFieldValue = codeBlock.v;
}
s += "String _typeFieldName = reader.readName();\n";
s += "String _typeFieldTypeName = reader.readString();\n";
s += clazz.getName() + " obj;\n";
s += "boolean doBody=true;\n";
boolean isAbstract = Modifier.isAbstract(clazz.getModifiers());
String hashForParent = getClassTypeName(clazz);
if (!isAbstract) {
s += "if(_typeFieldTypeName.equals(\"" + hashForParent + "\")) {\n";
s += " obj = new " + clazz.getName() + "();\n";
s += "} else {\n";
}
s += " obj = (" + clazz.getName()
+ ") registry.lookupMarshaller(" + clazz.getName() + ".class, _typeFieldTypeName).read(reader);\n";
s += " doBody = false;\n";
if (!isAbstract) {
s += "}\n";
}
if(skipIdFieldInfo!=null) {
s += "obj." + skipIdFieldInfo.setter.getName() + "("
+ _idFieldValue + ");\n";
}
} else {
s += clazz.getName() + " obj=new " + clazz.getName() + "();\n";
}
if (subTypeInfo != null) {
skipIdFieldInfo = getIdFieldInfo(fieldInfos);
}
if (hasSubTypesMap.get(clazz) != null) {
s += "if(doBody) {\n";
}
s += "while(reader.readBsonType() != BsonType.END_OF_DOCUMENT) {\n";
s += " String fieldName = reader.readName();\n";
s += " Setter setter = setterMap.get(fieldName);\n";
s += " if(setter!=null) {\n";
s += " setter.evaluate(reader, obj, registry);\n";
s += " } else {\n";
s += " reader.skipValue();\n";
s += " }\n";
s += "}\n";
if (hasSubTypesMap.get(clazz) != null) {
s += "}\n";
}
if (subTypeInfo == null) {
s += "reader.readEndDocument();\n";
}
s += "return obj;\n";
s += "}\n";
s += "interface Setter {\n";
s += " public void evaluate(BsonReader reader, " + clazz.getName() + " obj, MarshallerRegistry registry)\n" +
" ;\n";
s += "}\n";
s += "static final HashMap setterMap = new HashMap<>(199);\n";
s += "static {\n";
s += "Setter setter;\n";
for (FieldInfo fieldInfo : fieldInfos) {
if (fieldInfo == skipIdFieldInfo) {
continue;
}
CodeBlock codeBlock = fieldInfo.getUnmarshallerCode("obj");
s += " setter = new Setter() {\n";
s += " public void evaluate(BsonReader reader, " + clazz.getName() + " obj, MarshallerRegistry registry)\n" +
" {\n";
s += " " + codeBlock.s;
s += " }\n";
s += " };\n";
s += " setterMap.put(\""+fieldInfo.jsonFieldName + "\",setter);\n";
}
}
s += "}\n";
s += "}\n"; // close class
// System.out.println(s);
String fullPath = outputPath + packageToDirs + clazz.getSimpleName()
+ "Marshaller.java";
FileWriter fileWriter = new FileWriter(fullPath);
fileWriter.write(s);
fileWriter.close();
return true;
}
Map> mapOfFieldInfos = new HashMap<>();
public Map> getMapOfFieldInfos() {
return mapOfFieldInfos;
}
boolean haveClass(Class clazz) {
if (mapOfFieldInfos.containsKey(clazz)) {
return true;
}
if (ClassUtils.isPrimitiveOrWrapper(clazz)) {
return true;
}
if (clazz.isArray()) {
return true;
}
if (clazz.equals(String.class)) {
return true;
}
if (clazz.equals(UUID.class)) {
return true;
}
if (clazz.equals(ObjectId.class)) {
return true;
}
if (clazz.equals(Date.class)) {
return true;
}
return false;
}
Map mapOfSubTypeInfo = new HashMap<>();
public Map getMapOfSubTypeInfo() {
return mapOfSubTypeInfo;
}
class SubTypeInfo {
Class clazz;
String fieldName;
String name;
Class parentClass;
}
FieldInfo getIdFieldInfo(List fieldInfos) {
for (FieldInfo fieldInfo : fieldInfos) {
if (fieldInfo.fieldName.equals("_id")
|| fieldInfo.field.getName().equals("_id")
|| fieldInfo.jsonFieldName.equals("_id")) {
return fieldInfo;
}
}
return null;
}
String getClassTypeName(Class clazz) {
String typeName;
Annotation a = clazz.getAnnotation(JsonTypeName.class);
if(a!=null) {
typeName = ((JsonTypeName) a).value();
} else {
typeName = clazz.getSimpleName();
}
return typeName;
}
Map hasSubTypesMap = new HashMap<>();
void checkSubTypeInfoForClass(Class clazz) throws Exception {
String fieldName = null;
boolean hasSubTypes = false;
Annotation[] ca = clazz.getDeclaredAnnotations();
for (Annotation a : ca) {
if (getTypeName(a.annotationType())
.equals("com.fasterxml.jackson.annotation.JsonTypeInfo")) {
fieldName = ((JsonTypeInfo) a).property();
}
}
for (Annotation a : ca) {
if (getTypeName(a.annotationType())
.equals("com.fasterxml.jackson.annotation.JsonSubTypes")) {
JsonSubTypes jst = (JsonSubTypes) a;
hasSubTypes = true;
for (JsonSubTypes.Type subType : jst.value()) {
SubTypeInfo subTypeInfo = new SubTypeInfo();
subTypeInfo.clazz = subType.value();
subTypeInfo.parentClass = clazz;
subTypeInfo.fieldName = fieldName;
subTypeInfo.name = subType.name();
mapOfSubTypeInfo.put(subTypeInfo.clazz, subTypeInfo);
}
}
}
hasSubTypesMap.put(clazz, fieldName);
}
public Map> getFieldInfosForClasses(Class clazz,
List fieldInfos) throws Exception {
if (haveClass(clazz)) {
return mapOfFieldInfos;
}
checkSubTypeInfoForClass(clazz);
List classes = new ArrayList<>();
classes.add(clazz);
Class p = clazz.getSuperclass();
while (p != null) {
classes.add(p);
p = p.getSuperclass();
}
List methodInfos = new ArrayList<>();
for (Class c : classes) {
Field[] cf = c.getDeclaredFields();
Method[] ma = c.getDeclaredMethods();
for (Field f : cf) {
Annotation[] fa = f.getDeclaredAnnotations();
boolean bsonIgnore = false;
for(Annotation a: fa) {
if(a.annotationType().equals("com.jrodeo.bson.annotation.BsonIgnore")) {
bsonIgnore = ((BsonIgnore) a).value();
break;
}
}
if(bsonIgnore) {
continue;
}
for (Annotation a : fa) {
if (getTypeName(a.annotationType())
.equals("com.fasterxml.jackson.annotation.JsonProperty")) {
JsonProperty jsonProperty = (JsonProperty) a;
FieldInfo fieldInfo = getFieldInfo(f, fieldInfos);
if (fieldInfo == null) {
fieldInfo = new FieldInfo();
fieldInfo.field = f;
fieldInfos.add(fieldInfo);
}
fieldInfo.type = f.getType();
fieldInfo.fieldName = f.getName();
fieldInfo.jsonFieldName = jsonProperty.value();
fieldInfo.parentClassName = clazz.getSimpleName();
fieldInfo.jsonProperty = jsonProperty;
} else if (getTypeName(a.annotationType())
.equals("com.fasterxml.jackson.annotation.JsonInclude")) {
JsonInclude jsonInclude = (JsonInclude) a;
FieldInfo fieldInfo = getFieldInfo(f, fieldInfos);
if (fieldInfo == null) {
fieldInfo = new FieldInfo();
fieldInfo.field = f;
fieldInfos.add(fieldInfo);
}
fieldInfo.jsonInclude = jsonInclude;
}
}
}
for (Method m : ma) {
MethodInfo methodInfo = new MethodInfo();
methodInfo.method = m;
Annotation[] as = m.getDeclaredAnnotations();
for (Annotation a : as) {
if (getTypeName(a.annotationType())
.equals("com.fasterxml.jackson.annotation.JsonProperty")) {
methodInfo.jsonProperty = (JsonProperty) a;
}
}
methodInfos.add(methodInfo);
}
}
for (FieldInfo fieldInfo : fieldInfos) {
findGetterSetter(fieldInfo, methodInfos);
findCollectionTypes(fieldInfo);
}
mapOfFieldInfos.put(clazz, fieldInfos);
for (FieldInfo fieldInfo : fieldInfos) {
getFieldInfosForClasses(fieldInfo.type, new ArrayList());
}
return mapOfFieldInfos;
}
FieldInfo getFieldInfo(Field f, List fieldInfos) {
for (FieldInfo fieldInfo : fieldInfos) {
if (fieldInfo.field.equals(f)) {
return fieldInfo;
}
}
return null;
}
void findCollectionTypes(FieldInfo fieldInfo) throws Exception {
Type signatureType = fieldInfo.field.getGenericType();
if (fieldInfo.type.isArray()) {
if ("[I)".equals(signatureType)) {
// int[];
} else if ("[Z)".equals(signatureType)) {
// boolean[]
} else if ("[B)".equals(signatureType)) {
// byte[]
} else if ("[C)".equals(signatureType)) {
// char[]
} else if ("[S)".equals(signatureType)) {
// short[]
} else if ("[J)".equals(signatureType)) {
// long[]
} else if ("[F)".equals(signatureType)) {
// float[]
} else if ("[D)".equals(signatureType)) {
// double[]
}
}
if (signatureType instanceof ParameterizedType) {
ParameterizedType parameterizedType = (ParameterizedType) signatureType;
fieldInfo.parametrizedTypeArguments = parameterizedType
.getActualTypeArguments();
for (Type t : fieldInfo.parametrizedTypeArguments) {
if (t instanceof Class) {
getFieldInfosForClasses((Class) t, new ArrayList());
}
}
// same as fieldInfo.type Type rawType =
// parameterizedType.getRawType();
}
lookupInstanceTypes(fieldInfo);
}
void lookupInstanceTypes(FieldInfo fieldInfo) {
Class type = fieldInfo.type;
String instanceCreation = instanceTypeMap.get(type.getName());
fieldInfo.instanceCreator = instanceCreation;
}
Map instanceTypeMap = new HashMap<>();
/*
* Map classToWriterMap = new HashMap<>();
*
* static { instanceTypeMap.put("java.util.List", "new ArrayList<>()");
* instanceTypeMap.put("java.util.Map", "new HashMap<>()");
* classToWriterMap.put(String.class, "writer.writeString(#value);");
*
* }
*/
void findGetterSetter(FieldInfo fieldInfo, List methodInfos) {
for (MethodInfo methodInfo : methodInfos) {
if (methodInfo.jsonProperty != null
&& fieldInfo.jsonProperty.value().equalsIgnoreCase(
methodInfo.jsonProperty.value())) {
// first look for get/set by jsonProperty or override
if (methodInfo.method.getName().startsWith("get")) {
fieldInfo.getter = methodInfo.method;
} else if (methodInfo.method.getName().startsWith("set")) {
fieldInfo.setter = methodInfo.method;
}
} else {
// check the other methods without annotations
if (fieldInfo.getter == null) {
if (methodInfo.method.getName().startsWith("get")) {
String valueName = methodInfo.method.getName()
.substring(3);
if (fieldNameEquals(fieldInfo.fieldName, valueName)) {
fieldInfo.getter = methodInfo.method;
}
}
}
if (fieldInfo.setter == null) {
if (methodInfo.method.getName().startsWith("set")) {
String valueName = methodInfo.method.getName()
.substring(3);
if (fieldNameEquals(fieldInfo.fieldName, valueName)) {
fieldInfo.setter = methodInfo.method;
}
}
}
}
}
if (fieldInfo.getter == null) {
System.out.println("Field: " + fieldInfo.fieldName
+ " is missing a getter.");
}
if (fieldInfo.setter == null) {
System.out.print("Field:" + fieldInfo.fieldName
+ " is missing a setter.");
}
}
int variableNameCnt = 0;
public class FieldInfo {
Class type;
Field field;
Type[] parametrizedTypeArguments;
JsonProperty jsonProperty;
JsonInclude jsonInclude;
JsonSubTypes jsonSubTypes;
String fieldName;
String jsonFieldName;
String parentClassName;
String annotationName;
String required;
String defaultValue;
Method setter;
Method getter;
String instanceCreator;
public String toString() {
return "field:" + fieldName + "\n" + "parentClass: "
+ parentClassName + "\n" + "type: " + type + "\n"
+ "instanceCreator: " + instanceCreator + "\n" + "getter: "
+ getter + " setter: " + setter + "\n";
}
String createVariableName(String v) {
return v + variableNameCnt++;
}
String getMarshallCode(String context) throws Exception {
String s = "";
boolean canSkipIfNull = type.isPrimitive()
|| (jsonInclude != null && jsonInclude.value().equals(
JsonInclude.Include.NON_NULL));
if (type.isArray()) {
Type signatureType = field.getGenericType();
if ("int[]".equals(getTypeName(signatureType))) {
// int[];
String v = createVariableName("v");
s += "int[] " + v + " = " + context + "."
+ getter.getName() + "();\n";
if (!canSkipIfNull) {
s += "if(" + v + "==null) {\n";
s += " throw new RuntimeException(\"Field "
+ fieldName + " of class " + parentClassName
+ " cannot be null.\");\n";
s += "} else if(" + v + ".length!=0) {\n";
} else {
s += "if(" + v + "!=null) {\n";
}
s += " writer.writeStartArray(\"" + jsonFieldName
+ "\");\n";
s += " for(int i=0;i<" + v + ".length;i++) {\n";
s += " writer.writeInt32(" + v + "[i]);\n";
s += " }\n";
s += " writer.writeEndArray();\n";
s += "}\n";
} else if ("boolean[]".equals(getTypeName(signatureType))) {
// boolean[]
String v = createVariableName("v");
s += "boolean[] " + v + " = " + context + "."
+ getter.getName() + "();\n";
if (!canSkipIfNull) {
s += "if(" + v + "==null) {\n";
s += " throw new RuntimeException(\"Field "
+ fieldName + " of class " + parentClassName
+ " cannot be null.\");\n";
s += "} else if(" + v + ".length!=0) {\n";
} else {
s += "if(" + v + "!=null) {\n";
}
s += " writer.writeStartArray(\"" + jsonFieldName
+ "\");\n";
s += " for(int i=0;i<" + v + ".length;i++) {\n";
s += " writer.writeBoolean(" + v + "[i]);\n";
s += " }\n";
s += " writer.writeEndArray();\n";
s += "}\n";
} else if ("java.lang.String[]".equals(getTypeName(signatureType))) {
// String[]
String v = createVariableName("v");
s += "String[] " + v + " = " + context + "."
+ getter.getName() + "();\n";
if (!canSkipIfNull) {
s += "if(" + v + "==null) {\n";
s += " throw new RuntimeException(\"Field "
+ fieldName + " of class " + parentClassName
+ " cannot be null.\");\n";
s += "} else {\n";
} else {
s += "if(" + v + "!=null) {\n";
}
s += " writer.writeStartArray(\"" + jsonFieldName
+ "\");\n";
s += " for(int i=0;i<" + v + ".length;i++) {\n";
s += " writer.writeString(" + v + "[i]);\n";
s += " }\n";
s += " writer.writeEndArray();\n";
s += "}\n";
} else if ("byte[]".equals(getTypeName(signatureType))) {
// byte[]
String v = createVariableName("v");
s += "byte[] " + v + " = " + context + "."
+ getter.getName() + "();\n";
if (!canSkipIfNull) {
s += "if(" + v + "==null) {\n";
s += " throw new RuntimeException(\"Field "
+ fieldName + " of class " + parentClassName
+ " cannot be null.\");\n";
s += "} else {\n";
} else {
s += "if(" + v + "!=null) {\n";
}
s += " "
+ writeBinaryData("BsonBinarySubType.BINARY",
jsonFieldName, v);
s += " }\n";
} else if ("char[]".equals(getTypeName(signatureType))) {
// char[]
String v = createVariableName("v");
s += "char[] " + v + " = " + context + "."
+ getter.getName() + "();\n";
if (!canSkipIfNull) {
s += "if(" + v + "==null) {\n";
s += " throw new RuntimeException(\"Field "
+ fieldName + " of class " + parentClassName
+ " cannot be null.\");\n";
s += "} else {\n";
} else {
s += "if(" + v + "!=null) {\n";
}
String sv = createVariableName("s");
s += " String " + sv + " = String.valueOf(" + v + ");\n";
s += " writer.writeString(" + sv + ");\n";
s += "}\n";
} else if ("short[]".equals(getTypeName(signatureType))) {
// short[]
String v = createVariableName("v");
s += "short[] " + v + " = " + context + "."
+ getter.getName() + "();\n";
if (!canSkipIfNull) {
s += "if(" + v + "==null) {\n";
s += " throw new RuntimeException(\"Field "
+ fieldName + " of class " + parentClassName
+ " cannot be null.\");\n";
s += "} else {\n";
} else {
s += "if(" + v + "!=null) {\n";
}
s += " writer.writeStartArray(\"" + jsonFieldName
+ "\");\n";
s += " for(int i=0;i<" + v + ".length;i++) {\n";
s += " writer.writeInt32(" + v + "[i]);\n";
s += " }\n";
s += " writer.writeEndArray();\n";
s += "}\n";
} else if ("long[]".equals(getTypeName(signatureType))) {
// long[]
String v = createVariableName("v");
s += "long[] " + v + " = " + context + "."
+ getter.getName() + "();\n";
if (!canSkipIfNull) {
s += "if(" + v + "==null) {\n";
s += " throw new RuntimeException(\"Field "
+ fieldName + " of class " + parentClassName
+ " cannot be null.\");\n";
s += "} else {\n";
} else {
s += "if(" + v + "!=null) {\n";
}
s += " writer.writeStartArray(\"" + jsonFieldName
+ "\");\n";
s += " for(int i=0;i<" + v + ".length;i++) {\n";
s += " writer.writeInt64(" + v + "[i]);\n";
s += " }\n";
s += " writer.writeEndArray();\n";
s += "}\n";
} else if ("float[]".equals(getTypeName(signatureType))) {
// float[]
String v = createVariableName("v");
s += "float[] " + v + " = " + context + "."
+ getter.getName() + "();\n";
if (!canSkipIfNull) {
s += "if(" + v + "==null) {\n";
s += " throw new RuntimeException(\"Field "
+ fieldName + " of class " + parentClassName
+ " cannot be null.\");\n";
s += "} else {\n";
} else {
s += "if(" + v + "!=null) {\n";
}
s += " writer.writeStartArray(\"" + jsonFieldName
+ "\");\n";
s += " for(int i=0;i<" + v + ".length;i++) {\n";
s += " writer.writeDouble(" + v + "[i]);\n";
s += " }\n";
s += " writer.writeEndArray();\n";
s += "}\n";
} else if ("double[]".equals(getTypeName(signatureType))) {
// double[]
String v = createVariableName("v");
s += "double[] " + v + " = " + context + "."
+ getter.getName() + "();\n";
if (!canSkipIfNull) {
s += "if(" + v + "==null) {\n";
s += " throw new RuntimeException(\"Field "
+ fieldName + " of class " + parentClassName
+ " cannot be null.\");\n";
s += "} else {\n";
} else {
s += "if(" + v + "!=null) {\n";
}
s += " writer.writeStartArray(\"" + jsonFieldName
+ "\");\n";
s += " for(int i=0;i<" + v + ".length;i++) {\n";
s += " writer.writeDouble(" + v + "[i]);\n";
s += " }\n";
s += " writer.writeEndArray();\n";
s += "}\n";
} else {
// complex array
String v = createVariableName("v");
s += getTypeName(getter.getReturnType()) + " " + v + " = "
+ context + "." + getter.getName() + "();\n";
if (!canSkipIfNull) {
s += "if(" + v + "==null) {\n";
s += " throw new RuntimeException(\"Field "
+ fieldName + " of class " + parentClassName
+ " cannot be null.\");\n";
s += "} else {\n";
} else {
s += "if(" + v + "!=null) {\n";
}
s += " writer.writeStartArray(\"" + jsonFieldName
+ "\");\n";
String element = getElement(getTypeName(getter.getReturnType()));
Boolean hasSubTypes = hasSubTypesMap.get(Class.forName(element)) != null;
if (hasSubTypes == null) {
hasSubTypes = false;
}
if (!hasSubTypes) {
s += " Marshaller marshaller = registry.lookupMarshaller(" + v + "[0]);\n";
}
s += " for(int i=0;i<" + v + ".length;i++) {\n";
if (hasSubTypes) {
s += " Marshaller marshaller = registry.lookupMarshaller(" + v + "[i]);\n";
}
s += " marshaller.write(writer, " + v + "[i]);\n";
s += " }\n";
s += " writer.writeEndArray();\n";
s += "}\n";
}
} else if (isPrimitive(type)) {
String v = createVariableName("v");
s += field.getType().getName() + " " + v + "=" + context
+ "." + getter.getName() + "();\n";
boolean close = false;
if (!canSkipIfNull) {
close = true;
s += "if(" + v + "==null) {\n";
s += " throw new RuntimeException(\"Field " + fieldName
+ " of class " + parentClassName
+ " cannot be null.\");\n";
s += "} else {\n";
} else {
if (!type.isPrimitive()) {
close = true;
s += "if(" + v + "!=null) {\n";
}
}
s += writeName(jsonFieldName);
s += getPrimitiveWriter(type, v);
if (close) {
s += "}\n";
}
} else if (parametrizedTypeArguments != null) {
// List, Map, or something
if (isAMap(type)) {
String v = createVariableName("v");
String v2 = createVariableName("x");
String keyWriterString = getPrimitiveWriter((Class) parametrizedTypeArguments[0], v2);
if (keyWriterString == null) {
keyWriterString = "Marshaller kmarshaller = registry.lookupMarshaller("
+ v2 + ");\n";
keyWriterString += "kmarshaller.write(writer, " + v2
+ ");\n";
}
String u2 = createVariableName("z");
String valueWriterString = getPrimitiveWriter((Class) parametrizedTypeArguments[1], u2);
if (valueWriterString == null) {
valueWriterString = "Marshaller vmarshaller = registry.lookupMarshaller("
+ u2 + ");\n";
valueWriterString += " vmarshaller.write(writer, " + u2
+ ");\n";
}
s += "Map<" + getTypeName(parametrizedTypeArguments[0]) + "," +
getTypeName(parametrizedTypeArguments[1])
+ "> " + v + "=" + context + "." + getter.getName()
+ "();\n";
if (!canSkipIfNull) {
s += "if(" + v + "==null) {\n";
s += "throw new RuntimeException(\"Field "
+ fieldName + " of calss " + parentClassName
+ " cannot be null.\");\n";
s += "} else {\n";
} else {
s += "if(" + v + "!=null) {\n";
}
s += " writer.writeStartArray(\"" + jsonFieldName
+ "\");\n";
s += " for(" + getTypeName(parametrizedTypeArguments[0]) + " " + v2 + ":"
+ v + ".keySet()) {\n";
s += " " + getTypeName(parametrizedTypeArguments[1]) + " " + u2 + "=" + v + ".get(" + v2 + ");\n";
s += " " + keyWriterString;
s += " " + valueWriterString;
s += " }\n";
s += " writer.writeEndArray();\n";
s += "}\n";
} else if (isAList(type)) {
String v = createVariableName("v");
String v2 = createVariableName("x");
String writerString = getPrimitiveWriter(
(Class) parametrizedTypeArguments[0], v2);
if (writerString == null) {
writerString = "Marshaller marshaller = registry.lookupMarshaller("
+ v2 + ");\n";
writerString += "marshaller.write(writer, " + v2
+ ");\n";
}
s += "List<" + getTypeName(parametrizedTypeArguments[0])
+ "> " + v + "=" + context + "." + getter.getName()
+ "();\n";
if (!canSkipIfNull) {
s += "if(" + v + "==null) {\n";
s += " throw new RuntimeException(\"Field "
+ fieldName + " of class " + parentClassName
+ " cannot be null.\");\n";
s += "} else {\n";
} else {
s += "if(" + v + "!=null) {\n";
}
String b = createVariableName("b");
String c = createVariableName("c");
if (parametrizedTypeArguments[0] == Byte.class) {
s += "byte[] " + v2 + " = new byte[" + v
+ ".size()];\n";
s += "int " + c + " = 0;\n";
s += "for(Byte " + b + " : " + v + ") {\n";
s += " " + v2 + "[" + c + "++] = " + b + ";\n";
s += "}\n";
s += writeBinaryData("BsonBinarySubType.BINARY",
jsonFieldName, v2);
} else {
s += " writer.writeStartArray(\"" + jsonFieldName
+ "\");\n";
s += " for("
+ getTypeName(parametrizedTypeArguments[0])
+ " " + v2 + " : " + v + ") {\n";
s += " " + writerString;
s += " }\n";
s += " writer.writeEndArray();\n";
}
s += "}\n";
}
} else {
// complex type
String v = createVariableName("v");
s += field.getType().getName() + " " + v + "=" + context
+ "." + getter.getName() + "();\n";
if (!canSkipIfNull) {
s += "if(" + v + "==null) {\n";
s += " throw new RuntimeException(\"Field " + fieldName
+ " of class " + parentClassName
+ " cannot be null.\");\n";
s += "} else {\n";
} else {
s += "if(" + v + "!=null) {\n";
}
s += "writer.writeName(\"" + jsonFieldName + "\");\n";
s += "Marshaller marshaller = registry.lookupMarshaller("
+ v + ");\n";
s += "marshaller.write(writer, " + v + ");\n";
s += "}\n";
}
return s;
}
CodeBlock getUnmarshallerCode(String context) throws Exception {
String s = "";
String v = "";
if (type.isArray()) {
Type signatureType = field.getGenericType();
if ("int[]".equals(getTypeName(signatureType))) {
// int[];
s += "reader.readStartArray();\n";
v = createVariableName("v");
String x = createVariableName("x");
s += "List " + v + " = new ArrayList<>();\n";
s += "while(reader.readBsonType() != BsonType.END_OF_DOCUMENT) {\n";
s += " " + v + ".add(reader.readInt32());\n";
s += "}\n";
s += "int[] " + x + " = new int[" + v + ".size()];\n";
s += "int cnt=0;\n";
s += "for(Integer i:" + v + ") {\n";
s += " " + x + "[cnt++]=i;\n";
s += "}\n";
if (context != null) {
s += context + "." + setter.getName() + "(" + x
+ ");\n";
}
v = x;
s += "reader.readEndArray();\n";
} else if ("java.lang.String[]".equals(getTypeName(signatureType))) {
// String[]
s += "reader.readStartArray();\n";
v = createVariableName("v");
String x = createVariableName("x");
s += "List " + v + " = new ArrayList<>();\n";
s += "while(reader.readBsonType() != BsonType.END_OF_DOCUMENT) {\n";
s += " " + v + ".add(reader.readString());\n";
s += "}\n";
s += "String[] " + x + " = new String[" + v
+ ".size()];\n";
s += "int cnt=0;\n";
s += "for(String i:" + v + ") {\n";
s += " " + x + "[cnt++]=i;\n";
s += "}\n";
if (context != null) {
s += context + "." + setter.getName() + "(" + x
+ ");\n";
}
v = x;
s += "reader.readEndArray();\n";
} else if ("boolean[]".equals(getTypeName(signatureType))) {
// boolean[]
s += "reader.readStartArray();\n";
v = createVariableName("v");
String x = createVariableName("x");
s += "List " + v + " = new ArrayList<>();\n";
s += "while(reader.readBsonType() != BsonType.END_OF_DOCUMENT) {\n";
s += " " + v + ".add(reader.readBoolean());\n";
s += "}\n";
s += "boolean[] " + x + " = new boolean[" + v
+ ".size()];\n";
s += "int cnt=0;\n";
s += "for(Boolean i:" + v + ") {\n";
s += " " + x + "[cnt++]=i;\n";
s += "}\n";
if (context != null) {
s += context + "." + setter.getName() + "(" + x
+ ");\n";
}
v = x;
s += "reader.readEndArray();\n";
} else if ("byte[]".equals(getTypeName(signatureType))) {
// byte[]
v = createVariableName("v");
s += "BsonBinary binary = reader.readBinaryData();\n";
if (context != null) {
s += context + "." + setter.getName()
+ "(binary.getData());\n";
}
} else if ("char[]".equals(getTypeName(signatureType))) {
// char[]
v = createVariableName("v");
String x = createVariableName("s");
s += "String " + x + " = reader.readString();\n";
s += "char[] " + v + " = " + x + ".toCharArray();\n";
if (context != null) {
s += context + "." + setter.getName() + "(" + v
+ ");\n";
}
} else if ("short[]".equals(getTypeName(signatureType))) {
// short[]
s += "reader.readStartArray();\n";
v = createVariableName("v");
String x = createVariableName("x");
s += "List " + v + " = new ArrayList<>();\n";
s += "while(reader.readBsonType() != BsonType.END_OF_DOCUMENT) {\n";
s += " if(reader.getCurrentBsonType()!=BsonType.INT32) break;\n";
s += " " + v + ".add(reader.readInt32());\n";
s += "}\n";
s += "short[] " + x + " = new short[" + v + ".size()];\n";
s += "int cnt=0;\n";
s += "for(Integer i:" + v + ") {\n";
s += " " + x + "[cnt++]=i.shortValue();\n";
s += "}\n";
if (context != null) {
s += context + "." + setter.getName() + "(" + x
+ ");\n";
}
v = x;
s += "reader.readEndArray();\n";
} else if ("long[]".equals(getTypeName(signatureType))) {
// long[]
s += "reader.readStartArray();\n";
v = createVariableName("v");
String x = createVariableName("x");
s += "List " + v + " = new ArrayList<>();\n";
s += "while(reader.readBsonType() != BsonType.END_OF_DOCUMENT) {\n";
s += " if(reader.getCurrentBsonType()!=BsonType.INT64) break;\n";
s += " " + v + ".add(reader.readInt64());\n";
s += "}\n";
s += "long[] " + x + " = new long[" + v + ".size()];\n";
s += "int cnt=0;\n";
s += "for(Long i:" + v + ") {\n";
s += " " + x + "[cnt++]=i;\n";
s += "}\n";
if (context != null) {
s += context + "." + setter.getName() + "(" + x
+ ");\n";
}
v = x;
s += "reader.readEndArray();\n";
} else if ("float[]".equals(getTypeName(signatureType))) {
// float[]
s += "reader.readStartArray();\n";
v = createVariableName("v");
String x = createVariableName("x");
s += "List " + v + " = new ArrayList<>();\n";
s += "while(reader.readBsonType() != BsonType.END_OF_DOCUMENT) {\n";
s += " if(reader.getCurrentBsonType()!=BsonType.DOUBLE) break;\n";
s += " " + v + ".add(reader.readDouble());\n";
s += "}\n";
s += "float[] " + x + " = new float[" + v + ".size()];\n";
s += "int cnt=0;\n";
s += "for(Double i:" + v + ") {\n";
s += " " + x + "[cnt++]=i.floatValue();\n";
s += "}\n";
if (context != null) {
s += context + "." + setter.getName() + "(" + x
+ ");\n";
}
v = x;
s += "reader.readEndArray();\n";
} else if ("double[]".equals(getTypeName(signatureType))) {
// double[]
s += "reader.readStartArray();\n";
v = createVariableName("v");
String x = createVariableName("x");
s += "List " + v + " = new ArrayList<>();\n";
s += "while(reader.readBsonType() != BsonType.END_OF_DOCUMENT) {\n";
s += " if(reader.getCurrentBsonType()!=BsonType.DOUBLE) break;\n";
s += " " + v + ".add(reader.readDouble());\n";
s += "}\n";
s += "double[] " + x + " = new double[" + v + ".size()];\n";
s += "int cnt=0;\n";
s += "for(Double i:" + v + ") {\n";
s += " " + x + "[cnt++]=i;\n";
s += "}\n";
if (context != null) {
s += context + "." + setter.getName() + "(" + x
+ ");\n";
}
v = x;
s += "reader.readEndArray();\n";
} else {
// complex array
s += "reader.readStartArray();\n";
v = createVariableName("v");
String element = getElement(getTypeName(getter.getReturnType()));
SubTypeInfo sti = mapOfSubTypeInfo.get(Class.forName(element));
String marshallerType;
if (sti != null) {
marshallerType = getTypeName(sti.parentClass);
} else {
marshallerType = element;
}
String marshaller = createVariableName("m");
s += "Marshaller " + marshaller + " = registry.lookupMarshaller(" + marshallerType + ".class);\n";
s += "List<" + element + "> " + v
+ " = new ArrayList<>();\n";
s += "while(reader.readBsonType() != BsonType.END_OF_DOCUMENT) {\n";
s += element + " e = (" + element + ") " + marshaller + ".read(reader);\n";
s += v + ".add(e);\n";
s += "}\n";
String x = createVariableName("x");
s += element + "[] " + x + " = new " + element + "[" + v + ".size()];\n";
s += v + ".toArray(" + x + ");\n";
if (context != null) {
s += context + "." + setter.getName() + "(" + x + ");\n";
}
s += "reader.readEndArray();\n";
v = x;
}
} else if (isPrimitive(type)) {
v = createVariableName("v");
s += field.getType().getName() + " "
+ getPrimitiveReader(type, v);
if (context != null) {
s += context + "." + setter.getName() + "(" + v + ");\n";
}
} else if (parametrizedTypeArguments != null) {
if (isAMap(type)) {
v = createVariableName("mv");
String keyV = createVariableName("v");
String valueV = createVariableName("x");
String keyReaderString = getPrimitiveReader((Class) parametrizedTypeArguments[0], keyV);
String valueReaderString = getPrimitiveReader((Class) parametrizedTypeArguments[1], valueV);
s += "reader.readStartArray();\n";
String keyElement = getTypeName(parametrizedTypeArguments[0]);
SubTypeInfo sti = mapOfSubTypeInfo.get(Class.forName(keyElement));
String keyMarshallerType;
if (sti != null) {
keyMarshallerType = getTypeName(sti.parentClass);
} else {
keyMarshallerType = keyElement;
}
String valueElement = getTypeName(parametrizedTypeArguments[1]);
SubTypeInfo sti2 = mapOfSubTypeInfo.get(Class.forName(valueElement));
String valueMarshallerType;
if (sti2 != null) {
valueMarshallerType = getTypeName(sti2.parentClass);
} else {
valueMarshallerType = valueElement;
}
if (keyReaderString != null) {
keyReaderString = keyElement + " " + keyReaderString;
} else {
s += "Marshaller m = registry.lookupMarshaller(" + keyMarshallerType + ".class);\n";
keyReaderString = keyElement + " " + keyV + " = (" + keyElement + ") m.read(reader);\n";
}
if (valueReaderString != null) {
valueReaderString = valueElement + " " + valueReaderString;
} else {
s += "Marshaller m2 = registry.lookupMarshaller(" + valueMarshallerType + ".class);\n";
valueReaderString = valueElement + " " + valueV + " = (" + valueElement + ") m2.read(reader);\n";
}
s += "Map<" + keyElement + "," + valueElement + "> " + v + "=new HashMap<>();\n";
s += "while(reader.readBsonType() != BsonType.END_OF_DOCUMENT) {\n";
s += keyReaderString;
s += valueReaderString;
s += v + ".put(" + keyV + "," + valueV + ");\n";
s += "}\n";
if (context != null) {
s += context + "." + setter.getName() + "(" + v
+ ");\n";
}
s += "reader.readEndArray();\n";
} else if (isAList(type)) {
if (parametrizedTypeArguments[0] == Byte.class) {
// byte[]
v = createVariableName("v");
String b = createVariableName("b");
String b2 = createVariableName("x");
s += "BsonBinary binary = reader.readBinaryData();\n";
s += "List " + v + " = new ArrayList<>();\n";
s += "byte[] " + b + " = binary.getData();\n";
s += "for(byte " + b2 + " : " + b + ") {\n";
s += " " + v + ".add(" + b2 + ");\n";
s += "}\n";
if (context != null) {
s += context + "." + setter.getName() + "(" + v
+ ");\n";
}
} else {
s += "reader.readStartArray();\n";
v = createVariableName("v");
String readerString = getPrimitiveReader(
(Class) parametrizedTypeArguments[0], "e");
String element = getTypeName(parametrizedTypeArguments[0]);
SubTypeInfo sti = mapOfSubTypeInfo.get(Class.forName(element));
String marshallerType;
if (sti != null) {
marshallerType = getTypeName(sti.parentClass);
} else {
marshallerType = element;
}
if (readerString != null) {
readerString = element + " " + readerString;
} else {
s += "Marshaller m = registry.lookupMarshaller(" + marshallerType + ".class);\n";
readerString = element + " e = (" + element + ") m.read(reader);\n";
}
s += "List<" + element + "> " + v + "=new ArrayList<>();\n";
s += "while(reader.readBsonType() != BsonType.END_OF_DOCUMENT) {\n";
s += readerString;
s += v + ".add(e);\n";
s += "}\n";
if (context != null) {
s += context + "." + setter.getName() + "(" + v
+ ");\n";
}
s += "reader.readEndArray();\n";
}
}
} else {
v = createVariableName("v");
String m = "registry.lookupMarshaller("
+ field.getType().getName()
+ ".class).read(reader);\n";
s += field.getType().getName() + " " + v + "= ("
+ field.getType().getName() + ") " + m;
if (context != null) {
s += context + "." + setter.getName() + "(" + v + ");\n";
}
}
CodeBlock codeBlock = new CodeBlock();
codeBlock.s = s;
codeBlock.v = v;
return codeBlock;
}
String getElement(String array) {
return array.replace("[]", "");
}
}
class CodeBlock {
String s;
String v;
}
boolean isPrimitive(Class clazz) {
return ClassUtils.isPrimitiveOrWrapper(clazz)
|| clazz.equals(String.class);
}
String getPrimitiveWriter(Class clazz, String v) {
if (clazz.equals(String.class)) {
return writeString(v);
} else if (clazz.equals(Long.class) || clazz.equals(long.class)) {
return writeInt64(v);
} else if (clazz.equals(Integer.class) || clazz.equals(int.class)) {
return writeInt32(v);
} else if (clazz.equals(Boolean.class) || clazz.equals(boolean.class)) {
return writeBoolean(v);
} else if (clazz.equals(Double.class) || clazz.equals(double.class)) {
return writeDouble(v);
} else if (clazz.equals(Float.class) || clazz.equals(float.class)) {
return writeFloat(v);
} else if (clazz.equals(Short.class) || clazz.equals(short.class)) {
return writeShort(v);
}
return null;
}
String getPrimitiveReader(Class clazz, String v) {
if (clazz.equals(String.class)) {
return readString(v);
} else if (clazz.equals(Long.class) || clazz.equals(long.class)) {
return readInt64(v);
} else if (clazz.equals(Integer.class) || clazz.equals(int.class)) {
return readInt32(v);
} else if (clazz.equals(Boolean.class) || clazz.equals(boolean.class)) {
return readBoolean(v);
} else if (clazz.equals(Double.class) || clazz.equals(double.class)) {
return readDouble(v);
} else if (clazz.equals(Float.class) || clazz.equals(float.class)) {
return readFloat(v);
} else if (clazz.equals(Short.class) || clazz.equals(short.class)) {
return readShort(v);
}
return null;
}
boolean isAList(Class type) {
List> interfaces = ClassUtils.getAllInterfaces(type);
if (type.isInterface()) {
interfaces.add(type);
}
return interfaces.contains(List.class);
}
boolean isAMap(Class type) {
List> interfaces = ClassUtils.getAllInterfaces(type);
if (type.isInterface()) {
interfaces.add(type);
}
return interfaces.contains(Map.class);
}
class MethodInfo {
Method method;
JsonProperty jsonProperty;
}
boolean fieldNameEquals(String fieldName, String value) {
fieldName = fieldName.replaceAll("[^A-Za-z0-9]", "");
value = value.replaceAll("[^A-Za-z0-9]", "");
return fieldName.equalsIgnoreCase(value);
}
String writeBinaryData(String type, String value) {
String a = "BsonBinary binary = new BsonBinary(" + type + "," + value
+ ");\n";
String b = "writer.writeBinaryData(binary);\n";
return a + b;
}
String writeBinaryData(String type, String name, String value) {
String a = "BsonBinary binary = new BsonBinary(" + type + "," + value
+ ");\n";
String b = "writer.writeBinaryData(\"" + name + "\",binary);\n";
return a + b;
}
String writeBoolean(String value) {
return "writer.writeBoolean(" + value + ");\n";
}
String writeBoolean(String name, String value) {
return "writer.writeBoolean(\"" + name + "\"," + value + ");\n";
}
String writeDateTime(String value) {
return "writer.writeDateTime(" + value + ");\n";
}
String writeDateTime(String name, String value) {
return "writer.writeDateTime(\"" + name + "\"," + value + ");\n";
}
String writeEndArray() {
return "writer.writeEndArray();\n";
}
String writeEndDocument() {
return "writer.writeEndDocument();\n";
}
String writeInt32(String value) {
return "writer.writeInt32(" + value + ");\n";
}
String writeInt32(String name, String value) {
return "writer.writeInt32(\"" + name + "\"," + value + ");\n";
}
String writeInt64(String value) {
return "writer.writeInt64(" + value + ");\n";
}
String writeInt64(String name, String value) {
return "writer.writeInt64(\"" + name + "\"," + value + ");\n";
}
String writeDouble(String value) {
return "writer.writeDouble(" + value + ");\n";
}
String writeDouble(String name, String value) {
return "writer.writeDouble(\"" + name + "\"," + value + ");\n";
}
String writeFloat(String value) {
return "writer.writeDouble(" + value + ");\n";
}
String writeShort(String value) {
return "writer.writeInt32(" + value + ");\n;";
}
String writeName(String name) {
return "writer.writeName(\"" + name + "\");\n";
}
String writeStartArray() {
return "writer.writeStartArray();\n";
}
String writeStartArray(String name) {
return "writer.writeStartArray(\"" + name + "\");\n";
}
String writeStartDocument() {
return "writer.writeStartDocument();\n";
}
String writeStartDocument(String name) {
return "writer.writeStartDocument(\"" + name + "\");\n";
}
String writeString(String value) {
return "writer.writeString(" + value + ");\n";
}
String writeString(String name, String value) {
return "writer.writeString(\"" + name + "\"," + value + ");\n";
}
String readBinaryData(String v) {
return v + "=reader.readBinaryData();\n";
}
String readBoolean(String v) {
return v + "=reader.readBoolean();\n";
}
String readDateTime(String v) {
return v + "=reader.readDateTime();\n";
}
String readInt32(String v) {
return v + "=reader.readInt32();\n";
}
String readInt64(String v) {
return v + "=reader.readInt64();\n";
}
String readDouble(String v) {
return v + "=reader.readDouble();\n";
}
String readFloat(String v) {
return v + "=(float) reader.readDouble();\n";
}
String readShort(String v) {
return v + "=(short) reader.readInt32();\n";
}
String readString(String v) {
return v + "=reader.readString();\n";
}
/**
* Copied from java 1.8 impl for 1.7 compatibility
*
* @param t
* @return type name
*/
String getTypeName(Type t) {
Class type = (Class) t;
if (type.isArray()) {
try {
Class cl = type;
int dimensions = 0;
while (cl.isArray()) {
dimensions++;
cl = cl.getComponentType();
}
StringBuilder sb = new StringBuilder();
sb.append(cl.getName());
for (int i = 0; i < dimensions; i++) {
sb.append("[]");
}
return sb.toString();
} catch (Throwable e) { /*FALLTHRU*/ }
}
return type.getName();
}
private static final Class[] parameters = new Class[]{URL.class};
static void addURLToClasspath(URL url) throws Exception {
URLClassLoader sysLoader = (URLClassLoader) ClassLoader.getSystemClassLoader();
Class sysClass = URLClassLoader.class;
Method method = sysClass.getDeclaredMethod("addURL", parameters);
method.setAccessible(true);
method.invoke(sysLoader, new Object[]{url});
}
public static void main(String... argv) throws Exception {
String od = System.getProperty("output.dir");
String classes = System.getProperty("class.names");
String jarFiles = System.getProperty("jar.files", "false");
if (!jarFiles.equals("false")) {
StringTokenizer jarFilenames = new StringTokenizer(jarFiles);
while (jarFilenames.hasMoreElements()) {
addURLToClasspath(new File(jarFilenames.nextToken()).toURI().toURL());
}
}
StringTokenizer stringTokenizer = new StringTokenizer(classes, ",");
MarshallerGenerator.outputPath = od;
Map classesForFactory = new HashMap<>();
while (stringTokenizer.hasMoreElements()) {
String classname = stringTokenizer.nextToken();
Class clazz = Class.forName(classname);
Package p = clazz.getPackage();
String beanPackage = p.getName();
MarshallerGenerator generator = new MarshallerGenerator();
generator.beanPackage = beanPackage;
generator.factoryName = clazz.getSimpleName();
List fieldInfos = new ArrayList<>();
generator.getFieldInfosForClasses(clazz, fieldInfos);
for (Class clazz2 : generator.mapOfFieldInfos.keySet()) {
List fis = generator.mapOfFieldInfos
.get(clazz2);
if (generator.buildMarshaller(clazz2, fis)) {
classesForFactory.put(clazz2, clazz2);
}
}
for (Class clazz2 : generator.mapOfSubTypeInfo.keySet()) {
generator.getFieldInfosForClasses(clazz2, new ArrayList());
}
for (Class clazz2 : generator.mapOfSubTypeInfo.keySet()) {
List fis = generator.mapOfFieldInfos
.get(clazz2);
if (generator.buildMarshaller(clazz2, fis)) {
classesForFactory.put(clazz2, clazz2);
}
}
for (Class clazz2 : generator.mapOfFieldInfos.keySet()) {
List fis = generator.mapOfFieldInfos.get(clazz2);
if (generator.buildMarshaller(clazz2, fis)) {
classesForFactory.put(clazz2, clazz2);
}
}
generator.buildCodec(clazz);
List classListForFactory = new ArrayList<>();
for (Class key : classesForFactory.keySet()) {
classListForFactory.add(key);
}
generator.buildMarshallerFactory(classListForFactory);
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy