Refine search
body.add(sb .invoke("append").arg(jclass.dotclass().invoke("getName")) .invoke("append").arg(JExpr.lit('@')) .invoke("append").arg( jclass.owner().ref(Integer.class).staticInvoke("toHexString").arg( jclass.owner().ref(System.class).staticInvoke("identityHashCode").arg(JExpr._this()))) JVar baseLength = body.decl(jclass.owner().INT, "baseLength", sb.invoke("length")); JBlock superToStringBlock = body._if(superString.ne(JExpr._null()))._then(); superString.invoke("indexOf").arg(JExpr.lit('['))); JVar contentEnd = superToStringBlock.decl(jclass.owner().INT, "contentEnd", superString.invoke("lastIndexOf").arg(JExpr.lit(']'))); contentStart.gte(JExpr.lit(0)).cand(contentEnd.gt(contentStart))); sb.invoke("append") .arg(superString) .arg(contentStart.plus(JExpr.lit(1))) superToStringInnerConditional._else().add(sb.invoke("append").arg(superString)); body._if(sb.invoke("length").gt(baseLength)) ._then().add(sb.invoke("append").arg(JExpr.lit(','))); body.add(sb.invoke("append").arg(fieldVar.name())); body.add(sb.invoke("append").arg(JExpr.lit('=')));
private void addOverrideBuilder(JDefinedClass thisJDefinedClass, JMethod parentBuilder, JVar parentParam) { if (thisJDefinedClass.getMethod(parentBuilder.name(), new JType[] {parentParam.type()}) == null) { JMethod builder = thisJDefinedClass.method(parentBuilder.mods().getValue(), thisJDefinedClass, parentBuilder.name()); builder.annotate(Override.class); JVar param = builder.param(parentParam.type(), parentParam.name()); JBlock body = builder.body(); body.invoke(JExpr._super(), parentBuilder).arg(param); body._return(JExpr._this()); } } }
private void addEquals(JDefinedClass jclass, JsonNode node) { Map<String, JFieldVar> fields = removeFieldsExcludedFromEqualsAndHashCode(jclass.fields(), node); JMethod equals = jclass.method(JMod.PUBLIC, boolean.class, "equals"); JVar otherObject = equals.param(Object.class, "other"); JBlock body = equals.body(); body._if(otherObject.eq(JExpr._this()))._then()._return(JExpr.TRUE); body._if(otherObject._instanceof(jclass).eq(JExpr.FALSE))._then()._return(JExpr.FALSE); JVar rhsVar = body.decl(jclass, "rhs").init(JExpr.cast(jclass, otherObject)); JExpression result = JExpr.lit(true); if (!jclass._extends().fullName().equals(Object.class.getName())) { result = result.cand(JExpr._super().invoke("equals").arg(rhsVar)); fieldEquals = jclass.owner().ref(Arrays.class).staticInvoke("equals").arg(thisFieldRef).arg(otherFieldRef); } else { fieldEquals = thisFieldRef.eq(otherFieldRef).cor( body._return(result); equals.annotate(Override.class);
private void addFactoryMethod(JDefinedClass _enum, JType backingType) { JFieldVar quickLookupMap = addQuickLookupMap(_enum, backingType); JMethod fromValue = _enum.method(JMod.PUBLIC | JMod.STATIC, _enum, "fromValue"); JVar valueParam = fromValue.param(backingType, "value"); JBlock body = fromValue.body(); JVar constant = body.decl(_enum, "constant"); constant.init(quickLookupMap.invoke("get").arg(valueParam)); JConditional _if = body._if(constant.eq(JExpr._null())); JInvocation illegalArgumentException = JExpr._new(_enum.owner().ref(IllegalArgumentException.class)); JExpression expr = valueParam; // if string no need to add "" if(!isString(backingType)){ expr = expr.plus(JExpr.lit("")); } illegalArgumentException.arg(expr); _if._then()._throw(illegalArgumentException); _if._else()._return(constant); ruleFactory.getAnnotator().enumCreatorMethod(_enum, fromValue); }
public void generateAccessors() { Accessor acc = create(JExpr._this()); JVar $idx,$value; JBlock body; body = $getAll.body(); $idx = writer.addParameter(codeModel.INT,"idx"); $get.body()._if(acc.ref(true).eq(JExpr._null()))._then() ._throw(JExpr._new(codeModel.ref(IndexOutOfBoundsException.class))); $get.body()._return(acc.ref(true).component($idx)); JVar $len = $setAll.body().decl(codeModel.INT,"len", $value.ref("length")); $setAll.body().assign( (JAssignmentTarget) acc.ref(true), castToImplTypeArray(JExpr.newArray( codeModel.ref(exposedType.erasure().fullName()), $len))); JVar $i = _for.init( codeModel.INT, "i", JExpr.lit(0) ); _for.test( JOp.lt($i,$len) ); _for.update( $i.incr() ); _for.body().assign(acc.ref(true).component($i), castToImplType(acc.box($value.component($i))));
@Override public void process(Element element, JCodeModel codeModel, EBeanHolder holder) { Classes classes = holder.classes(); String methodName = element.getSimpleName().toString(); ExecutableElement executableElement = (ExecutableElement) element; List<? extends VariableElement> parameters = executableElement.getParameters(); boolean hasViewParameter = parameters.size() == 1; List<JFieldRef> idsRefs = helper.extractAnnotationFieldRefs(holder, element, getTarget(), rClass.get(Res.ID), true); JDefinedClass onClickListenerClass = codeModel.anonymousClass(classes.VIEW_ON_CLICK_LISTENER); JMethod onClickMethod = onClickListenerClass.method(JMod.PUBLIC, codeModel.VOID, "onClick"); onClickMethod.annotate(Override.class); JVar onClickViewParam = onClickMethod.param(classes.VIEW, "view"); JExpression activityRef = holder.generatedClass.staticRef("this"); JInvocation clickCall = onClickMethod.body().invoke(activityRef, methodName); if (hasViewParameter) { clickCall.arg(onClickViewParam); } for (JFieldRef idRef : idsRefs) { JBlock block = holder.afterSetContentView.body().block(); JInvocation findViewById = invoke("findViewById"); JVar view = block.decl(classes.VIEW, "view", findViewById.arg(idRef)); block._if(view.ne(_null()))._then().invoke(view, "setOnClickListener").arg(_new(onClickListenerClass)); } }
for ( JMethod m : fieldOutline.parent()._package().objectFactory().methods() ) if ( m.name().equals( methodName ) && m.hasSignature( signature ) ) return fieldOutline.parent()._package().objectFactory().staticInvoke( m ); for ( JMethod m : fieldOutline.parent().implClass.methods() ) if ( m.name().equals( methodName ) && m.hasSignature( signature ) ) return JExpr.invoke( m ); "A deep copy of {@code array} or {@code null} if {@code array} is {@code null}." ); final JConditional arrayNotNull = body._if( a.ne( JExpr._null() ) ); final JVar copy = arrayNotNull._then().decl( arrayType, "copy", JExpr.newArray( itemType, a.ref( "length" ) ) ); final JForLoop forEachItem = arrayNotNull._then()._for(); final JVar i = forEachItem.init( fieldOutline.parent().parent().getCodeModel().INT, "i", a.ref( "length" ).minus( JExpr.lit( 1 ) ) ); forEachItem.test( i.gte( JExpr.lit( 0 ) ) ); forEachItem.update( i.decr() ); fieldOutline, array.getItemType(), forEachItem.body(), a.component( i ), true ); forEachItem.body().assign( copy.component( i ), copyExpr ); arrayNotNull._then()._return( copy ); body._return( JExpr._null() );
JBlock sub = new JBlock(true, true); sub.assign(workspaceJVars[3].component(JExpr.lit(i)), workspaceJVars[2].component(JExpr.lit(i))); JBlock conditionalBlock = new JBlock(false, false); JConditional jc = conditionalBlock._if(inputVariables[i].getIsSet().ne(JExpr.lit(0))); jc._then().assign(JExpr.ref(workspaceJVars[3].component(JExpr.lit(i)), "valueHolder"), inputVariables[i].getHolder()); jc._else().assign(JExpr.ref(workspaceJVars[3].component(JExpr.lit(i)), "valueHolder"), JExpr._null()); sub.add(conditionalBlock); } else { sub.assign(workspaceJVars[3].component(JExpr.lit(i)), workspaceJVars[2].component(JExpr.lit(i))); sub.assign(JExpr.ref(workspaceJVars[3].component(JExpr.lit(i)), "valueHolder"), inputVariables[i].getHolder()); JVar retVal = sub.decl(m._ref(Object.class), "ret"); JTryBlock udfEvalTry = sub._try(); udfEvalTry.body().assign(retVal, workspaceJVars[1].invoke("evaluate").arg(workspaceJVars[3])); JCatchBlock udfEvalCatch = udfEvalTry._catch(m.directClass(Exception.class.getCanonicalName())); JVar exVar = udfEvalCatch.param("ex"); udfEvalCatch.body() ._throw(JExpr._new(m.directClass(RuntimeException.class.getCanonicalName())) .arg(JExpr.lit(String.format("GenericUDF.evaluate method failed"))).arg(exVar));
private void createAsPrismContainerValue(JDefinedClass definedClass, JVar containerValueVar) { JMethod getContainer = definedClass.method(JMod.PUBLIC, CLASS_MAP.get(PrismContainerValue.class), METHOD_AS_PRISM_CONTAINER_VALUE); // getContainer.annotate(CLASS_MAP.get(XmlTransient.class)); //create method body JBlock body = getContainer.body(); body._if(containerValueVar.eq(JExpr._null())). // if (_containerValue == null) { _then() // .assign(containerValueVar, // _containerValue = JExpr._new(CLASS_MAP.get(PrismContainerValueImpl.class).narrow(new JClass[0])) // new PrismContainerValueImpl<>( .arg(JExpr._this()) // this) ); body._return(containerValueVar); }
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()")) ) ); } } }
private void generateCurieMethod(JCodeModel model, JDefinedClass dc, JVar mapField) { JClass stringBuilderClass = model.ref(StringBuilder.class); JClass namespaceClass = model.ref(Namespace.class); JMethod method = dc.method(JMod.PUBLIC | JMod.STATIC, String.class, "curie"); JVar uriVar = method.param(URI.class, "uri"); JVar nsVar = method.body().decl(namespaceClass, "ns", mapField.invoke("get").arg(uriVar.invoke("getNamespace"))); method.body()._if(JOp.eq(nsVar, JExpr._null()))._then()._return(uriVar.invoke("stringValue")); JVar builderVar = method.body().decl(stringBuilderClass, "builder", JExpr._new(stringBuilderClass)); method.body().add(builderVar.invoke("add").arg(nsVar.invoke("getPrefix"))); method.body().add(builderVar.invoke("add").arg(JExpr.lit(':'))); method.body().add(builderVar.invoke("add").arg(uriVar.invoke("getLocalName"))); method.body()._return(builderVar.invoke("toString")); }
private JMethod addListMethod(final JDefinedClass definedClass, final Field field, final String listMethodName, final String parameterName) { final JClass fieldClass = toJavaClass(field); final StringBuilder builder = new StringBuilder(parameterName); builder.append(WordUtils.capitalize(field.getName())); final JMethod method = definedClass.method(JMod.PUBLIC, void.class, builder.toString()); final JVar adderParam = method.param(fieldClass, parameterName); final JBlock body = method.body(); final JVar decl = body.decl(getModel().ref(List.class), field.getName(), JExpr.invoke(getGetterName(field))); body.add(decl.invoke(listMethodName).arg(adderParam)); return method; }
switch(poi.getPrimitiveCategory()) { 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()); jc._else().assign(castedOI, JExpr.cast(m.directClass(BooleanObjectInspector.class.getCanonicalName()), returnOI)); JConditional booleanJC = jc._else()._if(castedOI.invoke("get").arg(returnValue)); booleanJC._then().assign(returnValueHolder.ref("value"), JExpr.lit(1)); booleanJC._else().assign(returnValueHolder.ref("value"), JExpr.lit(0)); 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(ByteObjectInspector.class.getCanonicalName()), "castOI", JExpr._null()); jc._else().assign(returnValueHolder.ref("value"), castedOI.invoke("get").arg(returnValue)); return block; 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)); jc._else().assign(returnValueHolder.ref("value"),
private void generateSetup(ClassGenerator<?> g, JVar[] workspaceJVars) { JCodeModel m = g.getModel(); JBlock sub = new JBlock(true, true); JVar oiArray = sub.decl( m._ref(ObjectInspector[].class), "argOIs", JExpr.newArray(m._ref(ObjectInspector.class), argTypes.length)); JClass oih = m.directClass(ObjectInspectorHelper.class.getCanonicalName()); JClass mt = m.directClass(TypeProtos.MinorType.class.getCanonicalName()); JClass mode = m.directClass(DataMode.class.getCanonicalName()); for(int i=0; i<argTypes.length; i++) { sub.assign( oiArray.component(JExpr.lit(i)), oih.staticInvoke("getDrillObjectInspector") .arg(mode.staticInvoke("valueOf").arg(JExpr.lit(argTypes[i].getMode().getNumber()))) .arg(mt.staticInvoke("valueOf").arg(JExpr.lit(argTypes[i].getMinorType().getNumber()))) .arg((((PrimitiveObjectInspector) returnOI).getPrimitiveCategory() == PrimitiveObjectInspector.PrimitiveCategory.STRING) ? JExpr.lit(true) : JExpr.lit(false))); sub.assign( workspaceJVars[2].component(JExpr.lit(i)), JExpr._new(m.directClass(DrillDeferredObject.class.getCanonicalName()))); udfInitTry.body().assign( workspaceJVars[0], workspaceJVars[1].invoke("initialize") .arg(oiArray));
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; }
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")); }
static private void createCopyMethod(JDefinedClass clazz){ JCodeModel codeModel = clazz.owner(); JClass reportClazz = codeModel.ref("org.jpmml.evaluator.Report"); JMethod method = clazz.method(JMod.PUBLIC, clazz, "copy"); method.annotate(Override.class); JBlock body = method.body(); JVar reportVariable = body.decl(reportClazz, "report", JExpr.invoke("getReport")); body._return(JExpr._new(clazz).arg(JExpr._super().ref("value")).arg(reportVariable.invoke("copy")).arg(JExpr._null())); }
private void addTabNavigationConfiguration(JBlock configureActionBarBody) { jClass._implements(ref.sTabListener()); JMethod onTabSelectedMethod = jClass.method(JMod.PUBLIC, jCodeModel.VOID, "onTabSelected"); JVar tabParam = onTabSelectedMethod.param(ref.sTab(), "tab"); onTabSelectedMethod.param(ref.fragmentTransaction(), "ft"); onTabSelectedMethod.annotate(ref.override()); JBlock onTabSelectedBody = onTabSelectedMethod.body(); JVar positionVar = onTabSelectedBody.decl(jCodeModel.INT, "position", tabParam.invoke("getPosition")); onTabSelectedBody.invoke(pagerField, "setCurrentItem").arg(positionVar); jClass.direct("@Override\n " + // "public void onTabUnselected(Tab tab, FragmentTransaction ft) {}"); "public void onTabReselected(Tab tab, FragmentTransaction ft) {}"); JInvocation getSupportActionBar = JExpr.invoke("getSupportActionBar"); configureActionBarBody.invoke(getSupportActionBar, "setNavigationMode").arg(navigationModeList); JForEach forEachLocation = configureActionBarBody.forEach(ref.string(), "location", locationsField);
JClass vvClass = model.ref(valueVectorClass); JClass retClass = vvClass; String vectorAccess = "getValueVector"; JClass t = model.ref(SchemaChangeException.class); JType objClass = model.ref(Object.class); JBlock b = getSetupBlock(); JVar fieldArr = b.decl(model.INT.array(), "fieldIds" + index++, JExpr.newArray(model.INT, fieldId.getFieldIds().length)); int[] fieldIndices = fieldId.getFieldIds(); for (int i = 0; i < fieldIndices.length; i++) { b.assign(fieldArr.component(JExpr.lit(i)), JExpr.lit(fieldIndices[i])); .arg(vvClass.dotclass()) .arg(fieldArr); JVar obj = b.decl( objClass, getNextVar("tmp"), invoke.invoke(vectorAccess)); b._if(obj.eq(JExpr._null()))._then()._throw(JExpr._new(t).arg(JExpr.lit(String.format("Failure while loading vector %s with id: %s.", vv.name(), fieldId.toString())))); b.assign(vv, JExpr.cast(retClass, obj));
protected void addQueryParameters(final JMethod method, final JBlock body, final JClass mapClass, final JClass hashMapClass, final JVar commandParametersRef) { if (!method.params().isEmpty()) { final JVar queryParametersRef = body.decl(mapClass, "queryParameters", JExpr._new(hashMapClass)); for (final JVar param : method.params()) { if (!FORBIDDEN_PARAMETER_NAMES.contains(param.name())) { body.invoke(queryParametersRef, "put").arg(JExpr.lit(param.name())).arg(param); } } body.invoke(commandParametersRef, "put").arg(JExpr.lit("queryParameters")).arg(JExpr.cast(getModel().ref(Serializable.class), queryParametersRef)); } }