ClassStructureBuilder<?> validatorInterface = new GwtValidatorGenerator().generate(context); ClassStructureBuilder<?> builder = ClassBuilder .define(packageName + "." + className, AbstractGwtValidatorFactory.class) .publicScope() .body(); BlockBuilder<?> methodBuilder = builder.publicMethod(AbstractGwtValidator.class, "createValidator"); if (validatorInterface == null) { methodBuilder.append( Stmt.nestedCall( Stmt.newObject(BeanValidator.class, Stmt.loadLiteral(null)) ).finish(); methodBuilder.append( Stmt.nestedCall( Stmt.newObject(BeanValidator.class, Cast.to(AbstractGwtValidator.class, Stmt.invokeStatic(GWT.class, "create", validatorInterface.getClassDefinition())) ).finish(); builder.getClassDefinition().addInnerClass(new InnerClass(validatorInterface.getClassDefinition()));
public static BuildMetaClass createArrayMarshallerClass(final MetaClass type) { final BuildMetaClass arrayMarshaller = ClassBuilder .define(MARSHALLER_NAME_PREFIX + getVarName(type)).packageScope() .abstractClass() .implementsInterface( MetaClassFactory.get(GeneratedMarshaller.class)) .body().getClassDefinition(); return arrayMarshaller; }
@Override public ClassStructureBuilder<?> getMarshaller(String marshallerClassName) { ClassDefinitionStaticOption<?> staticOption = ClassBuilder.define(marshallerClassName).publicScope(); classStructureBuilder = staticOption.staticClass().implementsInterface( parameterizedAs(GeneratedMarshaller.class, typeParametersOf(toMap))).body(); else { classStructureBuilder = staticOption.implementsInterface( parameterizedAs(GeneratedMarshaller.class, typeParametersOf(toMap))).body(); initMethod = classStructureBuilder.privateMethod(void.class, "lazyInit"); classStructureBuilder.privateField("EMPTY_ARRAY", arrayType).initializesWith(Stmt.newArray(toMap, 0)).finish(); classStructureBuilder.publicMethod(arrayType, "getEmptyArray") .append(Stmt.loadClassMember("EMPTY_ARRAY").returnValue()) .finish(); Parameter.of(EJValue.class, "a0"), Parameter.of(MarshallingSession.class, "a1")); builder.append(Stmt.loadVariable("this").invoke("lazyInit")); builder.append(Stmt.declareVariable(EJObject.class).named("obj") .initializeWith(loadVariable("a0").invoke("isObject")));
@Test public void testDefineClassWithMethodCallingMethodOnThis() { final String cls = ClassBuilder.define("org.foo.Foo") .publicScope() .body() .publicMethod(void.class, "bar") .append(Stmt.loadVariable("this").invoke("foo")) .finish() .publicMethod(String.class, "foo") .append(Stmt.load(null).returnValue()) .finish() .toJavaString(); assertEquals("failed to generate class with method calling method on this", CLASS_WITH_METHOD_CALLING_METHOD_ON_THIS, cls); }
.define("Dynamic" + fullyQualifiedClassNameToCamelCase(validator.getFullyQualifiedName()), validator) .publicScope() .implementsInterface(parameterizedAs(GeneratedDynamicValidator.class, typeParametersOf(valueType))) .body(); .publicMethod(parameterizedAs(Set.class, typeParametersOf(ConstraintViolation.class)), "validate", finalOf(parameterizedAs(Map.class, typeParametersOf(String.class, Object.class)), "parameters"), finalOf(valueType, "value")) .body(); bodyBlockBuilder.declaresInnerClass(new InnerClass(generatedValidatorBuilder.getClassDefinition())); .append(loadVariable("this").invoke("initialize", annoImpl)) .append(if_(Bool.expr(loadVariable("this").invoke("isValid", loadVariable("value"), castTo(ConstraintValidatorContext.class, loadLiteral(null))))) .append(invokeStatic(Collections.class, "emptySet").returnValue()) .finish().else_() .append(Stmt.declareVariable("paramMessage", String.class, castTo(String.class,
public ClassStructureBuilder<?> generate() { final String safeProxyClassName = bindable.getFullyQualifiedName().replace('.', '_') + "Proxy"; final ClassStructureBuilder<?> classBuilder = ClassBuilder.define(safeProxyClassName, bindable) .packageScope() .implementsInterface(BindableProxy.class) .body(); .privateField(agentField, parameterizedAs(BindableProxyAgent.class, typeParametersOf(bindable))) .finish() .privateField(targetField, bindable) .finish() .publicConstructor() .callThis(Stmt.newObject(bindable)) .finish() .publicConstructor(Parameter.of(bindable, "targetVal")) .append(Stmt.loadVariable(agentField).assignValue( Stmt.newObject(parameterizedAs(BindableProxyAgent.class, typeParametersOf(bindable)), Variable.get("this"), Variable.get("targetVal")))) .append(Stmt.loadVariable(targetField).assignValue(Variable.get("targetVal"))) .append(generatePropertiesMap()) .append(agent().returnValue()) .append(agent().invoke("updateWidgetsAndFireEvents")) .append(target().returnValue())
builder = ClassBuilder.define(proxyClassName, toProxy).publicScope().body(); builder = ClassBuilder.define(proxyClassName).publicScope().implementsInterface(toProxy).body(); builder.privateField(proxyVar, toProxy).finish(); builder.privateField(stateVar, boolean.class).finish(); builder.privateField(entry.getValue().getEncodedProperty(), entry.getValue().getType()).finish(); builder.packageMethod(void.class, "$set_" + entry.getKey(), Parameter.of(entry.getValue().getType(), "o")) .append(Stmt.loadVariable(entry.getValue().getEncodedProperty()).assignValue(Refs.get("o"))) .finish(); final BlockBuilder methBody = builder.publicMethod(method.getReturnType(), method.getName()) .annotatedWith(OVERRIDE_ANNOTATION) .parameters(defParameters) .throws_(method.getCheckedExceptions()); BlockBuilder<ElseBlockBuilder> ifBody = Stmt.create().if_( BooleanExpressionBuilder.create(Stmt.loadVariable(stateVar))); ifBody.appendAll(getAroundInvokeStatements(method)); ifBody.appendAll(getBeforeStatements(method)); builder.publicMethod(int.class, "hashCode") .annotatedWith(OVERRIDE_ANNOTATION) .body() ._(
= ClassBuilder.define(packageName + "." + className).publicScope() .implementsInterface(QualifierEqualityFactory.class) .body(); builder.getClassDefinition().getContext().setPermissiveMode(true); builder.privateField(COMPARATOR_MAP_VAR, mapStringAnnoComp) .initializesWith(Stmt.newObject(mapStringAnnoComp)).finish(); final ConstructorBlockBuilder<? extends ClassStructureBuilder<?>> constrBuilder = builder.publicConstructor(); constrBuilder._(Stmt.loadVariable(COMPARATOR_MAP_VAR) .invoke("put", MC_annotationClass.getFullyQualifiedName(), generateComparatorFor(MC_annotationClass, methods))); builder.publicMethod(int.class, "hashCodeOf", Parameter.of(Annotation.class, "a1")) .body() ._( If.cond(Stmt.loadVariable(COMPARATOR_MAP_VAR).invoke("containsKey",
ClassBuilder.define(marshallerClassName).publicScope(). implementsInterface(parameterizedAs(Marshaller.class, typeParametersOf(arrayType))).body(); initMethod = classStructureBuilder.privateMethod(void.class, "lazyInit"); classStructureBuilder.publicMethod(arrayOfArrayType, "getEmptyArray") .append(Stmt.load(null).returnValue()) .finish(); final BlockBuilder<?> bBuilder = classStructureBuilder.publicMethod(arrayType, "demarshall", Parameter.of(EJValue.class, "a0"), Parameter.of(MarshallingSession.class, "a1")); bBuilder.append( If.isNull(loadVariable("a0")) .append(Stmt.load(null).returnValue()) .finish() .else_()
@Test public void testDefineInnerClassInMethod() { final ClassStructureBuilder<?> innerClass = ClassBuilder.define("Inner") .packageScope() .implementsInterface(Serializable.class) .body() .privateField("name", String.class) .finish() .publicMethod(void.class, "setName", Parameter.of(String.class, "name", true)) .append(Stmt.loadClassMember("name").assignValue(Variable.get("name"))) .finish(); final String cls = ClassBuilder.define("foo.bar.Baz") .publicScope() .body() .publicMethod(void.class, "someMethod") .append(new InnerClass(innerClass.getClassDefinition())) .append(Stmt.newObject(innerClass.getClassDefinition())) .finish() .toJavaString(); assertEquals("failed to generate class with method using inner class", CLASS_WITH_METHOD_USING_INNER_CLASS, cls); }
asyncBootstrap = s != null && Boolean.parseBoolean(s); final Statement newBeanManager = asyncBootstrap ? Stmt.newObject(AsyncBeanManagerImpl.class) : Stmt.newObject(SyncBeanManagerImpl.class); = ClassBuilder.define(packageName + "." + className).publicScope() .implementsInterface(IOCEnvironment.class) .body() .publicMethod(boolean.class, "isAsync") .append(Stmt.load(asyncBootstrap).returnValue()) .finish() .publicMethod(ClientBeanManager.class, "getNewBeanManager") .append(Stmt.nestedCall(newBeanManager).returnValue()) .finish(); final String csq = builder.toJavaString(); printWriter.append(csq); generatorContext.commit(logger, printWriter);
@Test public void testAnonymousClassReferencingOuterClass() { ClassStructureBuilder<?> outer = ClassBuilder.define("org.foo.Outer").publicScope().body(); .extend() .publicOverridesMethod("setName", Parameter.of(String.class, "name")) .append( Stmt.loadStatic(outer.getClassDefinition(), "this").loadField("outerName").assignValue( Variable.get("name"))) .append(Stmt.loadStatic(outer.getClassDefinition(), "this").invoke("setOuterName", Variable.get("name"))) .finish() .finish(); .publicField("outerName", String.class) .finish() .publicMethod(void.class, "setOuterName", Parameter.of(String.class, "outerName")) .append(Stmt.loadClassMember("outerName").assignValue(Variable.get("outerName"))) .finish() .publicMethod(void.class, "test") .append(anonInner) .finish() .toJavaString();
@Test public void testDefineClassWithStaticMethod() { final String cls = ClassBuilder.define("my.test.Clazz") .publicScope().body() .publicMethod(void.class, "test").modifiers(Modifier.Static) .body() .append(Stmt.loadStatic(System.class, "out").invoke("println", "Hello, World!")) .finish() .toJavaString(); assertEquals("failed to generate class with static method", CLASS_WITH_STATIC_METHOD, cls); }
/** Regression test for ERRAI-363. */ @Test public void testReferenceToAnonymousClassMember() throws Exception { ClassStructureBuilder<?> builder = ClassBuilder.define("com.foo.A").publicScope().body(); builder.privateMethod(void.class, "method") .append(ObjectBuilder.newInstanceOf(Runnable.class).extend() .privateField("memberOfRunnable", Object.class).finish() .publicOverridesMethod("run").append(Stmt.loadVariable("memberOfRunnable").invoke("hashCode")).finish() .finish()) .finish(); String javaString = builder.toJavaString(); assertEquals("package com.foo; public class A { private void method() { new Runnable() { private Object memberOfRunnable; public void run() { memberOfRunnable.hashCode(); } }; } }", javaString); }
@Test public void testDefineClassWithFieldInheritance() { final String cls = ClassBuilder .define("org.foo.Foo", Parent.class) .publicScope() .body() .publicConstructor() .append(Stmt.loadVariable("parentProtected").assignValue(0)) .append(Stmt.loadVariable("parentPublic").assignValue(0)) .finish() .toJavaString(); assertEquals("failed to generate class with parent", CLASS_WITH_FIELD_INHERITANCE, cls); }
@Test public void testMethodAnnotated() { final String cls = ClassBuilder.define("MyRunnable") .publicScope().implementsInterface(Runnable.class) .body() .publicMethod(void.class, "run") .annotatedWith(new SuppressWarnings() { @Override public String[] value() { return new String[]{"blah"}; } @Override public Class<? extends Annotation> annotationType() { return SuppressWarnings.class; } }).body() .append(Stmt.returnVoid()) .finish().toJavaString(); assertEquals("public class MyRunnable implements Runnable {\n" + " @SuppressWarnings(\"blah\") public void run() {\n" + " return;\n" + " }\n" + "}", cls); }
public ClassStructureBuilder<?> generate() { String safeProxyClassName = remote.getFullyQualifiedName().replace('.', '_') + "Impl"; ClassStructureBuilder<?> classBuilder = ClassBuilder.define(safeProxyClassName, AbstractJaxrsProxy.class) .packageScope() .implementsInterface(remote) .body() .privateField("remoteCallback", RemoteCallback.class) .finish() .privateField("errorCallback", ErrorCallback.class) .finish() .publicConstructor() .append(generateConstructor()) .finish() .publicMethod(RemoteCallback.class, "getRemoteCallback") .append(Stmt.loadClassMember("remoteCallback").returnValue()) .finish() .publicMethod(void.class, "setRemoteCallback", Parameter.of(RemoteCallback.class, "callback")) .append(Stmt.loadClassMember("remoteCallback").assignValue(Variable.get("callback"))) .finish() .publicMethod(ErrorCallback.class, "getErrorCallback") .append(Stmt.loadClassMember("errorCallback").returnValue()) .finish() .publicMethod(void.class, "setErrorCallback", Parameter.of(ErrorCallback.class, "callback"))
Person kid3 = new PersonImpl("Kid 3", 5, mom); ClassStructureBuilder<?> peopleClassBuilder = ClassBuilder.define("com.foo.People").publicScope().body(); BlockBuilder<?> method = peopleClassBuilder.publicMethod(void.class, "makePeople").body(); .declareVariable(Person.class) .asFinal() .named("mom") .initializeWith(SnapshotMaker.makeSnapshotAsSubclass(mom, Person.class, Person.class, null, Person.class)); method.append(momVar); method.append(Stmt.declareVariable("kid1", SnapshotMaker.makeSnapshotAsSubclass(kid1, Person.class, Person.class, mbcb, Person.class))); method.append(Stmt.declareVariable("kid2", SnapshotMaker.makeSnapshotAsSubclass(kid2, Person.class, Person.class, mbcb, Person.class))); method.append(Stmt.declareVariable("kid3", SnapshotMaker.makeSnapshotAsSubclass(kid3, Person.class, Person.class, mbcb, Person.class))); method.finish(); final String generated = peopleClassBuilder.toJavaString();
static String generateSource(final Iterable<MetaClass> qualifiers) { final ClassStructureBuilder<?> body = ClassBuilder .define(SERIALIZER_PACKAGE_NAME + "." + SERIALIZER_CLASS_NAME, EventQualifierSerializer.class) .publicScope().body(); final ConstructorBlockBuilder<?> ctor = body.publicConstructor(); for (final MetaClass qual : qualifiers) { final Collection<MetaMethod> bindingAttributes = CDIAnnotationUtils.getAnnotationAttributes(qual); if (!bindingAttributes.isEmpty()) { ctor.append(loadVariable("serializers").invoke("put", qual.getFullyQualifiedName(), generateEntryStatement(qual, bindingAttributes))); } } ctor.finish(); return body.toJavaString(); }
/** * Create an inner interface for the given {@link MessageBundle} class and its corresponding JSON * resource. * * @param bundlePath * path to the message bundle */ private BuildMetaClass generateMessageBundleResourceInterface(final String bundlePath) { final ClassStructureBuilder<?> componentMessageBundleResource = ClassBuilder .define(getMessageBundleTypeName(bundlePath)).publicScope() .interfaceDefinition().implementsInterface(MessageBundle.class) .implementsInterface(ClientBundle.class).body() .publicMethod(TextResource.class, "getContents") .annotatedWith(new Source() { @Override public Class<? extends Annotation> annotationType() { return Source.class; } @Override public String[] value() { return new String[] { bundlePath }; } }).finish(); return componentMessageBundleResource.getClassDefinition(); }