private void addNewArray(JDefinedClass jclass, JDefinedClass creatorClass) { JMethod newArray = creatorClass.method(JMod.PUBLIC, jclass.array(), "newArray"); newArray.param(int.class, "size"); newArray.body()._return(JExpr.direct("new " + jclass.name() + "[size]")); }
public void addConstructorFromParcel(JDefinedClass jclass) { JMethod ctorFromParcel = jclass.constructor(JMod.PROTECTED); JVar in = ctorFromParcel.param(jclass.owner().directClass("android.os.Parcel"), "in"); if (extendsParcelable(jclass)) { ctorFromParcel.body().directStatement("super(in);"); } for (JFieldVar f : jclass.fields().values()) { if( (f.mods().getValue() & JMod.STATIC) == JMod.STATIC ) { continue; } if (f.type().erasure().name().equals("List")) { ctorFromParcel.body() .invoke(in, "readList") .arg(JExpr._this().ref(f)) .arg(JExpr.direct(getListType(f.type()) + ".class.getClassLoader()")); } else { ctorFromParcel.body().assign( JExpr._this().ref(f), JExpr.cast( f.type(), in.invoke("readValue").arg(JExpr.direct(f.type().erasure().name() + ".class.getClassLoader()")) ) ); } } }
static private JAnnotationUse annotate(JCodeModel codeModel, JAnnotatable owner, CPluginCustomization customization){ String content = (customization.element).getTextContent(); Matcher matcher = AnnotatePlugin.PATTERN.matcher(content); if(matcher.matches()){ JClass annotationClass = codeModel.ref(matcher.group(1)); return owner.annotate(annotationClass) .param("value", JExpr.direct(matcher.group(2))); } else { JClass annotationClass = codeModel.ref(content); return owner.annotate(annotationClass); } }
public JVar asString() { JVar var = method.body().decl(model._ref(String.class), "value", JExpr.direct("_attValue")); return var; }
JExpression rLayoutSherlockSpinner = JExpr.direct("android.R.layout.simple_list_item_1");
private JMethod addAddMethod(JDefinedClass builderClass, FieldOutline field) { List<JClass> typeParams = ((JClass) getJavaType(field)).getTypeParameters(); if (!typeParams.iterator().hasNext()) { return null; } JMethod method = builderClass.method(JMod.PUBLIC, builderClass, "add" + field.getPropertyInfo().getName(true)); JBlock block = method.body(); String fieldName = field.getPropertyInfo().getName(false); JVar param = method.param(JMod.FINAL, typeParams.iterator().next(), fieldName); JInvocation invocation = JExpr.refthis(fieldName).invoke("add").arg(param); block.add(invocation); block._return(JExpr.direct("this")); return method; }
private JMethod addWithMethod(JDefinedClass builderClass, FieldOutline field) { String fieldName = field.getPropertyInfo().getName(true); JMethod method = builderClass.method(JMod.PUBLIC, builderClass, "with" + fieldName); generatePropertyAssignment(method, field); method.body()._return(JExpr.direct("this")); return method; }
private JVar createVar( Class<?> cls, Class parser) { JClass jcls = (JClass) model._ref(parser); return method.body().decl(model._ref(cls), "value", jcls.staticInvoke("valueOf").arg(JExpr.direct("_attValue"))); }
private void addNewArray(JDefinedClass jclass, JDefinedClass creatorClass) { JMethod newArray = creatorClass.method(JMod.PUBLIC, jclass.array(), "newArray"); newArray.param(int.class, "size"); newArray.body()._return(JExpr.direct("new " + jclass.name() + "[size]")); }
static private void createValueMethods(JDefinedClass clazz, JPrimitiveType type){ JCodeModel codeModel = clazz.owner(); if((codeModel.DOUBLE).equals(type)){ JClass valueClazz = codeModel.ref("org.jpmml.evaluator.ReportingDoubleValue"); createGetMethod(clazz, valueClazz, JExpr.direct("doubleValue(index)")); createAggregationMethod(clazz, valueClazz, "max", JExpr.invoke("doubleMax"), "<apply><max/>${this}</apply>", type); createAggregationMethod(clazz, valueClazz, "median", JExpr.invoke("doubleMedian"), "<apply><median/>${this}</apply>", type); createAggregationMethod(clazz, valueClazz, "sum", JExpr.invoke("doubleSum"), "<apply><plus/>${this}</apply>", type); } else if((codeModel.FLOAT).equals(type)){ JClass valueClazz = codeModel.ref("org.jpmml.evaluator.ReportingFloatValue"); createGetMethod(clazz, valueClazz, JExpr.direct("floatValue(index)")); createAggregationMethod(clazz, valueClazz, "max", JExpr.invoke("floatMax"), "<apply><max/>${this}</apply>", type); createAggregationMethod(clazz, valueClazz, "median", JExpr.invoke("floatMedian"), "<apply><median/>${this}</apply>", type); createAggregationMethod(clazz, valueClazz, "sum", JExpr.invoke("floatSum"), "<apply><plus/>${this}</apply>", type); } else { throw new RuntimeException(); } }
@Override void generateCode(ClassGenerator<WindowFramer> cg) { final GeneratorMapping mapping = GeneratorMapping.create("setupPartition", "outputRow", "resetValues", "cleanup"); final MappingSet mappingSet = new MappingSet(null, "outIndex", mapping, mapping); cg.setMappingSet(mappingSet); final JVar vv = cg.declareVectorValueSetupAndMember(cg.getMappingSet().getOutgoing(), fieldId); final JExpression outIndex = cg.getMappingSet().getValueWriteIndex(); JInvocation setMethod = vv.invoke("setSafe").arg(outIndex) .arg(JExpr.direct("partition.ntile(" + numTiles + ")")); cg.getEvalBlock().add(setMethod); } }
public Sizer(Generator generator, String className) throws JClassAlreadyExistsException { cm = generator.getCm(); this.generator = generator; definedClass = cm._class(className, ClassType.INTERFACE); generator.registry().cls().field(JMod.PROTECTED | JMod.FINAL | JMod.STATIC, cls(), "SIZER", JExpr.direct("AMQPSizer.instance()")); JMethod singletonAccessor = generator.registry().cls().method(JMod.PUBLIC, cls(), "sizer"); singletonAccessor.body()._return(JExpr.ref("SIZER")); }
public EncodingPicker(Generator generator, String className) throws JClassAlreadyExistsException { cm = generator.getCm(); this.generator = generator; definedClass = cm._class(className, ClassType.INTERFACE); generator.registry().cls().field(JMod.PROTECTED | JMod.FINAL | JMod.STATIC, cls(), "PICKER", JExpr.direct("AMQPEncodingPicker.instance()")); JMethod singletonAccessor = generator.registry().cls().method(JMod.PUBLIC, cls(), "picker"); singletonAccessor.body()._return(JExpr.ref("PICKER")); }
@Override void generateCode(ClassGenerator<WindowFramer> cg) { final GeneratorMapping mapping = GeneratorMapping.create("setupPartition", "outputRow", "resetValues", "cleanup"); final MappingSet mappingSet = new MappingSet(null, "outIndex", mapping, mapping); cg.setMappingSet(mappingSet); final JVar vv = cg.declareVectorValueSetupAndMember(cg.getMappingSet().getOutgoing(), fieldId); final JExpression outIndex = cg.getMappingSet().getValueWriteIndex(); JInvocation setMethod = vv.invoke("setSafe").arg(outIndex).arg(JExpr.direct("partition." + getName())); cg.getEvalBlock().add(setMethod); }
@Override void generateCode(ClassGenerator<WindowFramer> cg) { final GeneratorMapping mapping = GeneratorMapping.create("setupPartition", "outputRow", "resetValues", "cleanup"); final MappingSet mappingSet = new MappingSet(null, "outIndex", mapping, mapping); cg.setMappingSet(mappingSet); final JVar vv = cg.declareVectorValueSetupAndMember(cg.getMappingSet().getOutgoing(), fieldId); final JExpression outIndex = cg.getMappingSet().getValueWriteIndex(); JInvocation setMethod = vv.invoke("getMutator").invoke("setSafe").arg(outIndex) .arg(JExpr.direct("partition.ntile(" + numTiles + ")")); cg.getEvalBlock().add(setMethod); } }
@Override public HoldingContainer visitQuotedStringConstant(QuotedString e, ClassGenerator<?> generator) throws RuntimeException { CompleteType completeType = CompleteType.VARCHAR; JBlock setup = generator.getBlock(BlockType.SETUP); JType holderType = completeType.getHolderType(generator.getModel()); JVar var = generator.declareClassField("string", holderType); JExpression stringLiteral = JExpr.lit(e.value); JExpression buffer = JExpr.direct("context").invoke("getManagedBuffer"); setup.assign(var, generator.getModel().ref(ValueHolderHelper.class).staticInvoke("getNullableVarCharHolder").arg(buffer).arg(stringLiteral)); return new HoldingContainer((completeType), var, var.ref("value"), var.ref("isSet")); }
@Override void generateCode(ClassGenerator<WindowFramer> cg) { final GeneratorMapping mapping = GeneratorMapping.create("setupPartition", "outputRow", "resetValues", "cleanup"); final MappingSet mappingSet = new MappingSet(null, "outIndex", mapping, mapping); cg.setMappingSet(mappingSet); final JVar vv = cg.declareVectorValueSetupAndMember(cg.getMappingSet().getOutgoing(), fieldId); final JExpression outIndex = cg.getMappingSet().getValueWriteIndex(); JInvocation setMethod = vv.invoke("getMutator").invoke("setSafe").arg(outIndex).arg(JExpr.direct("partition." + getName())); cg.getEvalBlock().add(setMethod); }
private JMethod addWithIfNotNullMethod(JDefinedClass builderClass, FieldOutline field, JMethod unconditionalWithMethod) { if (field.getRawType().isPrimitive()) return null; String fieldName = field.getPropertyInfo().getName(true); JMethod method = builderClass.method(JMod.PUBLIC, builderClass, "with" + fieldName + "IfNotNull"); JVar param = generateMethodParameter(method, field); JBlock block = method.body(); JConditional conditional = block._if(param.eq(JExpr._null())); conditional._then()._return(JExpr.direct("this")); conditional._else()._return(JExpr.invoke(unconditionalWithMethod).arg(param)); return method; }
public void init() throws JClassAlreadyExistsException { typeRegistry = cm._class(typeRegistryName); typeRegistry.field(JMod.PUBLIC | JMod.FINAL | JMod.STATIC, cm.BYTE, "DESCRIBED_FORMAT_CODE", JExpr.direct("0x00")); typeRegistry.field(JMod.PUBLIC | JMod.FINAL | JMod.STATIC, cm.BYTE, "NULL_FORMAT_CODE", JExpr.direct("0x40")); JFieldVar singleton = typeRegistry.field(JMod.PROTECTED | JMod.FINAL | JMod.STATIC, (JType) typeRegistry, "SINGLETON", JExpr._new(typeRegistry)); JFieldVar primitiveFormatCodeMap = typeRegistry.field(JMod.PROTECTED | JMod.FINAL, mapByteClass, "primitiveFormatCodeMap", JExpr._new(hashMapByteClass)); JFieldVar formatCodeMap = typeRegistry.field(JMod.PROTECTED | JMod.FINAL, mapLongClass, "formatCodeMap", JExpr._new(hashMapLongClass)); JFieldVar symbolicCodeMap = typeRegistry.field(JMod.PROTECTED | JMod.FINAL, mapBufferClass, "symbolicCodeMap", JExpr._new(hashMapBufferClass)); JMethod singletonAccessor = typeRegistry.method(JMod.PUBLIC | JMod.STATIC, typeRegistry, "instance"); singletonAccessor.body()._return(JExpr.ref("SINGLETON")); JMethod formatCodeMapGetter = typeRegistry.method(JMod.PUBLIC, mapLongClass, "getFormatCodeMap"); formatCodeMapGetter.body()._return(JExpr.ref("formatCodeMap")); JMethod symbolicCodeMapGetter = typeRegistry.method(JMod.PUBLIC, mapBufferClass, "getSymbolicCodeMap"); symbolicCodeMapGetter.body()._return(JExpr.ref("symbolicCodeMap")); JMethod primitiveFormatCodeGetter = typeRegistry.method(JMod.PUBLIC, mapByteClass, "getPrimitiveFormatCodeMap"); primitiveFormatCodeGetter.body()._return(JExpr.ref("primitiveFormatCodeMap")); }
private List<Partitioner> createClassInstances(int actualPartitions) throws SchemaChangeException { // set up partitioning function final LogicalExpression expr = config.getExpr(); final ClassGenerator<Partitioner> cg = context.getClassProducer().createGenerator(Partitioner.TEMPLATE_DEFINITION).getRoot(); ClassGenerator<Partitioner> cgInner = cg.getInnerGenerator("OutgoingRecordBatch"); final LogicalExpression materializedExpr = context.getClassProducer().materialize(expr, incoming); // generate code to copy from an incoming value vector to the destination partition's outgoing value vector JExpression bucket = JExpr.direct("bucket"); // generate evaluate expression to determine the hash ClassGenerator.HoldingContainer exprHolder = cg.addExpr(materializedExpr); cg.getEvalBlock().decl(JType.parse(cg.getModel(), "int"), "bucket", exprHolder.getValue().mod(JExpr.lit(outGoingBatchCount))); cg.getEvalBlock()._return(cg.getModel().ref(Math.class).staticInvoke("abs").arg(bucket)); CopyUtil.generateCopies(cgInner, incoming, incoming.getSchema().getSelectionVectorMode() == SelectionVectorMode.FOUR_BYTE); // compile and setup generated code List<Partitioner> subPartitioners = cg.getCodeGenerator().getImplementationClass(actualPartitions); return subPartitioners; }