public static void addSerializableSupport(JDefinedClass jclass) { jclass._implements(Serializable.class); try { final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); final DataOutputStream dataOutputStream = new DataOutputStream(byteArrayOutputStream); processDefinedClassForSerializableSupport(jclass, dataOutputStream); dataOutputStream.flush(); final MessageDigest digest = MessageDigest.getInstance("SHA"); final byte[] digestBytes = digest.digest(byteArrayOutputStream.toByteArray()); long serialVersionUID = 0L; for (int i = Math.min(digestBytes.length, 8) - 1; i >= 0; i--) { serialVersionUID = serialVersionUID << 8 | digestBytes[i] & 0xff; } JFieldVar serialUIDField = jclass.field(JMod.PRIVATE | JMod.STATIC | JMod.FINAL, long.class, "serialVersionUID"); serialUIDField.init(JExpr.lit(serialVersionUID)); } catch (IOException exception) { throw new GenerationException("IOException while generating serialversionUID field while adding serializable support to class: " + jclass.fullName(), exception); } catch (NoSuchAlgorithmException exception) { throw new GenerationException("SHA algorithm not found when trying to generate serialversionUID field while adding serializable support to class: " + jclass.fullName(), exception); } } }
JFieldRef getOrAddNotFoundVar(JDefinedClass jclass) { jclass.field(PROTECTED | STATIC | FINAL, Object.class, NOT_FOUND_VALUE_FIELD, _new(jclass.owner()._ref(Object.class))); return jclass.staticRef(NOT_FOUND_VALUE_FIELD); }
private JFieldVar addValueField(JDefinedClass _enum, JType type) { JFieldVar valueField = _enum.field(JMod.PRIVATE | JMod.FINAL, type, VALUE_FIELD_NAME); JMethod constructor = _enum.constructor(JMod.PRIVATE); JVar valueParam = constructor.param(type, VALUE_FIELD_NAME); JBlock body = constructor.body(); body.assign(JExpr._this().ref(valueField), valueParam); return valueField; }
public void addCreator(JDefinedClass jclass) { JClass creatorType = jclass.owner().directClass("android.os.Parcelable.Creator").narrow(jclass); JDefinedClass creatorClass = jclass.owner().anonymousClass(creatorType); addCreateFromParcel(jclass, creatorClass); addNewArray(jclass, creatorClass); JFieldVar creatorField = jclass.field(JMod.PUBLIC | JMod.STATIC | JMod.FINAL, creatorType, "CREATOR"); creatorField.init(JExpr._new(creatorClass)); }
private JFieldVar addAdditionalPropertiesField(JDefinedClass jclass, JType propertyType) { JClass propertiesMapType = jclass.owner().ref(Map.class); propertiesMapType = propertiesMapType.narrow(jclass.owner().ref(String.class), propertyType.boxify()); JClass propertiesMapImplType = jclass.owner().ref(HashMap.class); propertiesMapImplType = propertiesMapImplType.narrow(jclass.owner().ref(String.class), propertyType.boxify()); JFieldVar field = jclass.field(JMod.PRIVATE, propertiesMapType, "additionalProperties"); ruleFactory.getAnnotator().additionalPropertiesField(field, jclass, "additionalProperties"); field.init(JExpr._new(propertiesMapImplType)); return field; }
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; }
JFieldVar field = jclass.field(accessModifier, propertyType, propertyName);
private JFieldVar createViewField(JClass type, String name) { int mod = appDetails.isAndroidAnnotations() || appDetails.isRoboguice() ? JMod.NONE : JMod.PRIVATE; JFieldVar field = jClass.field(mod, type, name); return field; }
private void createAndInitLocationsField() { // private String[] locations; locationsField = jClass.field(JMod.PRIVATE, ref.string().array(), "locations"); // locations = getResources().getStringArray(R.array.locations); JFieldRef rArrayLocations = ref.r().staticRef("array").ref("locations"); JInvocation getResources = JExpr.invoke("getResources"); JInvocation getStringArray = getResources.invoke("getStringArray").arg(rArrayLocations); afterViewsBody.assign(locationsField, getStringArray); }
private void addRestClient(JFieldVar textViewField) { // add annotated restClient field JFieldVar restClient = jClass.field(JMod.NONE, ref.ref(appDetails.getRestClientPackage()), "restClient"); restClient.annotate(ref.restService()); // add doSomethingElseOnUiThread method JMethod doSomethingElseOnUiThread = jClass.method(JMod.NONE, jCodeModel.VOID, "doSomethingElseOnUiThread"); doSomethingElseOnUiThread.annotate(ref.uithread()); JBlock body = doSomethingElseOnUiThread.body(); if (textViewField != null) { body.invoke(textViewField, "setText").arg("Hi!"); } else { body.directStatement("// do something on UIThread"); } // add doSomethingInBackground method JMethod doSomethingInBackground = jClass.method(JMod.NONE, jCodeModel.VOID, "doSomethingInBackground"); doSomethingInBackground.annotate(ref.background()); JBlock doSomethingInBackgroundBody = doSomethingInBackground.body(); doSomethingInBackgroundBody.invoke(restClient, "main"); doSomethingInBackgroundBody.invoke(doSomethingElseOnUiThread); }
public SingleMarshallingField(ClassOutlineImpl context, CPropertyInfo prop, CPropertyInfo core, String contextPath, boolean _final) { super(context, prop, core); this.contextPath = context.implClass.field(JMod.PUBLIC | JMod.STATIC | (_final ? JMod.FINAL : JMod.NONE), String.class, prop .getName(true) + "ContextPath", JExpr.lit(contextPath)); }
public JVar declareClassField(String prefix, JType t, JExpression init) { if (innerClassGenerator != null && hasMaxIndexValue()) { return innerClassGenerator.declareClassField(prefix, t, init); } return clazz.field(JMod.NONE, t, prefix + index++, init); }
public JFieldVar field( int mods, Class type, String name, JExpression init) { return field(mods, owner()._ref(type), name, init); }
protected JFieldVar generateField() { // generate the constant JExpression value = createValue(); JFieldVar field = referenceClass.field(JMod.PUBLIC | JMod.STATIC | JMod.FINAL, type, propertyInfo.getPublicName(), value); annotate(field); return field; }
protected final void createField() { field = outline.implClass.field( JMod.PROTECTED, getFieldType(), prop.getName(false) ); annotate(field); }
protected final void createField() { field = outline.implClass.field( JMod.PROTECTED, getFieldType(), prop.getName(false) ); annotate(field); }
if (hasLocationsField) { locationsField = jClass.field(JMod.PRIVATE, ref.string().array(), "locations");
protected final void generate() { // for the collectionType customization to take effect, the field needs to be strongly typed, // not just List<Foo>. field = outline.implClass.field( JMod.PROTECTED, listT, prop.getName(false) ); if(eagerInstanciation) field.init(newCoreList()); annotate(field); // generate the rest of accessors generateAccessors(); }
JFieldVar labelTextField = jClass.field(appDetails.isAndroidAnnotations() || appDetails.isRoboguice() ? JMod.NONE : JMod.PRIVATE, ref.textView(), "labelText");
private void createReportingVectorClass(JCodeModel codeModel, String name, JPrimitiveType type) throws JClassAlreadyExistsException { JDefinedClass clazz = codeModel._class(JMod.ABSTRACT | JMod.PUBLIC, "org.jpmml.evaluator.Reporting" + name, ClassType.CLASS); clazz._extends(codeModel.ref("org.jpmml.evaluator." + name)); JFieldVar expressionField = clazz.field(JMod.PRIVATE, String.class, "expression", JExpr.lit("")); createNewReportMethod(clazz); createOperationMethods(clazz, name, type); createValueMethods(clazz, type); createReportMethod(clazz); createAccessorMethods(clazz, expressionField); }