@Test
public void parameters_as_return() throws IOException {
JClass c = new JClass("test", "MyClass");
c.addMethod("getValue", new JClass("test.api", "Model").addParameter(String.class))
.addContent("return null;");
assertJClass(c, "/jclass/ParametersAsReturn.java", "parameters_as_return");
}
@Test
public void referenceName_two_parameters() {
JClass c =
new JClass("test", "MyClass")
.addParameter(new JClass("test.api", "Model"))
.addParameter(String.class);
assertEquals("MyClass<Model,String>", c.getReferenceName());
}
@Test
public void parameters_as_param() throws IOException {
JClass c = new JClass("test", "MyClass");
c.addMethod("setValue")
.addParam(new JClass("test.api", "Model").addParameter(String.class), "value")
.addContent("// Nothing");
assertJClass(c, "/jclass/ParametersAsParam.java", "parameters_as_param");
}
/** Returns true if equals. */
public boolean equals(Object o) {
if (o == this) return true;
else if (o == null || getClass() != o.getClass()) return false;
JClass jClass = (JClass) o;
// note that the equality test doesn't include the class loader
return getName().equals(jClass.getName());
}
/** Primitive type as an import */
@Test
public void primitive_as_import() throws IOException {
JClass intClass = new JClass(Integer.TYPE);
JClass hostClass = new JClass("test", "Test");
hostClass.addImport(intClass);
Set<String> imports = hostClass.getImportNames();
assertNotNull(imports);
assertTrue(imports.isEmpty());
}
/** Removes a class from this package. */
public void remove(JClass c) {
if (c._package() != this)
throw new IllegalArgumentException(
"the specified class is not a member of this package," + " or it is a referenced class");
// note that c may not be a member of classes.
// this happens when someone is trying to remove a non generated class
classes.remove(c.name());
if (upperCaseClassMap != null) upperCaseClassMap.remove(c.name().toUpperCase());
}
protected String jToSql(String javaName, JClass currentClass)
throws IOException, SchemaException {
JField jf = currentClass.getFieldByName(javaName);
if (jf == null)
throw new SchemaException(
"field " + javaName + " not a member of class " + currentClass.getClassName(),
currentClass.getSchemaFileName());
return jf.getSqlName();
}
/**
* Tests that spacing is correct.
*
* @throws IOException
*/
@Test
public void spacing() throws IOException {
// Class structure
JClass c = new JClass("sido.test", "Test");
c.addImport(List.class);
c.addImport(ArrayList.class);
c.addField("String", "name");
c.addField("List<String>", "otherNames").setInitialisation("new ArrayList<String>()");
c.addConstructor();
c.addConstructor().addParam("String", "value").addContent("this.name = value;");
c.addMethod("getName", "String").addContent("return name;");
c.addMethod("setName").addParam("String", "value").addContent("this.name = value;");
// Output
StringWriter s = new StringWriter();
PrintWriter writer = new PrintWriter(s);
// Generation
c.write(writer);
// Output
List<String> actual = readLines(s.toString());
// Gets the expected content
List<String> expected = readReference("/jclass/Spacing.java");
// Difference between the two sets
Patch diff = DiffUtils.diff(expected, actual);
List<Delta> deltas = diff.getDeltas();
if (!deltas.isEmpty()) {
// Creates the diff
String original = StringUtils.join(expected, "\n");
String revised = StringUtils.join(actual, "\n");
List<String> unifiedDiff =
DiffUtils.generateUnifiedDiff(original, revised, expected, diff, 3);
String diffDisplay = StringUtils.join(unifiedDiff, "\n");
System.err.println(diffDisplay);
fail("spacing");
}
}
private JInvocation buildScopeKey(InjectionNode injectionNode) {
InjectionSignature signature = injectionNode.getTypeSignature();
JClass injectionNodeClassRef = generationUtil.ref(injectionNode.getASTType());
return codeModel
.ref(ScopeKey.class)
.staticInvoke(ScopeKey.GET_METHOD)
.arg(injectionNodeClassRef.dotclass())
.arg(JExpr.lit(signature.buildScopeKeySignature()));
}
/* override to insert constraint in table definition */
protected void writeCheckConstraint(JClass currentClass, String cons_name, JField jf)
throws IOException {
constraints +=
"\nalter table "
+ currentClass.getTableName()
+ " add constraint "
+ cons_name
+ " check ("
+ jf.getSqlName()
+ jf.getConstraint()
+ ");\n";
cleanupConstraints +=
"\nalter table " + currentClass.getTableName() + " drop constraint " + cons_name + " ;\n";
}
public void assertJClass(JClass c, String referenceResourcePath, String testId)
throws IOException {
// Output
StringWriter s = new StringWriter();
PrintWriter writer = new PrintWriter(s);
// Generation
c.write(writer);
// Output
List<String> actual = readLines(s.toString());
// Gets the expected content
List<String> expected = readReference(referenceResourcePath);
// Difference between the two sets
Patch diff = DiffUtils.diff(expected, actual);
List<Delta> deltas = diff.getDeltas();
if (!deltas.isEmpty()) {
// Creates the diff
String original = StringUtils.join(expected, "\n");
String revised = StringUtils.join(actual, "\n");
List<String> unifiedDiff =
DiffUtils.generateUnifiedDiff(original, revised, expected, diff, 3);
String diffDisplay = StringUtils.join(unifiedDiff, "\n");
System.err.println(diffDisplay);
fail(testId);
}
}
protected JMethod(FJBGContext context,
JClass owner,
int accessFlags,
String name,
JType returnType,
JType[] argTypes,
String[] argNames) {
super(context,
owner,
accessFlags,
name,
new JMethodType(returnType, argTypes));
this.argNames = argNames;
assert argTypes.length == argNames.length;
if (isAbstract() || isNative()) {
code = null;
} else {
code = context.JCode(owner, this);
addAttribute(context.JCodeAttribute(owner, this));
if (!isStatic())
addNewLocalVariable(owner.getType(), "this");
for (int i = 0; i < argTypes.length; ++i)
addNewLocalVariable(argTypes[i], argNames[i]);
}
}
/**
* Adds the given JMethodSignature to this JClass
*
* @param jMethodSig the JMethodSignature to add.
* @throws java.lang.IllegalArgumentException when the given JMethodSignature conflicts with an
* existing method signature.
*/
public void addMethod(JMethodSignature jMethodSig) throws IllegalArgumentException {
if (jMethodSig == null) {
String err = "The JMethodSignature cannot be null.";
throw new IllegalArgumentException(err);
}
// -- check method name and signatures *add later*
// -- keep method list sorted for esthetics when printing
// -- START SORT :-)
boolean added = false;
// short modifierVal = 0;
JModifiers modifiers = jMethodSig.getModifiers();
for (int i = 0; i < methods.size(); i++) {
JMethodSignature tmp = (JMethodSignature) methods.elementAt(i);
// -- first compare modifiers
if (tmp.getModifiers().isProtected()) {
if (!modifiers.isProtected()) {
methods.insertElementAt(jMethodSig, i);
added = true;
break;
}
}
// -- compare names
if (jMethodSig.getName().compareTo(tmp.getName()) < 0) {
methods.insertElementAt(jMethodSig, i);
added = true;
break;
}
}
// -- END SORT
if (!added) methods.addElement(jMethodSig);
// -- check return type to make sure it's included in the
// -- import list
JType jType = jMethodSig.getReturnType();
if (jType != null) {
while (jType.isArray()) jType = jType.getComponentType();
if (!jType.isPrimitive()) addImport(jType.getName());
}
// -- check exceptions
JClass[] exceptions = jMethodSig.getExceptions();
for (JClass exception : exceptions) {
addImport(exception.getName());
}
} // -- addMethod
protected JClass createClass(GenerationContext generationContext, SidoType type) {
JClass c = JClassUtils.createClassRef(generationContext, type);
// Abstraction?
if (type.isAbstractType()) {
c.setAbstractClass(true);
}
// Subclass?
SidoType parentType = type.getParentType();
if (parentType != null) {
String parentTypeName = JClassUtils.getSimpleClassName(generationContext, parentType);
c.setParent(parentTypeName);
c.addImport(JClassUtils.createClassRef(generationContext, parentType));
}
// Constructors
generateConstructors(c, generationContext, type);
// OK
return c;
}
protected void writeForeignKey(
JClass currentClass, String cons_name, JField jf, JClass foreignClass) throws IOException {
constraints +=
"\nalter table "
+ currentClass.getTableName()
+ " add constraint "
+ cons_name
+ " foreign key ("
+ jf.getSqlName()
+ ") references "
+ foreignClass.getTableName()
+ "("
+ foreignClass.getPrimaryKey()
+ ");\n";
cleanupConstraints +=
"\nalter table " + currentClass.getTableName() + " drop constraint " + cons_name + " ;\n";
}
protected void addIndex(JClass currentClass, String sOut, JIndex index) {
constraints +=
"\ncreate index "
+ index.getName()
+ " on "
+ currentClass.getTableName()
+ " ("
+ sOut
+ ");\n";
}
private static void processToString(JDefinedClass packetClass, JCodeModel codeModel) {
JClass string = codeModel.ref(String.class);
JClass stringBuilder = codeModel.ref(StringBuilder.class);
JClass arrays = codeModel.ref(Arrays.class);
JMethod toStringMeth = packetClass.method(JMod.PUBLIC, String.class, "toString");
toStringMeth.annotate(Override.class);
JBlock body = toStringMeth.body();
JVar stringBuilderVar = body.decl(stringBuilder, "sb");
stringBuilderVar =
stringBuilderVar.init(JExpr._new(stringBuilder).arg(packetClass.name() + "["));
JInvocation appendChain = null;
for (JFieldVar fieldVar : packetClass.fields().values()) {
if (appendChain != null) {
// a comma is needed
appendChain = appendChain.invoke("append").arg("," + fieldVar.name() + "=");
} else {
appendChain = stringBuilderVar.invoke("append").arg(fieldVar.name() + "=");
}
// now add the field to the toString output
JExpression expression =
fieldVar.type().isArray()
? arrays.staticInvoke("toString").arg(JExpr._this().ref(fieldVar.name()))
: fieldVar.type().isReference()
? JExpr._this().ref(fieldVar.name()).invoke("toString")
: JExpr._this().ref(fieldVar.name());
appendChain = appendChain.invoke("append").arg(expression);
}
if (appendChain != null) {
appendChain = appendChain.invoke("append").arg("]");
} else {
appendChain = stringBuilderVar.invoke("append").arg("]");
}
body.add(appendChain);
body._return(stringBuilderVar.invoke("toString"));
}
/**
* Create a new dependency with a given digest.
*
* @param cl the source class
* @param digest the MD5 digest
*/
public JClassDependency(JClass cl, String digest) {
_className = cl.getName();
String newDigest = getDigest();
if (!newDigest.equals(digest)) {
if (log.isLoggable(Level.FINE)) log.fine(_className + " digest is modified.");
_isDigestModified = true;
}
}
public void inlineField(JClass currentClass, JCompositeField jcf, HashSet fieldNames)
throws IOException, SchemaException {
JClass fieldClass = jcf.getJClass();
Vector fields = new Vector(fieldClass.getAllFields().values());
String primaryKey = fieldClass.getPrimaryKey();
String prefix = jcf.getPrefix();
for (int i = 0; i < fields.size(); i++) {
JField jf = (JField) fields.elementAt(i);
String sqlName = jf.getSqlName();
if (!jf.isDbColumn() || sqlName.equals(primaryKey)) {
// do nothing ..
} else if (jf instanceof JCompositeField) {
throw new SchemaException(
"Composite Fields not allowed in inline objects", currentClass.getSchemaFileName());
} else
schemaFile.write(",\n\t" + prefix + "_" + sqlName + " " + getSqlOutType(currentClass, jf));
fieldNames.add(prefix + "_" + sqlName);
}
}
private Refs(JCodeModel m, String packageName, String layoutName, String superclass) {
this.m = m;
this.packageName = packageName;
this.layoutName = layoutName;
viewHolder = m.ref(superclass);
viewClass = m.ref("android.view.View");
androidRClass = m.ref("android.R");
rClass = m.ref(packageName + ".R");
nullableAnnotation = m.ref("android.support.annotation.Nullable");
overrideAnnotation = m.ref("java.lang.Override");
layoutRef = rClass.staticRef("layout").ref(layoutName);
}
protected void addConstraint(
JClass currentClass, String consName, JConstraint jcons, String sOut) {
constraints +=
"\nalter table "
+ currentClass.getTableName()
+ " add constraint "
+ consName
+ " "
+ jcons.getType()
+ " ("
+ sOut
+ ");\n";
}
protected String convertFields(String fields, JClass currentClass)
throws SchemaException, IOException {
Vector tokens = Tokenizer.tokenize(fields, ",", "/");
Debugger.trace(fields + " token-size=" + tokens.size(), Debugger.VERBOSE);
String sOut;
if (tokens == null || tokens.size() < 1)
throw new SchemaException(
"Invalid constraint specification ", currentClass.getSchemaFileName());
else sOut = jToSql((String) tokens.elementAt(0), currentClass);
for (int j = 1; j < tokens.size(); j++) {
sOut += "," + jToSql((String) tokens.elementAt(j), currentClass);
}
return sOut;
}
/**
* Parses '<T1,T2,...,Tn>'
*
* @return the index of the character next to '>'
*/
private JClass parseArguments(JClass rawType) throws ClassNotFoundException {
if (s.charAt(idx) != '<') throw new IllegalArgumentException();
idx++;
List<JClass> args = new ArrayList<JClass>();
while (true) {
args.add(parseTypeName());
if (idx == s.length()) throw new IllegalArgumentException("Missing '>' in " + s);
char ch = s.charAt(idx);
if (ch == '>') return rawType.narrow(args.toArray(new JClass[args.size()]));
if (ch != ',') throw new IllegalArgumentException(s);
idx++;
}
}
/** Parses additional left-associative suffixes, like type arguments and array specifiers. */
private JClass parseSuffix(JClass clazz) throws ClassNotFoundException {
if (idx == s.length()) return clazz; // hit EOL
char ch = s.charAt(idx);
if (ch == '<') return parseSuffix(parseArguments(clazz));
if (ch == '[') {
if (s.charAt(idx + 1) == ']') {
idx += 2;
return parseSuffix(clazz.array());
}
throw new IllegalArgumentException("Expected ']' but found " + s.substring(idx + 1));
}
return clazz;
}
private void checkJCompUnit() {
JCompUnit unit = new JCompUnit("com.acme", "JCompUnitTest.java");
JClass testClass = new JClass("Test");
testClass.addImport("java.util.Vector");
testClass.addMember(new JField(JType.INT, "x"));
JField field = null;
field = new JField(JType.INT, "_z");
field.getModifiers().setStatic(true);
testClass.addField(field);
testClass.getStaticInitializationCode().add("_z = 75;");
JClass jcString = new JClass("String");
field = new JField(jcString, "myString");
field.getModifiers().makePrivate();
testClass.addMember(field);
// -- create constructor
JConstructor cons = testClass.createConstructor();
testClass.addConstructor(cons);
cons.getSourceCode().add("this.x = 6;");
JMethod jMethod = new JMethod("getX", JType.INT, null);
jMethod.setSourceCode("return this.x;");
testClass.addMethod(jMethod);
unit.addClass(testClass);
JClass fooClass = new JClass("Foo");
unit.addClass(fooClass);
unit.print(getOutputDirectory().toString(), null);
assertTrue(new File(getOutputDirectory(), "com/acme/JCompUnitTest.java").exists());
}
public JAttribute newInstance(JClass clazz, Object owner, DataInputStream stream)
throws IOException {
String name = clazz.getConstantPool().lookupUtf8(stream.readShort());
Integer size = new Integer(stream.readInt());
Constructor constr = (Constructor) constructors.get(name);
if (constr == null) constr = defaultConstructor;
Object[] args = new Object[] {context, clazz, owner, name, size, stream};
try {
return (JAttribute) constr.newInstance(args);
} catch (InstantiationException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throw new RuntimeException(e);
}
}
/* write the schema line for one field*/
protected void writeFieldSchema(
JClass currentClass, JField jf, String primaryKey, boolean is_first)
throws IOException, SchemaException {
String sqlName = jf.getSqlName();
String fieldType = jf.getSqlType();
String sep = is_first ? "" : ",";
if (sqlName.equals(primaryKey)) {
schemaFile.write(sep);
writePrimaryKey(currentClass, sqlName);
} else {
schemaFile.write(sep + "\n\t" + sqlName + " " + getSqlOutType(currentClass, jf));
if (jf.isUnique()) writeUniqueConstraint(currentClass, jf);
if (jf.isRequired()) schemaFile.write(" not null");
else {
String dbSpecificOptions = getDbSpecificOptions(currentClass, jf, primaryKey);
if (dbSpecificOptions != null) schemaFile.write(" " + dbSpecificOptions);
}
}
if (jf instanceof JCompositeField
&& ((JCompositeField) jf).getJClass() != null
&& ((JCompositeField) jf).getJClass().isLeaf()) {
// is a foreign key and has a class to reference
JCompositeField jcf = ((JCompositeField) jf);
JClass foreignClass = jcf.getJClass();
String cons_name = jcf.getConstraintName();
if (!Checks.exists(cons_name)) {
cons_name = currentClass.getClassName() + jf.getJavaName();
if (cons_name.length() > 30) cons_name = cons_name.substring(cons_name.length() - 28);
}
cons_name = makeConstraintName(cons_name);
writeForeignKey(currentClass, cons_name, jf, foreignClass);
} else if (Checks.exists(jf.getConstraint())) {
String cons_name = jf.getConstraintName();
if (!Checks.exists(cons_name)) cons_name = "C_" + jf.getJavaName();
cons_name = makeConstraintName(cons_name);
writeCheckConstraint(currentClass, cons_name, jf);
}
}
/** Parameters in fields */
@Test
public void parameters_in_fields() throws IOException {
JClass c = new JClass("test", "MyClass");
c.addField(new JClass("test.api", "Model").addParameter(String.class), "model");
assertJClass(c, "/jclass/ParametersInFields.java", "parameters_in_fields");
}
@Test
public void referenceName_one_parameter() {
JClass c = new JClass("test", "MyClass").addParameter(new JClass("test.api", "Model"));
assertEquals("MyClass<Model>", c.getReferenceName());
}
@Test
public void referenceName_no_parameter() {
JClass c = new JClass("test", "MyClass");
assertEquals("MyClass", c.getReferenceName());
}
