final long time = System.currentTimeMillis(); final MethodBlockBuilder<?> loadProxies = classBuilder.publicMethod(void.class, "loadProxies", Parameter.of(MessageBus.class, "bus", true)); if (remote.isInterface()) { 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)); classBuilder = (ClassStructureBuilder<?>) loadProxies.finish(); String gen = classBuilder.toJavaString();
public static void createJavaReflectionFieldInitializerUtilMethod(final ClassStructureBuilder<?> classBuilder) { if (classBuilder.getClassDefinition().getMethod(JAVA_REFL_FLD_UTIL_METH, Class.class, Field.class) != null) { return; } classBuilder.privateMethod(Field.class, JAVA_REFL_FLD_UTIL_METH).modifiers(Modifier.Static) .parameters(DefParameters.of(Parameter.of(Class.class, "cls"), Parameter.of(String.class, "name"))) .body() ._(Stmt.try_() ._(Stmt.declareVariable("fld", Stmt.loadVariable("cls").invoke("getDeclaredField", Stmt.loadVariable("name")))) ._(Stmt.loadVariable("fld").invoke("setAccessible", true)) ._(Stmt.loadVariable("fld").returnValue()) .finish() .catch_(Throwable.class, "e") ._(Stmt.loadVariable("e").invoke("printStackTrace")) ._(Stmt.throw_(RuntimeException.class, Refs.get("e"))) .finish()) .finish(); }
@Override public void createReadableField(final MetaClass type, final ClassStructureBuilder<?> classBuilder, final MetaField field, final Modifier[] modifiers) { final MethodBlockBuilder<? extends ClassStructureBuilder<?>> instance = classBuilder.packageMethod(type, PrivateAccessUtil.getPrivateFieldAccessorName(field)); if (!field.isStatic()) { instance.parameters(DefParameters.fromParameters(Parameter.of(field.getDeclaringClass().getErased(), "instance"))); } if (type.getCanonicalName().equals("long")) { instance.annotatedWith(UNSAFE_NATIVE_LONG_ANNOTATION); } instance.modifiers(appendJsni(modifiers)) .body() ._(StringStatement.of("return " + JSNIUtil.fieldAccess(field))) .finish(); }
builder.privateField(proxyVar, toProxy).finish(); builder.privateField(stateVar, boolean.class).finish(); methodParms.add(Parameter.of(parameters[i].getType().getErased(), "a" + i)); .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)); statementVars[i] = loadVariable(parms.get(i).getName()); .annotatedWith(OVERRIDE_ANNOTATION) .body() .body() ._(loadVariable(proxyVar).assignValue(loadVariable("proxy")))
if (bindable.isFinal()) { throw new RuntimeException("@Bindable type cannot be final: " + bindable.getFullyQualifiedName()); if (bindable.getDeclaredConstructor(new MetaClass[0]) == null || !bindable.getDeclaredConstructor(new MetaClass[0]).isPublic()) { throw new RuntimeException("@Bindable type needs a public default no-arg constructor: " + bindable.getFullyQualifiedName()); loadProxies.append(new InnerClass(bindableProxy.getClassDefinition())); final Statement proxyProvider = ObjectBuilder.newInstanceOf(BindableProxyProvider.class) .extend() .publicOverridesMethod("getBindableProxy", Parameter.of(Object.class, "model")) .append(Stmt.nestedCall(Stmt.newObject(bindableProxy.getClassDefinition()) .withParameters(Cast.to(bindable, Stmt.loadVariable("model")))).returnValue()) .finish() .publicOverridesMethod("getBindableProxy") .append( Stmt.nestedCall( Stmt.newObject(bindableProxy.getClassDefinition())) .finish() .finish(); loadProxies.append(Stmt.invokeStatic(BindableProxyFactory.class, "addBindableProxy", bindable, proxyProvider)); classBuilder = (ClassStructureBuilder<?>) loadProxies.finish(); return classBuilder.toJavaString();
@Override public void createWritableField(final MetaClass type, final ClassStructureBuilder<?> classBuilder, final MetaField field, final Modifier[] modifiers) { final String cachedField = initCachedField(classBuilder, field); final String setterName = getReflectionFieldSetterName(field); final MethodCommentBuilder<? extends ClassStructureBuilder<?>> methodBuilder = classBuilder.privateMethod(void.class, PrivateAccessUtil.getPrivateFieldAccessorName(field)); if (!field.isStatic()) { methodBuilder .parameters( DefParameters.fromParameters( Parameter.of(field.getDeclaringClass().getErased(), "instance"), Parameter.of(field.getType(), "value") ) ); } methodBuilder.modifiers(modifiers) .body() ._(Stmt.try_() ._(Stmt.loadVariable(cachedField).invoke(setterName, Refs.get("instance"), Refs.get("value"))) .finish() .catch_(Throwable.class, "e") ._(Stmt.loadVariable("e").invoke("printStackTrace")) ._(Stmt.throw_(RuntimeException.class, Refs.get("e"))) .finish()) .finish(); }
dimParms[0] = Stmt.loadVariable("a0").invoke("size"); final MetaClass arrayType = toMap.asArrayOf(dim); final Statement demarshallerStatement = Stmt.castTo(toMap.asBoxed().asClass(), Stmt.loadVariable(marshallerVarName).invoke("demarshall", loadVariable("a0") .invoke("get", loadVariable("i")), Stmt.loadVariable("a1"))); classBuilder.privateMethod(arrayType, "_demarshall" + dim) .parameters(EJArray.class, MarshallingSession.class).body(); dmBuilder.append(Stmt.loadVariable("this").invoke("lazyInit")); dmBuilder.append(Stmt .declareVariable(arrayType).named("newArray") .initializeWith(Stmt.newArray(toMap, dimParms))); dmBuilder.append(autoForLoop("i", Stmt.loadVariable("newArray").loadField("length")) .append(dim == 1 ? outerAccessorStatement : loadVariable("newArray", loadVariable("i")).assignValue( dmBuilder.finish(); final BlockBuilder<?> mBuilder = classBuilder.privateMethod(String.class, "_marshall" + dim) .parameters(arrayType, MarshallingSession.class).body();
wrapperDefParms.add(Parameter.of(method.getDeclaringClass().getErased(), "instance")); args[i++] = Refs.get(p.getName()); = classBuilder.publicMethod(method.getReturnType(), PrivateAccessUtil.getPrivateMethodName(method)) .parameters(DefParameters.fromParameters(wrapperDefParms)) .modifiers(modifiers) .body(); final BlockBuilder<CatchBlockBuilder> tryBuilder = Stmt.try_(); final ContextualStatementBuilder statementBuilder = Stmt.loadVariable(cachedMethod) .invoke("invoke", method.isStatic() ? null : Refs.get("instance"), args); if (method.getReturnType().isVoid()) { tryBuilder._(statementBuilder); tryBuilder._(Stmt.castTo(method.getReturnType().asBoxed(), statementBuilder).returnValue()); body._(tryBuilder .finish() .catch_(Throwable.class, "e")
classContext = classStructureBuilder.getClassDefinition().getContext(); mappingContext = GeneratorMappingContextFactory.create(context, target, this, classStructureBuilder, new ArrayMarshallerCallbackImpl()); classStructureBuilder.getClassDefinition().addAnnotation(() -> Dependent.class); autoInitializedField(classStructureBuilder, javaUtilMap, MARSHALLERS_VAR, mapClass); final ConstructorBlockBuilder<?> constructor = classStructureBuilder.publicConstructor(); classStructureBuilder.publicMethod(parameterizedAs(Marshaller.class, typeParametersOf(Object.class)), "getMarshaller").parameters(String.class) .body() .append( If.isNull(loadVariable("a0")) .append(Stmt.loadLiteral(null).returnValue()).finish()) .append(Stmt.declareVariable("m", Marshaller.class, Stmt.loadVariable(MARSHALLERS_VAR).invoke("get", loadVariable("a0")))); classStructureBuilder.publicMethod(void.class, "registerMarshaller").parameters(String.class, Marshaller.class) .body() .append(Stmt.loadVariable(MARSHALLERS_VAR).invoke("put", Stmt.loadVariable("a0"), Stmt.loadVariable("a1"))) .finish();
@Override public void makeConstructorAccessible(final ClassStructureBuilder<?> classBuilder, final MetaConstructor constructor) { final DefParameters methodDefParms = DefParameters.from(constructor); final String cachedMethod = initCachedMethod(classBuilder, constructor); final Object[] args = new Object[methodDefParms.getParameters().size()]; int i = 0; for (final Parameter p : methodDefParms.getParameters()) { args[i++] = Refs.get(p.getName()); } final BlockBuilder<? extends ClassStructureBuilder> body = classBuilder.publicMethod(constructor.getReturnType(), PrivateAccessUtil.getPrivateMethodName(constructor)) .parameters(methodDefParms) .modifiers(Modifier.Static) .body(); final Statement tryBuilder = Stmt.try_() .append( Stmt.nestedCall( Stmt.castTo(constructor.getReturnType(), Stmt.loadVariable(cachedMethod).invoke("newInstance", (Object) args))).returnValue()) .finish() .catch_(Throwable.class, "e") .append(Stmt.loadVariable("e").invoke("printStackTrace")) .append(Stmt.throw_(RuntimeException.class, Refs.get("e"))) .finish(); body.append(tryBuilder).finish(); }
if (method.getReturnType().isPrimitive()) { isEqualBuilder._( If.notEquals(Stmt.loadVariable("a1").invoke(method), Stmt.loadVariable("a2").invoke(method)) ._(Stmt.load(false).returnValue()) .finish() ); else if (method.getReturnType().isArray()) { isEqualBuilder._( If.not(Stmt.invokeStatic(Arrays.class, "equals", Stmt.loadVariable("a1").invoke(method), Stmt.loadVariable("a2").invoke(method)) isEqualBuilder._( If.not(Stmt.loadVariable("a1").invoke(method).invoke("equals", Stmt.loadVariable("a2").invoke(method))) ._(Stmt.load(false).returnValue()) isEqualBuilder._(Stmt.load(true).returnValue()); = clsBuilder.publicOverridesMethod("hashCodeOf", Parameter.of(MC_annotationClass, "a1")); hashCodeOfBuilder._(Stmt.declareVariable(int.class).named("hash") hashCodeOfBuilder.finish(); final AnonymousClassStructureBuilder classStructureBuilder = isEqualBuilder.finish();
private String generateErraiEntityType(final EntityType<?> et, MethodBlockBuilder<?> pmm, List<MetaClass> globalListeners, ClassStructureBuilder<?> classBuilder) { MetaClass met = MetaClassFactory.get(et.getJavaType()); pmm.append(Stmt.codeComment( "**\n" + "** EntityType for " + et.getJavaType().getName() + "\n" + Stmt.newObject(MetaClassFactory.get(ErraiEntityType.class, new ParameterizedEntityType(et.getJavaType()))) .extend(); .append(Stmt.nestedCall(Stmt.newObject(et.getJavaType())).returnValue()) .finish(); MethodBlockBuilder<?> cmm = classBuilder.privateMethod(MetaClassFactory.get(ErraiEntityType.class, new ParameterizedEntityType(et.getJavaType())), entityTypeMethodName); cmm.append(Stmt.declareVariable(ErraiEntityType.class).asFinal().named("entityType") .initializeWith(entityTypeSubclass.finish().withParameters(et.getName(), et.getJavaType()))); attrib, SingularAttribute.class, ErraiSingularAttribute.class, methodBodyCallback, EntityType.class, ManagedType.class, Type.class); cmm.append(Stmt.loadVariable("entityType").invoke("addAttribute", attribSnapshot)); attrib, PluralAttribute.class, ErraiPluralAttribute.class, methodBodyCallback, EntityType.class, ManagedType.class, Type.class); cmm.append(Stmt.loadVariable("entityType").invoke("addAttribute", attribSnapshot)); cmm.append(Stmt.loadVariable("entityType").returnValue()); cmm.finish(); pmm.append(Stmt.loadVariable(entityTypeVarName).assignValue(Stmt.loadVariable("this").invoke(entityTypeMethodName)));
@Override public void makeMethodAccessible(final ClassStructureBuilder<?> classBuilder, final MetaMethod method, final Modifier[] modifiers) { final MetaMethod erasedMethod = method.getDeclaringClass().getErased().getDeclaredMethod(method.getName(), getErasedParamterTypes(method)); final List<Parameter> wrapperDefParms = new ArrayList<Parameter>(); if (!erasedMethod.isStatic()) { wrapperDefParms.add(Parameter.of(erasedMethod.getDeclaringClass().getErased(), "instance")); } final List<Parameter> methodDefParms = DefParameters.from(erasedMethod).getParameters(); wrapperDefParms.addAll(methodDefParms); Annotation[] annotations = NO_ANNOTATIONS; for (MetaParameter p : erasedMethod.getParameters()) { if (p.getType().getCanonicalName().equals("long")) { annotations = new Annotation[] { UNSAFE_NATIVE_LONG_ANNOTATION }; } } if (erasedMethod.getReturnType().getCanonicalName().equals("long")) { annotations = new Annotation[] { UNSAFE_NATIVE_LONG_ANNOTATION }; } classBuilder.publicMethod(erasedMethod.getReturnType(), PrivateAccessUtil.getPrivateMethodName(method)) .annotatedWith(annotations) .parameters(DefParameters.fromParameters(wrapperDefParms)) .modifiers(appendJsni(modifiers)) .body() ._(StringStatement.of(JSNIUtil.methodAccess(erasedMethod))) .finish(); }
final Statement lookupMethod = Stmt.invokeStatic(context.getBootstrapClass(), "addLookups_" + addLookupMethodCount); if (currentBlock != null) { currentBlock .append(lookupMethod); currentBlock.modifiers(Modifier.Static).finish(); context.getBootstrapBuilder().privateMethod(void.class, "addLookups_" + addLookupMethodCount++); if (subClass.getSuperClass() != null) { currentBlock.append(Stmt.invokeStatic(CDIEventTypeLookup.class, "get") .invoke("addLookup", subClass.getFullyQualifiedName(), subClass.getSuperClass().getFullyQualifiedName())); for (final MetaClass interfaceClass : subClass.getInterfaces()) { currentBlock.append(Stmt.invokeStatic(CDIEventTypeLookup.class, "get") .invoke("addLookup", subClass.getFullyQualifiedName(), interfaceClass.getFullyQualifiedName())); currentBlock.modifiers(Modifier.Static).finish();
@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); }
@Override public void createWritableField(final MetaClass type, final ClassStructureBuilder<?> classBuilder, final MetaField field, final Modifier[] modifiers) { final MethodCommentBuilder<? extends ClassStructureBuilder<?>> methodBuilder = classBuilder.packageMethod(void.class, PrivateAccessUtil.getPrivateFieldAccessorName(field)); if (type.getCanonicalName().equals("long")) { methodBuilder.annotatedWith(UNSAFE_NATIVE_LONG_ANNOTATION); } if (!field.isStatic()) { methodBuilder .parameters(DefParameters.fromParameters(Parameter.of(field.getDeclaringClass().getErased(), "instance"), Parameter.of(type, "value"))); } else { methodBuilder .parameters(DefParameters.fromParameters(Parameter.of(type, "value"))); } methodBuilder.modifiers(appendJsni(modifiers)) .body() ._(StringStatement.of(JSNIUtil.fieldAccess(field) + " = value")) .finish(); }
for (final MetaClass iface : converter.getInterfaces()) { if (iface.getErased().equals(MetaClassFactory.get(Converter.class))) { final MetaParameterizedType parameterizedInterface = iface.getParameterizedType(); if (parameterizedInterface != null) { final MetaType[] typeArgs = parameterizedInterface.getTypeParameters(); if (typeArgs != null && typeArgs.length == 2) { registerConverterStatement = Stmt.invokeStatic(Convert.class, "registerDefaultConverter", typeArgs[0], typeArgs[1], Stmt.newObject(converter)); loadProxies.append(registerConverterStatement);
private void generateCreateMetamodelMethod( final ClassStructureBuilder<?> classBuilder, Metamodel mm) { MethodBlockBuilder<?> cmm = classBuilder.privateMethod(ErraiMetamodel.class, "createMetamodel"); cmm.append(Stmt.declareVariable("metamodel", Stmt.newObject(ErraiMetamodel.class))); classBuilder.privateField(entityTypeVarName, ErraiEntityType.class).finish(); while (superclass != null) { if (entityTypes.contains(superclass)) { cmm.append(Stmt.loadVariable(entitySnapshotVarName(superclass)) .invoke("addSubtype", Stmt.loadVariable(entityTypeVarName))); cmm.append(new StringStatement("metamodel.freeze()")); cmm.append(Stmt.loadVariable("metamodel").returnValue()); cmm.finish();
@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); }
@Override public void makeConstructorAccessible(final ClassStructureBuilder<?> classBuilder, final MetaConstructor constructor) { final DefParameters methodDefParms = DefParameters.from(constructor); Annotation[] annotations = NO_ANNOTATIONS; for (MetaParameter p : constructor.getParameters()) { if (p.getType().getCanonicalName().equals("long")) { annotations = new Annotation[] { UNSAFE_NATIVE_LONG_ANNOTATION }; } } classBuilder.publicMethod(constructor.getReturnType(), PrivateAccessUtil.getPrivateMethodName(constructor)) .annotatedWith(annotations) .parameters(methodDefParms) .modifiers(Modifier.Static, Modifier.JSNI) .body() ._(StringStatement.of(JSNIUtil.methodAccess(constructor))) .finish(); }