Refine search
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 void addEquals(JDefinedClass jclass, JsonNode node) { Map<String, JFieldVar> fields = removeFieldsExcludedFromEqualsAndHashCode(jclass.fields(), node); JBlock body = equals.body(); 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)); JClass doubleClass = jclass.owner().ref(Double.class); fieldEquals = doubleClass.staticInvoke("doubleToLongBits").arg(thisFieldRef).eq( doubleClass.staticInvoke("doubleToLongBits").arg(otherFieldRef)); } else if ("float".equals(fieldVar.type().name())) { JClass floatClass = jclass.owner().ref(Float.class); fieldEquals = floatClass.staticInvoke("floatToIntBits").arg(thisFieldRef).eq( floatClass.staticInvoke("floatToIntBits").arg(otherFieldRef)); } else { fieldEquals = thisFieldRef.eq(otherFieldRef); 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);
public static JBlock getDrillObject(JCodeModel m, ObjectInspector oi, JVar returnOI, JVar returnValueHolder, JVar returnValue) { JBlock block = new JBlock(false, false); switch(oi.getCategory()) { case PRIMITIVE: { 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)); m.directClass(ByteObjectInspector.class.getCanonicalName()), "castOI", JExpr._null()); castedOI.invoke("get").arg(returnValue)); return block; castedOI.invoke("get").arg(returnValue)); return block; .arg(m.directClass(org.joda.time.DateTimeZone.class.getCanonicalName()).staticRef("UTC")).invoke("getMillis")); return block;
private boolean extendsParcelable(final JDefinedClass jclass) { final java.util.Iterator<JClass> interfaces = jclass._extends() != null ? jclass._extends()._implements() : null; if (interfaces != null) { while (interfaces.hasNext()) { final JClass iface = interfaces.next(); if (iface.erasure().name().equals("Parcelable")) { return true; } } } return false; }
JClass listGenericType = ((JClass) fieldType).getTypeParameters().get(0); JClass listImplClass = fieldType.owner().ref(ArrayList.class); listImplClass = listImplClass.narrow(listGenericType); JInvocation newListImpl = JExpr._new(listImplClass); JInvocation invokeAsList = fieldType.owner().ref(Arrays.class).staticInvoke("asList"); for (JsonNode defaultValue : node) { invokeAsList.arg(getDefaultValue(listGenericType, defaultValue)); newListImpl.arg(invokeAsList); } else if (!ruleFactory.getGenerationConfig().isInitializeCollections()) { return JExpr._null();
JBlock body = toString.body(); JClass stringBuilderClass = jclass.owner().ref(StringBuilder.class); JVar sb = body.decl(stringBuilderClass, "sb", JExpr._new(stringBuilderClass)); 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()))) .invoke("append").arg(JExpr.lit('['))); if (!jclass._extends().fullName().equals(Object.class.getName())) { JVar baseLength = body.decl(jclass.owner().INT, "baseLength", sb.invoke("length")); JVar superString = body.decl(jclass.owner().ref(String.class), "superString", JExpr._super().invoke("toString")); JExpr.refthis(fieldVar.name()).eq(JExpr._null()), JExpr.lit("<null>"), jclass.owner().ref(Arrays.class).staticInvoke("toString") .arg(JExpr.refthis(fieldVar.name())) .invoke("replace").arg(JExpr.lit('[')).arg(JExpr.lit('{')) body._return(sb.invoke("toString")); toString.annotate(Override.class);
private void addHashCode(JDefinedClass jclass, JsonNode node) { Map<String, JFieldVar> fields = removeFieldsExcludedFromEqualsAndHashCode(jclass.fields(), node); JFieldRef fieldRef = JExpr.refthis(fieldVar.name()); fieldHash = fieldRef; } else if ("double".equals(fieldVar.type().name())) { JClass doubleClass = jclass.owner().ref(Double.class); JExpression longField = doubleClass.staticInvoke("doubleToLongBits").arg(fieldRef); fieldHash = JExpr.cast(jclass.owner().INT, longField.xor(longField.shrz(JExpr.lit(32)))); } else if ("float".equals(fieldVar.type().name())) { fieldHash = jclass.owner().ref(Float.class).staticInvoke("floatToIntBits").arg(fieldRef); } else { fieldHash = JExpr.cast(jclass.owner().INT, fieldRef); fieldHash = jclass.owner().ref(Arrays.class).staticInvoke("hashCode").arg(fieldRef); } else { fieldHash = JOp.cond(fieldRef.eq(JExpr._null()), JExpr.lit(0), fieldRef.invoke("hashCode")); body.assign(result, result.mul(JExpr.lit(31)).plus(fieldHash)); if (!jclass._extends().fullName().equals(Object.class.getName())) { body.assign(result, result.mul(JExpr.lit(31)).plus(JExpr._super().invoke("hashCode"))); body._return(result); hashCode.annotate(Override.class);
private void addToString(JDefinedClass jclass) { JMethod toString = jclass.method(JMod.PUBLIC, String.class, "toString"); JBlock body = toString.body(); JInvocation reflectionToString = jclass.owner().ref(ToStringBuilder.class).staticInvoke("reflectionToString"); reflectionToString.arg(JExpr._this()); body._return(reflectionToString); toString.annotate(Override.class); }
private JMethod addPublicSetMethod(JDefinedClass jclass, JMethod internalSetMethod) { JMethod method = jclass.method(PUBLIC, jclass.owner().VOID, SETTER_NAME); JVar nameParam = method.param(String.class, "name"); JVar valueParam = method.param(Object.class, "value"); JBlock body = method.body(); JBlock notFound = body._if(JOp.not(invoke(internalSetMethod).arg(nameParam).arg(valueParam)))._then(); // if we have additional properties, then put value. JMethod getAdditionalProperties = jclass.getMethod("getAdditionalProperties", new JType[] {}); if (getAdditionalProperties != null) { JType additionalPropertiesType = ((JClass) (getAdditionalProperties.type())).getTypeParameters().get(1); notFound.add(invoke(getAdditionalProperties).invoke("put").arg(nameParam) .arg(cast(additionalPropertiesType, valueParam))); } // else throw exception. else { notFound._throw(illegalArgumentInvocation(jclass, nameParam)); } return method; }
private void addListNavigationConfiguration(JBlock configureActionBarBody) { jClass._implements(ref.sNavigationListener()); JBlock onNavigationItemSelectedBody = onNavigationItemSelectedMethod.body(); if (appDetails.isViewPager()) { onNavigationItemSelectedBody.invoke(pagerField, "setCurrentItem").arg(itemPositionParam); onNavigationItemSelectedBody._return(JExpr.TRUE); JFieldRef rArrayLocations = ref.r().staticRef("array").ref("locations"); JExpression rLayoutSherlockSpinner = JExpr.direct("android.R.layout.simple_list_item_1"); JInvocation createFromResource = arrayAdapter.staticInvoke("createFromResource"). // arg(contextVar). // arg(rArrayLocations). // arg(rLayoutSherlockSpinner); JClass listType = arrayAdapter.narrow(ref.charSequence()); JVar listVar = configureActionBarBody.decl(listType, "list", createFromResource); JFieldRef navigationModeList = ref.sActionBar().staticRef("NAVIGATION_MODE_LIST"); configureActionBarBody.invoke(getSupportActionbar, "setNavigationMode").arg(navigationModeList); configureActionBarBody.invoke(getSupportActionbar, "setListNavigationCallbacks").// arg(listVar).// arg(JExpr._this());
private JMethod generateLazyProxyInitGetter(final ClassOutline classOutline, final FieldOutline fieldOutline) { final JCodeModel m = classOutline.parent().getCodeModel(); final JDefinedClass definedClass = classOutline.implClass; final String fieldName = fieldOutline.getPropertyInfo().getName(false); final String getterName = "get" + fieldOutline.getPropertyInfo().getName(true); final JFieldVar collectionField = definedClass.fields().get(fieldName); final JClass elementType = ((JClass) collectionField.type()).getTypeParameters().get(0); final JClass proxyFieldType = m.ref(BoundList.class).narrow(elementType); final JFieldRef collectionFieldRef = JExpr._this().ref(collectionField); final JFieldRef proxyField = JExpr._this().ref(collectionField.name() + BoundPropertiesPlugin.PROXY_SUFFIX); final JMethod oldGetter = definedClass.getMethod(getterName, new JType[0]); definedClass.methods().remove(oldGetter); final JMethod newGetter = definedClass.method(JMod.PUBLIC, proxyFieldType, getterName); newGetter.body()._if(collectionFieldRef.eq(JExpr._null()))._then().assign(collectionFieldRef, JExpr._new(m.ref(ArrayList.class).narrow(elementType))); final JBlock ifProxyNull = newGetter.body()._if(proxyField.eq(JExpr._null()))._then(); ifProxyNull.assign(proxyField, JExpr._new(m.ref(BoundListProxy.class).narrow(elementType)).arg(collectionFieldRef)); newGetter.body()._return(proxyField); return newGetter; }
jClass = jCodeModel._class(appDetails.getSampleFragmentPackage()); jClass._extends(ref.ref(appDetails.getRoboSherlockFragmentPackage())); } else if (appDetails.isRoboguice()) { jClass._extends(ref.roboFragment()); } else { jClass._extends(ref.fragment()); if (appDetails.isAndroidAnnotations()) { jClass.annotate(ref.efragment()).param("value", ref.r().staticRef("layout").ref("fragment_sample")); JMethod onCreateViewMethod = jClass.method(JMod.NONE, jCodeModel.VOID, "afterViews"); onCreateViewMethod.annotate(ref.afterViews()); onCreateViewMethodBody = onCreateViewMethod.body(); JFieldRef field = ref.r().staticRef("id").ref("label_text"); injectViewAnnotation.param("value", field); onCreateViewMethodBody = onCreateViewMethod.body(); onCreateViewMethodBody._return(inflateView(inflaterParam, containerParam)); onViewCreatedMethodBody.invoke(JExpr._super(), "onViewCreated").arg(viewParam).arg(savedInstanceStateParam); JVar contentViewVar = onCreateViewMethodBody.decl(ref.view(), "contentView", inflateInvoke);
private void createFieldReferenceUseCreateItemBody(JFieldVar field, JMethod method) { JClass type = ((JClass) field.type()).getTypeParameters().get(0); JBlock body = method.body(); JExpression initExpr; initExpr = constructorExpression(method, type); JVar decl = body.decl(type, field.name(), initExpr); JInvocation invocation = body.invoke(decl, METHOD_SETUP_CONTAINER); invocation.arg(JExpr.invoke(method.listParams()[0], "getObject")); body._return(decl); }
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"); JFieldRef navigationModeList = ref.sActionBar().staticRef("NAVIGATION_MODE_TABS"); configureActionBarBody.invoke(getSupportActionBar, "setNavigationMode").arg(navigationModeList); JForEach forEachLocation = configureActionBarBody.forEach(ref.string(), "location", locationsField);
private static void generateQueryParamSetMethod(JDefinedClass derivedBuilderClass, ParameterSchema param, JClass paramClass, JClass paramItemsClass) { final String paramName = param.getName(); final boolean isOptional = RestLiToolsUtils.isParameterOptional(param); final String methodName = RestLiToolsUtils.nameCamelCase(paramName + "Param"); final JMethod setMethod = derivedBuilderClass.method(JMod.PUBLIC, derivedBuilderClass, methodName); final JVar setMethodParam = setMethod.param(paramClass, "value"); setMethod.body().add(JExpr._super().invoke(isOptional ? "setParam" : "setReqParam").arg(paramName).arg(setMethodParam).arg(paramItemsClass.dotclass())); setMethod.body()._return(JExpr._this()); generateParamJavadoc(setMethod, setMethodParam, param); }
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)));
private JMethod addGetter(JDefinedClass c, JFieldVar field, String jsonPropertyName, JsonNode node, boolean isRequired, boolean usesOptional) { JType type = getReturnType(c, field, isRequired, usesOptional); JMethod getter = c.method(JMod.PUBLIC, type, getGetterName(jsonPropertyName, field.type(), node)); JBlock body = getter.body(); if ((ruleFactory.getGenerationConfig().isUseOptionalForGetters() || usesOptional) && !isRequired && field.type().isReference()) { body._return(c.owner().ref("java.util.Optional").staticInvoke("ofNullable").arg(field)); } else { body._return(field); } return getter; }
@Override public List<JMethod> apply(JClass clazz, JClass superClazz){ String parameterName = NameConverter.standard.toVariableName((clazz.erasure()).name()); if(!JJavaName.isJavaIdentifier(parameterName)){ parameterName = ("_" + parameterName); } JMethod visitorVisit = visitorInterface.method(JMod.PUBLIC, visitorActionEnum, "visit"); visitorVisit.param(clazz, parameterName); JMethod abstractVisitorVisit = abstractVisitorClazz.method(JMod.PUBLIC, visitorActionEnum, "visit"); abstractVisitorVisit.annotate(Override.class); abstractVisitorVisit.param(clazz, parameterName); abstractVisitorVisit.body()._return(JExpr.invoke("visit").arg(JExpr.cast(superClazz.erasure(), JExpr.ref(parameterName)))); return Arrays.asList(visitorVisit, abstractVisitorVisit); } };
protected JMethod generate$HashCode0(ClassContext classContext, final ClassItem classItem) { final JCodeModel codeModel = getCodeModel(classContext); final JMethod hashCode0 = classContext.implClass.method(JMod.PUBLIC, codeModel.INT, "hashCode"); final JVar hashCodeStrategy = hashCode0.body().decl( JMod.FINAL, codeModel.ref(HashCodeStrategy.class), "hashCodeStrategy", codeModel.ref(JAXBHashCodeStrategy.class).staticRef("INSTANCE")); final JMethod hashCode2 = generate$HashCode2(classContext, classItem); hashCode0.body()._return( JExpr._this().invoke(hashCode2).arg(JExpr._null()).arg(hashCodeStrategy)); return hashCode0; }