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; }
log.info("generating RPC proxy loader class..."); ClassStructureBuilder<?> classBuilder = ClassBuilder.implement(RpcProxyLoader.class); final long time = System.currentTimeMillis(); final MethodBlockBuilder<?> loadProxies = classBuilder.publicMethod(void.class, "loadProxies", Parameter.of(MessageBus.class, "bus", true)); loadProxies.append(new InnerClass(remoteProxy.getClassDefinition())); .extend() .publicOverridesMethod("getProxy") .append(Stmt.nestedCall(Stmt.newObject(remoteProxy.getClassDefinition())).returnValue()) .finish() .finish(); loadProxies.append(Stmt.invokeStatic(RemoteServiceProxyFactory.class, "addRemoteProxy", remote, proxyProvider));
public static ClassStructureBuilder<?> implement(final MetaClass cls) { return new ClassBuilder<DefaultClassStructureBuilder>(cls.getFullyQualifiedName() + "Impl", null, Context.create() .autoImport()) .publicScope() .implementsInterface(cls).body(); }
@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); }
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())
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_()
.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,
= ClassBuilder.define(packageName + "." + className).publicScope() .implementsInterface(QualifierEqualityFactory.class) .body(); builder.getClassDefinition().getContext().setPermissiveMode(true); = parameterizedAs(HashMap.class, typeParametersOf(String.class, AnnotationComparator.class)); 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",
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()));
@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); }
@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); }
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();
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(); }
/** 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); }
/** * 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(); }
@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 testDefineClassImplementingInterface() { final String cls = ClassBuilder.define("org.foo.Bar") .publicScope() .implementsInterface(Serializable.class) .body() .privateField("name", String.class) .finish() .toJavaString(); System.out.println(cls); assertEquals("failed to generate class definition implementing an interface", CLASS_IMPLEMENTING_INTERFACE, 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); }