case BOOLEAN:{ JConditional jc = block._if(returnValue.eq(JExpr._null())); jc._then().assign(returnValueHolder.ref("isSet"), JExpr.lit(0)); jc._else().assign(returnValueHolder.ref("isSet"), JExpr.lit(1)); JVar castedOI = jc._else().decl( m.directClass(BooleanObjectInspector.class.getCanonicalName()), "castOI", JExpr._null()); booleanJC._then().assign(returnValueHolder.ref("value"), JExpr.lit(1)); booleanJC._else().assign(returnValueHolder.ref("value"), JExpr.lit(0)); jc._then().assign(returnValueHolder.ref("isSet"), JExpr.lit(0)); jc._else().assign(returnValueHolder.ref("isSet"), JExpr.lit(1)); JVar castedOI = jc._else().decl( m.directClass(ByteObjectInspector.class.getCanonicalName()), "castOI", JExpr._null()); jc._else().assign(returnValueHolder.ref("value"), castedOI.invoke("get").arg(returnValue)); return block; jc._then().assign(returnValueHolder.ref("isSet"), JExpr.lit(0)); jc._else().assign(returnValueHolder.ref("isSet"), JExpr.lit(1)); JVar castedOI = jc._else().decl( m.directClass(ShortObjectInspector.class.getCanonicalName()), "castOI", JExpr._null()); jc._else().assign(returnValueHolder.ref("value"), castedOI.invoke("get").arg(returnValue)); return block; jc._then().assign(returnValueHolder.ref("isSet"), JExpr.lit(0));
private JFieldVar addQuickLookupMap(JDefinedClass _enum, JType backingType) { JClass lookupType = _enum.owner().ref(Map.class).narrow(backingType.boxify(), _enum); JFieldVar lookupMap = _enum.field(JMod.PRIVATE | JMod.STATIC | JMod.FINAL, lookupType, "CONSTANTS"); JClass lookupImplType = _enum.owner().ref(HashMap.class).narrow(backingType.boxify(), _enum); lookupMap.init(JExpr._new(lookupImplType)); JForEach forEach = _enum.init().forEach(_enum, "c", JExpr.invoke("values")); JInvocation put = forEach.body().invoke(lookupMap, "put"); put.arg(forEach.var().ref("value")); put.arg(forEach.var()); return lookupMap; }
void assign(JVar $target, JBlock block, JExpression rhs) { block.assign($target.ref(field.getSimpleName().toString()), rhs); } }
@Override public JExpression f(final JVar param) { return param.ref(propertyName); } } : new F1<JExpression, JVar>() {
@Override public JExpression f(final JBlock block, final JVar instanceParam, final JVar valueParam) { block.assign(instanceParam.ref(propertyName), valueParam); return null; } };
@Override public JExpression f(final JBlock block, final JVar instanceParam, final JVar valueParam) { block.assign(instanceParam.ref(propertyName), valueParam); return null; } };
@Override public JExpression getValue(JVar entity) { return entity.ref(getName()); }
private HoldingContainer getHoldingContainer(ClassGenerator<?> generator, MajorType majorType, Function<DrillBuf, ? extends ValueHolder> function) { JType holderType = generator.getHolderType(majorType); Pair<Integer, JVar> depthVar = generator.declareClassConstField("const", holderType, function); JFieldRef outputSet = null; JVar var = depthVar.getValue(); if (majorType.getMode() == TypeProtos.DataMode.OPTIONAL) { outputSet = var.ref("isSet"); } return new HoldingContainer(majorType, var, var.ref("value"), outputSet); }
public HoldingContainer declare(CompleteType t, boolean includeNewInstance) { JType holderType = t.getHolderType(model); JVar var; if (includeNewInstance) { var = getEvalBlock().decl(holderType, "out" + index, JExpr._new(holderType)); } else { var = getEvalBlock().decl(holderType, "out" + index); } index++; return new HoldingContainer(t, var, var.ref("value"), var.ref("isSet")); }
private HoldingContainer renderConstantExpression(ClassGenerator<?> generator, HoldingContainer input) { JVar fieldValue = generator.declareClassField("constant", generator.getHolderType(input.getMajorType())); generator.getEvalBlock().assign(fieldValue, input.getHolder()); generator.getMappingSet().exitConstant(); return new HoldingContainer(input.getMajorType(), fieldValue, fieldValue.ref("value"), fieldValue.ref("isSet")) .setConstant(true); } }
private HoldingContainer renderConstantExpression(ClassGenerator<?> generator, HoldingContainer input) { JVar fieldValue = generator.declareClassField("constant", input.getCompleteType().getHolderType(generator.getModel())); generator.getEvalBlock().assign(fieldValue, input.getHolder()); generator.getMappingSet().exitConstant(); return new HoldingContainer(input.getCompleteType(), fieldValue, fieldValue.ref("value"), fieldValue.ref("isSet")) .setConstant(true); } }
private void buildFieldGet(ASTType returnType, ASTType variableType, String name, String accessorMethodName, JDefinedClass helperClass) { JClass returnTypeRef = generationUtil.narrowRef(returnType); //get, ClassName, FG, fieldName JMethod accessorMethod = helperClass.method(JMod.PUBLIC | JMod.STATIC, returnTypeRef, accessorMethodName); JClass variableTypeRef = generationUtil.ref(variableType); JVar variableParam = accessorMethod.param(variableTypeRef, namer.generateName(variableTypeRef)); JBlock body = accessorMethod.body(); body._return(variableParam.ref(name)); }
@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 public JExpression f(final JBlock block, final JVar instanceParam, final JVar valueParam) { return JExpr.assign(instanceParam.ref(propertyName), JExpr._new(jaxbElementClass).arg(JExpr._this().ref("schemaName")).arg(propertyType._extends().dotclass()).arg(valueParam)); } };
private void buildFieldSet(FieldReference fieldReference, String accessorMethodName, JDefinedClass helperClass) { //get, ClassName, FS, fieldName JMethod accessorMethod = helperClass.method(JMod.PUBLIC | JMod.STATIC, codeModel.VOID, accessorMethodName); JClass containerType = generationUtil.ref(fieldReference.getVariableType()); JVar containerParam = accessorMethod.param(containerType, namer.generateName(containerType)); JClass inputType = generationUtil.ref(fieldReference.getReturnType()); JVar inputParam = accessorMethod.param(inputType, namer.generateName(inputType)); JBlock body = accessorMethod.body(); body.assign(containerParam.ref(fieldReference.getName()), inputParam); }
static private void createFormatMethod(JDefinedClass clazz, JPrimitiveType type){ JCodeModel codeModel = clazz.owner(); JClass numberClazz = codeModel.ref(Number.class); JClass stringBuilderClazz = codeModel.ref(StringBuilder.class); JMethod method = clazz.method(JMod.STATIC | JMod.PRIVATE, String.class, "format"); JVar valuesParameter = method.varParam(numberClazz, "values"); JBlock body = method.body(); JVar sbVariable = body.decl(stringBuilderClazz, "sb", JExpr._new(stringBuilderClazz).arg(valuesParameter.ref("length").mul(JExpr.lit(32)))); JForEach forStatement = body.forEach(numberClazz, "value", valuesParameter); JBlock forBody = forStatement.body(); forBody.add(createReportInvocation(clazz, sbVariable, "${0}", Collections.singletonList(forStatement.var()), type)); body._return(sbVariable.invoke("toString")); }
private JFieldVar addQuickLookupMap(JDefinedClass _enum, JType backingType) { JClass lookupType = _enum.owner().ref(Map.class).narrow(backingType.boxify(), _enum); JFieldVar lookupMap = _enum.field(JMod.PRIVATE | JMod.STATIC | JMod.FINAL, lookupType, "CONSTANTS"); JClass lookupImplType = _enum.owner().ref(HashMap.class).narrow(backingType.boxify(), _enum); lookupMap.init(JExpr._new(lookupImplType)); JForEach forEach = _enum.init().forEach(_enum, "c", JExpr.invoke("values")); JInvocation put = forEach.body().invoke(lookupMap, "put"); put.arg(forEach.var().ref("value")); put.arg(forEach.var()); return lookupMap; }
private JFieldVar addQuickLookupMap(JDefinedClass _enum) { JClass lookupType = _enum.owner().ref(Map.class).narrow(_enum.owner().ref(String.class), _enum); JFieldVar lookupMap = _enum.field(JMod.PRIVATE | JMod.STATIC, lookupType, "constants"); JClass lookupImplType = _enum.owner().ref(HashMap.class).narrow(_enum.owner().ref(String.class), _enum); lookupMap.init(JExpr._new(lookupImplType)); JForEach forEach = _enum.init().forEach(_enum, "c", _enum.staticInvoke("values")); JInvocation put = forEach.body().invoke(lookupMap, "put"); put.arg(forEach.var().ref("value")); put.arg(forEach.var()); return lookupMap; }