ClassDefinition classDefinition = new ClassDefinition(a(PUBLIC, FINAL), makeClassName("VarArgsToListAdapter"), type(Object.class)); classDefinition.declareDefaultConstructor(a(PRIVATE)); MethodDefinition stateFactoryDefinition = classDefinition.declareMethod(a(PUBLIC, STATIC), "createState", type(VarArgsToArrayAdapterState.class)); MethodDefinition methodDefinition = classDefinition.declareMethod(a(PUBLIC, STATIC), "varArgsToArray", type(returnType), parameterList); BytecodeBlock body = methodDefinition.getBody();
@Inject public EmbedVersion(ServerConfig serverConfig) { ClassDefinition classDefinition = new ClassDefinition( a(PUBLIC, FINAL), makeClassName(baseClassName(serverConfig)), type(Object.class), type(Runnable.class)); FieldDefinition field = classDefinition.declareField(a(PRIVATE), "runnable", Runnable.class); Parameter parameter = arg("runnable", type(Runnable.class)); MethodDefinition constructor = classDefinition.declareConstructor(a(PUBLIC), parameter); constructor.getBody() .comment("super(runnable);") .append(constructor.getThis()) .invokeConstructor(Object.class) .append(constructor.getThis()) .append(parameter) .putField(field) .ret(); MethodDefinition run = classDefinition.declareMethod(a(PUBLIC), "run", type(void.class)); run.getBody() .comment("runnable.run();") .append(run.getThis()) .getField(field) .invokeInterface(Runnable.class, "run", void.class) .ret(); Class<? extends Runnable> generatedClass = defineClass(classDefinition, Runnable.class, ImmutableMap.of(), getClass().getClassLoader()); this.runnableConstructor = constructorMethodHandle(generatedClass, Runnable.class); }
private static FieldDefinition generateInstanceSize(ClassDefinition definition) { // Store instance size in static field FieldDefinition instanceSize = definition.declareField(a(PRIVATE, STATIC, FINAL), "INSTANCE_SIZE", long.class); definition.getClassInitializer() .getBody() .comment("INSTANCE_SIZE = ClassLayout.parseClass(%s.class).instanceSize()", definition.getName()) .push(definition.getType()) .invokeStatic(ClassLayout.class, "parseClass", ClassLayout.class, Class.class) .invokeVirtual(ClassLayout.class, "instanceSize", int.class) .intToLong() .putStaticField(instanceSize); return instanceSize; }
private Class<? extends PageWithPositionComparator> generatePageWithPositionComparatorClass(List<Type> sortTypes, List<Integer> sortChannels, List<SortOrder> sortOrders) { CallSiteBinder callSiteBinder = new CallSiteBinder(); ClassDefinition classDefinition = new ClassDefinition( a(PUBLIC, FINAL), makeClassName("PageWithPositionComparator"), type(Object.class), type(PageWithPositionComparator.class)); classDefinition.declareDefaultConstructor(a(PUBLIC)); generateMergeSortCompareTo(classDefinition, callSiteBinder, sortTypes, sortChannels, sortOrders); return defineClass(classDefinition, PageWithPositionComparator.class, callSiteBinder.getBindings(), getClass().getClassLoader()); }
private <T> Class<? extends T> compileProcessor( RowExpression filter, List<RowExpression> projections, BodyCompiler bodyCompiler, Class<? extends T> superType) { ClassDefinition classDefinition = new ClassDefinition( a(PUBLIC, FINAL), makeClassName(superType.getSimpleName()), type(Object.class), type(superType)); CallSiteBinder callSiteBinder = new CallSiteBinder(); bodyCompiler.generateMethods(classDefinition, callSiteBinder, filter, projections); // // toString method // generateToString( classDefinition, callSiteBinder, toStringHelper(classDefinition.getType().getJavaClassName()) .add("filter", filter) .add("projections", projections) .toString()); return defineClass(classDefinition, superType, callSiteBinder.getBindings(), getClass().getClassLoader()); }
private static <T> Class<? extends T> generateSingleStateClass(Class<T> clazz, Map<String, Type> fieldTypes, DynamicClassLoader classLoader) { ClassDefinition definition = new ClassDefinition( a(PUBLIC, FINAL), makeClassName("Single" + clazz.getSimpleName()), type(Object.class), type(clazz)); FieldDefinition instanceSize = generateInstanceSize(definition); // Add getter for class size definition.declareMethod(a(PUBLIC), "getEstimatedSize", type(long.class)) .getBody() .getStaticField(instanceSize) .retLong(); // Generate constructor MethodDefinition constructor = definition.declareConstructor(a(PUBLIC)); constructor.getBody() .append(constructor.getThis()) .invokeConstructor(Object.class); // Generate fields List<StateField> fields = enumerateFields(clazz, fieldTypes); for (StateField field : fields) { generateField(definition, constructor, field); } constructor.getBody() .ret(); return defineClass(definition, clazz, classLoader); }
private static MethodDefinition declareAddIntermediate(ClassDefinition definition, boolean grouped) { ImmutableList.Builder<Parameter> parameters = ImmutableList.builder(); if (grouped) { parameters.add(arg("groupIdsBlock", GroupByIdBlock.class)); } parameters.add(arg("block", Block.class)); return definition.declareMethod( a(PUBLIC), "addIntermediate", type(void.class), parameters.build()); }
private ClassDefinition defineFilterClass(RowExpression filter, InputChannels inputChannels, CallSiteBinder callSiteBinder, Optional<String> classNameSuffix) ClassDefinition classDefinition = new ClassDefinition( a(PUBLIC, FINAL), generateFilterClassName(classNameSuffix), generateFilterMethod(classDefinition, callSiteBinder, cachedInstanceBinder, compiledLambdaMap, filter); FieldDefinition selectedPositions = classDefinition.declareField(a(PRIVATE), "selectedPositions", boolean[].class); generatePageFilterMethod(classDefinition, selectedPositions); classDefinition.declareMethod(a(PUBLIC), "isDeterministic", type(boolean.class)) .getBody() .append(constantBoolean(determinismEvaluator.isDeterministic(filter))) classDefinition.declareMethod(a(PUBLIC), "getInputChannels", type(InputChannels.class)) .getBody() .append(invoke(callSiteBinder.bind(inputChannels, InputChannels.class), "getInputChannels")) String toStringResult = toStringHelper(classDefinition.getType() .getJavaClassName()) .add("filter", filter) .toString(); classDefinition.declareMethod(a(PUBLIC), "toString", type(String.class)) .getBody()
CallSiteBinder callSiteBinder = new CallSiteBinder(); ClassDefinition classDefinition = new ClassDefinition(a(PUBLIC, FINAL), makeClassName("VarArgsToMapAdapter"), type(Object.class)); MethodDefinition methodDefinition = classDefinition.declareMethod(a(PUBLIC, STATIC), "varArgsToMap", type(returnType), parameterList); BytecodeBlock body = methodDefinition.getBody();
private static void generateField(ClassDefinition definition, MethodDefinition constructor, StateField stateField) { FieldDefinition field = definition.declareField(a(PRIVATE), UPPER_CAMEL.to(LOWER_CAMEL, stateField.getName()) + "Value", stateField.getType()); // Generate getter MethodDefinition getter = definition.declareMethod(a(PUBLIC), stateField.getGetterName(), type(stateField.getType())); getter.getBody() .append(getter.getThis().getField(field).ret()); // Generate setter Parameter value = arg("value", stateField.getType()); MethodDefinition setter = definition.declareMethod(a(PUBLIC), stateField.getSetterName(), type(void.class), value); setter.getBody() .append(setter.getThis().setField(field, value)) .ret(); constructor.getBody() .append(constructor.getThis().setField(field, stateField.initialValueExpression())); }
private static void generateConstructor( ClassDefinition classDefinition, CachedInstanceBinder cachedInstanceBinder, Map<LambdaDefinitionExpression, CompiledLambda> compiledLambdaMap, Consumer<MethodDefinition> additionalStatements) { MethodDefinition constructorDefinition = classDefinition.declareConstructor(a(PUBLIC)); BytecodeBlock body = constructorDefinition.getBody(); Variable thisVariable = constructorDefinition.getThis(); body.comment("super();") .append(thisVariable) .invokeConstructor(Object.class); additionalStatements.accept(constructorDefinition); cachedInstanceBinder.generateInitializations(thisVariable, body); body.ret(); }
ClassDefinition classDefinition = new ClassDefinition( a(PUBLIC, FINAL), makeClassName("PagesHashStrategy"), FieldDefinition sizeField = classDefinition.declareField(a(PRIVATE, FINAL), "size", type(long.class)); List<FieldDefinition> channelFields = new ArrayList<>(); for (int i = 0; i < types.size(); i++) { FieldDefinition channelField = classDefinition.declareField(a(PRIVATE, FINAL), "channel_" + i, type(List.class, Block.class)); channelFields.add(channelField); for (int i = 0; i < joinChannels.size(); i++) { joinChannelTypes.add(types.get(joinChannels.get(i))); FieldDefinition channelField = classDefinition.declareField(a(PRIVATE, FINAL), "joinChannel_" + i, type(List.class, Block.class)); joinChannelFields.add(channelField); FieldDefinition hashChannelField = classDefinition.declareField(a(PRIVATE, FINAL), "hashChannel", type(List.class, Block.class));
for (AnnotationDefinition annotationDefinition : classDefinition.getAnnotations()) { visitAnnotation(classDefinition, annotationDefinition); Line classDeclaration = line().addAll(classDefinition.getAccess()); if (!classDefinition.getAccess().contains(INTERFACE)) { classDeclaration.add("class"); classDeclaration.add(classDefinition.getType().getJavaClassName()); if (!classDefinition.getSuperClass().equals(type(Object.class))) { classDeclaration.add("extends").add(classDefinition.getSuperClass().getJavaClassName()); if (!classDefinition.getInterfaces().isEmpty()) { classDeclaration.add("implements"); for (ParameterizedType interfaceType : classDefinition.getInterfaces()) { classDeclaration.add(interfaceType.getJavaClassName()); for (FieldDefinition fieldDefinition : classDefinition.getFields()) { visitField(classDefinition, fieldDefinition); for (MethodDefinition methodDefinition : classDefinition.getMethods()) { visitMethod(classDefinition, methodDefinition); visitMethod(classDefinition, classDefinition.getClassInitializer());
public FieldDefinition getCachedInstance(MethodHandle methodHandle) { FieldDefinition field = classDefinition.declareField(a(PRIVATE, FINAL), "__cachedInstance" + nextId, methodHandle.type().returnType()); initializers.put(field, methodHandle); nextId++; return field; }
classDefinition.visit(fakeLineNumbers ? new AddFakeLineNumberClassVisitor(writer) : writer); classDefinition.visit(new TraceClassVisitor(null, new Textifier(), new PrintWriter(out))); throw new IllegalArgumentException("Error processing class definition:\n" + out, e); throw new CompilationException("Error compiling class: " + classDefinition.getName(), e); bytecodes.put(classDefinition.getType().getJavaClassName(), bytecode);
public static <T> Class<? extends T> defineClass(ClassDefinition classDefinition, Class<T> superType, DynamicClassLoader classLoader) { log.debug("Defining class: %s", classDefinition.getName()); return classGenerator(classLoader).defineClass(classDefinition, superType); } }
public static ClassInfoLoader createClassInfoLoader(Iterable<ClassDefinition> classDefinitions, ClassLoader classLoader) { ImmutableMap.Builder<ParameterizedType, ClassNode> classNodes = ImmutableMap.builder(); for (ClassDefinition classDefinition : classDefinitions) { ClassNode classNode = new ClassNode(); classDefinition.visit(classNode); classNodes.put(classDefinition.getType(), classNode); } return new ClassInfoLoader(classNodes.build(), ImmutableMap.of(), classLoader, true); }
private static <T> Class<? extends T> generateGroupedStateClass(Class<T> clazz, Map<String, Type> fieldTypes, DynamicClassLoader classLoader) ClassDefinition definition = new ClassDefinition( a(PUBLIC, FINAL), makeClassName("Grouped" + clazz.getSimpleName()), MethodDefinition constructor = definition.declareConstructor(a(PUBLIC)); constructor.getBody() .append(constructor.getThis()) MethodDefinition ensureCapacity = definition.declareMethod(a(PUBLIC), "ensureCapacity", type(void.class), arg("size", long.class)); MethodDefinition getEstimatedSize = definition.declareMethod(a(PUBLIC), "getEstimatedSize", type(long.class)); BytecodeBlock body = getEstimatedSize.getBody();
private static void generatePrepareFinal(ClassDefinition definition) { MethodDefinition method = definition.declareMethod( a(PUBLIC), "prepareFinal", type(void.class)); method.getBody().ret(); }