Refine search
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; }
return JExpr._new(fieldType).arg(JExpr.lit(node.asText())); return JExpr._new(fieldType).arg(JExpr.lit(node.asText())); long millisecs = parseDateToMillisecs(node.asText()); JInvocation newDateTime = JExpr._new(fieldType); newDateTime.arg(JExpr.lit(millisecs)); JInvocation invokeCreate = fieldType.owner().ref(URI.class).staticInvoke("create"); return invokeCreate.arg(JExpr.lit(node.asText()));
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; }
itemType = ruleFactory.getSchemaRule().apply(makeSingular(nodeName), node.get("items"), node, jpackage, schema); } else { itemType = jpackage.owner().ref(Object.class); arrayType = jpackage.owner().ref(Set.class).narrow(itemType); } else { arrayType = jpackage.owner().ref(List.class).narrow(itemType);
protected JMethod generate$createCopy(final ClassOutline classOutline, final JDefinedClass theClass) { final JMethod createCopy = theClass.method(JMod.PUBLIC, theClass .owner().ref(Object.class), "createCopy"); { final JBlock body = createCopy.body(); body._return(JExpr._new(theClass)); } return createCopy; }
targetType = cm.ref(name); injector._extends(cm.ref(NoopConfigInjector.class)); injectAttributeMethod = null; injectMethod = null; injectElementMethod = null; } else { injector._extends(cm.ref(ConfigInjector.class).narrow(targetType)); injectMethod.param(Dom.class, "dom"); injectMethod.param(targetType, "target"); injectMethod.body();
private void testDefaultConstructorMethod(JFieldVar uutField, JVar staticTYPEVar, final JDefinedClass unitTestClass, JDefinedClass definedClass, JCodeModel codeModel) { int modifiers = JMod.PUBLIC; JMethod unitTestMethod = unitTestClass.method(modifiers, Void.TYPE, "testDefaultConstructor"); unitTestMethod.annotate(org.junit.Test.class); JBlock unitTestBody = unitTestMethod.body(); unitTestBody.assign(uutField, JExpr._new(unitTestClass)); JClass abstractItemMetadataClass = definedClass._extends(); JInvocation assertEqualsInvoke = codeModel.ref(org.junit.Assert.class).staticInvoke("assertEquals").arg(staticTYPEVar).arg(JExpr.invoke(uutField, "getType")); unitTestBody.add(assertEqualsInvoke); }
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();
JVar otherObject = equals.param(Object.class, "other"); JBlock body = equals.body(); 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)); fieldEquals = jclass.owner().ref(Arrays.class).staticInvoke("equals").arg(thisFieldRef).arg(otherFieldRef); } else { fieldEquals = thisFieldRef.eq(otherFieldRef).cor(
private JType getReturnType(final JDefinedClass c, final JFieldVar field, final boolean required, final boolean usesOptional) { JType returnType = field.type(); if (ruleFactory.getGenerationConfig().isUseOptionalForGetters() || usesOptional) { if (!required && field.type().isReference()) { returnType = c.owner().ref("java.util.Optional").narrow(field.type()); } } return returnType; }
private void createTypeGetter(JCodeModel model, TypeInfo pair) { JClass setClass = model.ref(Set.class); JClass uriSetClass = setClass.narrow(URI.class); JDefinedClass dc = pair.implClass; JFieldRef typeRef = pair.interfaceClass.staticRef("TYPE"); JMethod method = dc.method(JMod.PUBLIC, URI.class, "getType"); method.body()._return(typeRef); JFieldRef typeSetField = pair.interfaceClass.staticRef("TYPES"); dc.method(JMod.PUBLIC, uriSetClass, "getAllTypes") .body()._return(typeSetField); }
protected JFieldVar addConstructor(final JDefinedClass implClass) { final JClass serviceClass = getModel().ref("org.bonitasoft.engine.business.data.BusinessDataRepository"); final JFieldVar service = addField(implClass, "businessDataRepository", serviceClass); final JMethod constructor = implClass.constructor(JMod.PUBLIC); constructor.param(serviceClass, "businessDataRepository"); final JBlock body = constructor.body(); body.assign(JExpr.refthis("businessDataRepository"), JExpr.ref("businessDataRepository")); return service; }
JClass setImplClass = fieldType.owner().ref(LinkedHashSet.class); setImplClass = setImplClass.narrow(setGenericType); JInvocation newSetImpl = JExpr._new(setImplClass); JInvocation invokeAsList = fieldType.owner().ref(Arrays.class).staticInvoke("asList"); for (JsonNode defaultValue : node) { invokeAsList.arg(getDefaultValue(setGenericType, defaultValue)); newSetImpl.arg(invokeAsList); } else if (!ruleFactory.getGenerationConfig().isInitializeCollections()) { return JExpr._null();
JBlock body = hashCode.body(); JVar result = body.decl(jclass.owner().INT, "result", JExpr.lit(1)); 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"));