@Override public MetaClass getType() { return MetaClassFactory.get(annotationClass); } };
@Override public FieldBuildName<T> typeOf(Class<?> type) { this.type = MetaClassFactory.get(type); return this; }
private void generateMethod(ClassStructureBuilder<?> classBuilder, MetaMethod method) { final List<Class<?>> interceptors = interceptorProvider.getInterceptors(remote, method); final boolean intercepted = !interceptors.isEmpty(); final Parameter[] parms = DefParameters.from(method).getParameters().toArray(new Parameter[0]); final Parameter[] finalParms = new Parameter[parms.length]; final List<Statement> parmVars = new ArrayList<Statement>(); for (int i = 0; i < parms.length; i++) { finalParms[i] = Parameter.of(parms[i].getType().getErased(), parms[i].getName(), true); parmVars.add(Stmt.loadVariable(parms[i].getName())); } final Statement parameters = (intercepted) ? new StringStatement("getParameters()", MetaClassFactory.get(Object[].class)) : Stmt.newArray(Object.class).initialize(parmVars.toArray()); final BlockBuilder<?> methodBlock = classBuilder.publicMethod(method.getReturnType().getErased(), method.getName(), finalParms); if (intercepted) { methodBlock.append(generateInterceptorLogic(classBuilder, method, generateRequest(classBuilder, method, parameters, true), parmVars, interceptors)); } else { methodBlock.append(generateRequest(classBuilder, method, parameters, false)); } final Statement returnStmt = ProxyUtil.generateProxyMethodReturnStatement(method); if (returnStmt != null) { methodBlock.append(returnStmt); } methodBlock.finish(); }
@Override public String getCanonicalString(final Context context) { return getClassReference(MetaClassFactory.get(o.getClass()), context) + "." + ((Enum) o).name(); } };
@Override public MethodBuilderAbstractOption<ClassStructureBuilderAbstractMethodOption> publicAbstractMethod( Class<?> returnType, String name) { return publicAbstractMethod(MetaClassFactory.get(returnType), name); }
@Override public MethodBuilderAbstractOption<ClassStructureBuilderAbstractMethodOption> protectedAbstractMethod( Class<?> returnType, String name, Parameter... parms) { return protectedAbstractMethod(MetaClassFactory.get(returnType), name, parms); }
@Override public MetaClass[] getDeclaredClasses() { final Class[] declaredClasses = getEnclosedMetaObject().getDeclaredClasses(); final MetaClass[] declaredClassesMC = new MetaClass[declaredClasses.length]; int i = 0; for (final Class c : declaredClasses) { declaredClassesMC[i++] = MetaClassFactory.get(c); } return declaredClassesMC; }
@Override public String getCanonicalString(final Context context) { final StringBuilder buf = new StringBuilder("new " + LoadClassReference.getClassReference(MetaClassFactory.get(arrayType), context)); final Object val = getValue(); for (int i = 0; i < dimensions; i++) { buf.append("[]"); } buf.append(" "); buf.append(renderInlineArrayLiteral(context, val)); return buf.toString(); }
@Override public MethodBuilderAbstractOption<ClassStructureBuilderAbstractMethodOption> publicAbstractMethod( Class<?> returnType, String name, Class<?>... parms) { return publicAbstractMethod(MetaClassFactory.get(returnType), name, MetaClassFactory.fromClassArray(parms)); }
@Override public MethodBuilderAbstractOption<ClassStructureBuilderAbstractMethodOption> protectedAbstractMethod( Class<?> returnType, String name, Class<?>... parms) { return protectedAbstractMethod(MetaClassFactory.get(returnType), name, MetaClassFactory.fromClassArray(parms)); }
private MetaMethod validateExceptionHandlingMethod(final Decorable decorable) { // Ensure that method has exactly one parameter of type Throwable final MetaMethod method = decorable.getAsMethod(); final MetaParameter[] parms = method.getParameters(); if (!(parms.length == 1 && parms[0].getType().equals(MetaClassFactory.get(Throwable.class)))) { throw new GenerationException("Methods annotated with " + UncaughtExceptionHandler.class.getName() + " must have exactly one parameter of type " + Throwable.class.getName() + ". Invalid parameters in method: " + GenUtil.getMethodString(method) + " of type " + method.getDeclaringClass() + "."); } return method; }
@Override public String generate(final Context context) { if (operator == null) { lhs = GenUtil.generate(context, lhs); lhs = GenUtil.convert(context, lhs, MetaClassFactory.get(Boolean.class)); } if (negated) { return UnaryOperator.Complement.getCanonicalString().concat("(") + super.generate(context).concat(")"); } return super.generate(context); }
public static void autoInitializedField(final ClassStructureBuilder<?> builder, final MetaClass type, final String name, MetaClass implementation) { implementation = MetaClassFactory.parameterizedAs(implementation, type.getParameterizedType()); builder.privateField(name, type) .initializesWith(Stmt.newObject(implementation)).finish(); }
@Test public void testWideningCharByte() throws Exception { ArithmeticExpression expr = Arith.expr((char) 1, ArithmeticOperator.Addition, (byte) 3); assertEquals(MetaClassFactory.get(int.class), expr.getType()); }
@Test public void testWideningIntLong() throws Exception { ArithmeticExpression expr = Arith.expr(1, ArithmeticOperator.Addition, (long) 3); assertEquals(MetaClassFactory.get(long.class), expr.getType()); }
@Test public void testCharCharMakesInt() throws Exception { ArithmeticExpression expr = Arith.expr((char) 1, ArithmeticOperator.Addition, (char) 3); assertEquals(MetaClassFactory.get(int.class), expr.getType()); }
@Test public void testObjectCreationWithParameterizedTypeAndClassImport() { final Context c = Context.create().addImport(MetaClassFactory.get(ArrayList.class)); final String s = StatementBuilder.create(c).newObject(new TypeLiteral<ArrayList<String>>() { }).toJavaString(); assertEquals("failed to generate new object with parameterized type", "new ArrayList<String>()", s); }
@Test public void testAddVariableWithObjectInitializationWithExactTypeProvided() { Context ctx = ContextBuilder.create().addVariable("str", String.class, ObjectBuilder.newInstanceOf(String.class)).getContext(); VariableReference str = ctx.getVariable("str"); assertEquals("Wrong variable name", "str", str.getName()); Assert.assertEquals("Wrong variable type", MetaClassFactory.get(String.class), str.getType()); // variable value cannot be verified before initialization statement was generated. Variable v = ctx.getVariables().get("str"); v.generate(ctx); assertNotNull("Value could not be generated", v.getValue()); }
@Test public void testAddVariableWithStringTypeInference() { Context ctx = ContextBuilder.create().addVariable("n", "10").getContext(); VariableReference n = ctx.getVariable("n"); assertEquals("Wrong variable name", "n", n.getName()); Assert.assertEquals("Wrong variable type", MetaClassFactory.get(String.class), n.getType()); Assert.assertEquals("Wrong variable value", LiteralFactory.getLiteral("10"), n.getValue()); }
@Test public void testDeclareVariableWithIntegerTypeInference() { final Context ctx = Context.create(); final String s = StatementBuilder.create().declareVariable("n", 10).generate(ctx); assertEquals("failed to generate variable declaration with Integers type inference", "Integer n = 10;", s); final VariableReference n = ctx.getVariable("n"); assertEquals("Wrong variable name", "n", n.getName()); Assert.assertEquals("Wrong variable type", MetaClassFactory.get(Integer.class), n.getType()); Assert.assertEquals("Wrong variable value", LiteralFactory.getLiteral(10), n.getValue()); }