private JMethod addInternalSetMethodJava7(JDefinedClass jclass, JsonNode propertiesNode) { JMethod method = jclass.method(PROTECTED, jclass.owner().BOOLEAN, DEFINED_SETTER_NAME); JVar nameParam = method.param(String.class, "name"); JVar valueParam = method.param(Object.class, "value"); JBlock body = method.body(); JSwitch propertySwitch = body._switch(nameParam); if (propertiesNode != null) { for (Iterator<Map.Entry<String, JsonNode>> properties = propertiesNode.fields(); properties.hasNext();) { Map.Entry<String, JsonNode> property = properties.next(); String propertyName = property.getKey(); JsonNode node = property.getValue(); String fieldName = ruleFactory.getNameHelper().getPropertyName(propertyName, node); JType propertyType = jclass.fields().get(fieldName).type(); addSetPropertyCase(jclass, propertySwitch, propertyName, propertyType, valueParam, node); } } JBlock defaultBlock = propertySwitch._default().body(); JClass extendsType = jclass._extends(); if (extendsType != null && extendsType instanceof JDefinedClass) { JDefinedClass parentClass = (JDefinedClass) extendsType; JMethod parentMethod = parentClass.getMethod(DEFINED_SETTER_NAME, new JType[] { parentClass.owner()._ref(String.class), parentClass.owner()._ref(Object.class) }); defaultBlock._return(_super().invoke(parentMethod).arg(nameParam).arg(valueParam)); } else { defaultBlock._return(FALSE); } return method; }
JBlock body = equals.body(); JVar rhsVar = body.decl(jclass, "rhs").init(JExpr.cast(jclass, otherObject)); JExpression result = JExpr.lit(true); if ((fieldVar.mods().getValue() & JMod.STATIC) == JMod.STATIC) { continue; JFieldRef thisFieldRef = JExpr.refthis(fieldVar.name()); JFieldRef otherFieldRef = JExpr.ref(rhsVar, fieldVar.name()); JExpression fieldEquals; if (fieldVar.type().isPrimitive()) { if ("double".equals(fieldVar.type().name())) { 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( fieldEquals = thisFieldRef.eq(otherFieldRef); } else if (fieldVar.type().isArray()) { if (!fieldVar.type().elementType().isPrimitive()) { throw new UnsupportedOperationException("Only primitive arrays are supported");
@Override public void propertyField(JFieldVar field, JDefinedClass clazz, String propertyName, JsonNode propertyNode) { field.annotate(JsonProperty.class).param("value", propertyName); if (field.type().erasure().equals(field.type().owner().ref(Set.class))) { field.annotate(JsonDeserialize.class).param("as", LinkedHashSet.class); } if (propertyNode.has("javaJsonView")) { field.annotate(JsonView.class).param( "value", field.type().owner().ref(propertyNode.get("javaJsonView").asText())); } }
private JMethod addSetter(JDefinedClass c, JFieldVar field, String jsonPropertyName, JsonNode node) { JMethod setter = c.method(JMod.PUBLIC, void.class, getSetterName(jsonPropertyName, node)); JVar param = setter.param(field.type(), field.name()); JBlock body = setter.body(); body.assign(JExpr._this().ref(field), param); return setter; }
private static void processFieldVarForSerializableSupport(JFieldVar fieldVar, DataOutputStream dataOutputStream) throws IOException { dataOutputStream.writeUTF(fieldVar.name()); dataOutputStream.writeInt(fieldVar.mods().getValue()); JType type = fieldVar.type(); dataOutputStream.writeUTF(type.fullName()); }
JDocComment comment = cls.javadoc(); if(fault.getJavaDoc() != null){ comment.add(fault.getJavaDoc()); cls._extends(java.lang.Exception.class); JAnnotationUse faultAnn = cls.annotate(WebFault.class); faultAnn.param("name", fault.getBlock().getName().getLocalPart()); faultAnn.param("targetNamespace", fault.getBlock().getName().getNamespaceURI()); fi.javadoc().add("Java type that goes as soapenv:Fault detail element."); JFieldRef fr = JExpr.ref(JExpr._this(), fi); JMethod constrc1 = cls.constructor(JMod.PUBLIC); JVar var1 = constrc1.param(String.class, "message"); JVar var2 = constrc1.param(faultBean, "faultInfo"); constrc1.javadoc().addParam(var1); constrc1.javadoc().addParam(var2); JBlock cb1 = constrc1.body(); cb1.invoke("super").arg(var1); cb1.assign(fr, var2); constrc2.javadoc().addParam(var3); JBlock cb2 = constrc2.body(); cb2.invoke("super").arg(var1).arg(var3); cb2.assign(fr, var2);
private void writeClassLoaderResourceWSDLLocation(String className, JDefinedClass cls, JFieldVar urlField, JFieldVar exField) { JBlock staticBlock = cls.init(); staticBlock.assign(urlField, JExpr.dotclass(cm.ref(className)).invoke("getClassLoader").invoke("getResource").arg(wsdlLocation)); JVar exVar = staticBlock.decl(cm.ref(WebServiceException.class), "e", JExpr._null()); JConditional ifBlock = staticBlock._if(urlField.eq(JExpr._null())); ifBlock._then().assign(exVar, JExpr._new(cm.ref(WebServiceException.class)).arg( "Cannot find "+JExpr.quotify('\'', wsdlLocation)+" wsdl. Place the resource correctly in the classpath.")); staticBlock.assign(exField, exVar); }
JBlock body = toString.body(); jclass.owner().ref(System.class).staticInvoke("identityHashCode").arg(JExpr._this()))) contentStart.gte(JExpr.lit(0)).cand(contentEnd.gt(contentStart))); if (excludes.contains(fieldVar.name()) || (fieldVar.mods().getValue() & JMod.STATIC) == JMod.STATIC) { continue; body.add(sb.invoke("append").arg(fieldVar.name())); if (fieldVar.type().isPrimitive()) { body.add(sb.invoke("append").arg(JExpr.refthis(fieldVar.name()))); } else if (fieldVar.type().isArray()) { if (!fieldVar.type().elementType().isPrimitive()) { throw new UnsupportedOperationException("Only primitive arrays are supported"); JExpr.refthis(fieldVar.name()).eq(JExpr._null()), .arg(JExpr.refthis(fieldVar.name())) JExpr.refthis(fieldVar.name()).eq(JExpr._null()), JExpr.lit("<null>"), JExpr.refthis(fieldVar.name())))); toString.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 JMethod addListSetter(final JDefinedClass definedClass, final JFieldVar field) { final JMethod method = definedClass.method(JMod.PUBLIC, Void.TYPE, getSetterName(field)); method.param(field.type(), field.name()); final JFieldRef thisField = JExpr._this().ref(field.name()); final JConditional ifListIsNull = method.body()._if(thisField.eq(JExpr._null())); ifListIsNull._then().assign(JExpr._this().ref(field.name()), JExpr.ref(field.name())); final JBlock elseBlock = ifListIsNull._else(); final JVar copyVar = elseBlock.decl(field.type(), "copy", JExpr._new(getModel().ref(ArrayList.class)).arg(field)); elseBlock.invoke(JExpr._this().ref(field.name()), "clear"); elseBlock.invoke(JExpr._this().ref(field.name()), "addAll").arg(copyVar); return method; }
if ((fieldVar.mods().getValue() & JMod.STATIC) == JMod.STATIC) { continue; JFieldRef fieldRef = JExpr.refthis(fieldVar.name()); if (fieldVar.type().isPrimitive()) { if ("long".equals(fieldVar.type().name())) { fieldHash = JExpr.cast(jclass.owner().INT, fieldRef.xor(fieldRef.shrz(JExpr.lit(32)))); } else if ("boolean".equals(fieldVar.type().name())) { fieldHash = JOp.cond(fieldRef, JExpr.lit(1), JExpr.lit(0)); } else if ("int".equals(fieldVar.type().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 if (fieldVar.type().isArray()) { if (!fieldVar.type().elementType().isPrimitive()) { throw new UnsupportedOperationException("Only primitive arrays are supported"); fieldHash = jclass.owner().ref(Arrays.class).staticInvoke("hashCode").arg(fieldRef); body.assign(result, result.mul(JExpr.lit(31)).plus(fieldHash));
private void addQueryMethodBody(final JDefinedClass entity, final JMethod method, final String queryName, final JFieldVar businessDataRepository) { final String entityName = entity.name(); final JTryBlock tryBlock = method.body()._try(); final JBlock tryBody = tryBlock.body(); JClass hashMapClass = getModel().ref(HashMap.class); hashMapClass = hashMapClass.narrow(String.class, Serializable.class); final JVar queryParameterMap = tryBody.decl(queryParameterMapClass, "queryParameters", JExpr._new(hashMapClass)); for (final JVar param : method.params()) { if (!FORBIDDEN_PARAMETER_NAMES.contains(param.name())) { tryBody.invoke(queryParameterMap, "put").arg(JExpr.lit(param.name())).arg(param); if (method.type() instanceof JClass) { isCollection = collectionClass.isAssignableFrom((JClass) method.type()); throw new IllegalArgumentException("Neither 'startIndex' nor 'maxResults' parameters should be null"); tryBody._return(businessDataRepository.invoke("findListByNamedQuery").arg(JExpr.lit(entityName + "." + queryName)).arg(JExpr.dotclass(entity)) .arg(queryParameterMap).arg(startIndex).arg(maxResults)); } else { final JClass returnTypeClass = entity.fullName().equals(method.type().fullName()) ? entity : getModel().ref(method.type().fullName()); tryBody._return(businessDataRepository.invoke("findByNamedQuery").arg(JExpr.lit(entityName + "." + queryName)).arg(JExpr.dotclass(returnTypeClass)) .arg(queryParameterMap));
constructor = servCls.constructor(JMod.PUBLIC); pfVar = servCls.field(JMod.STATIC + JMod.PRIVATE, pfType, "proxyFactory", JExpr._new(pfType)); endpointsVar = servCls.field(JMod.PRIVATE, hashMapType, "endpoints", JExpr._new(hashMapType)); getEndpoint = servCls.method(JMod.PUBLIC, objectType, "getEndpoint"); JVar epVar = getEndpoint.param(Endpoint.class, "endpoint"); JInvocation createProxy = pfVar.invoke("create"); createProxy.arg(JExpr.direct(epVar.name()).invoke("getBinding")); createProxy.arg(JExpr.direct(epVar.name()).invoke("getUrl")); tryBlock.body()._return(createProxy); catchBlock.body()._throw(xreThrow); geBody = getEndpointByName.body(); JInvocation getEndpointInv = endpointsVar.invoke("get"); getEndpointInv.arg(JExpr.direct(epname.name())); JBlock noEPBlock = geBody._if(JExpr.direct(epVar.name()).eq(JExpr._null()))._then(); geBody = getEndpoints.body(); geBody._return(endpointsVar.invoke("values"));
holder.generatedClass._extends(eBeanClass); holder.init = holder.generatedClass.method(PRIVATE, codeModel.VOID, "init_"); holder.init.param(holder.classes().BUNDLE, "savedInstanceState"); onCreateBody.invoke(holder.init).arg(onCreateSavedInstanceState); onCreateBody.invoke(_super(), onCreate).arg(onCreateSavedInstanceState); holder.contextRef = invoke("getActivity"); JBlock body = onCreateView.body(); body.assign(contentView, _super().invoke(onCreateView).arg(inflater).arg(container).arg(savedInstanceState)); body._if(contentView.eq(_null())) // .assign(contentView, inflater.invoke("inflate").arg(contentViewId).arg(container).arg(FALSE)); JBlock body = findViewById.body(); body._if(contentView.eq(_null())) // ._then()._return(_null()); body._return(contentView.invoke(findViewById).arg(idParam));
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()")) ) ); } } }
JMethod noargsConstructor = jclass.constructor(JMod.PUBLIC); noargsConstructor.javadoc().add("No args constructor for use in serialization"); JMethod fieldsConstructor = jclass.constructor(JMod.PUBLIC); JBlock constructorBody = fieldsConstructor.body(); JInvocation superInvocation = constructorBody.invoke("super"); Map<String, JFieldVar> fields = jclass.fields(); Map<String, JVar> classFieldParams = new HashMap<>(); fieldsConstructor.javadoc().addParam(property); JVar param = fieldsConstructor.param(field.type(), field.name()); constructorBody.assign(JExpr._this().ref(field), param); classFieldParams.put(property, param); param = fieldsConstructor.param(field.type(), field.name()); superInvocation.arg(param);
JBlock consBody = constructor.body(); JType qnameType = model.ref(QName.class); JInvocation newQN = JExpr._new(qnameType); newQN.arg(endpoint.getName().getNamespaceURI()); newQN.arg(endpoint.getName().getLocalPart()); JInvocation bindingQN = JExpr._new(qnameType); bindingQN.arg(endpoint.getBinding().getName().getNamespaceURI()); bindingQN.arg(endpoint.getBinding().getName().getLocalPart()); JVar epVar = consBody.decl(endpointType, javify(endpoint.getName().getLocalPart()) + "EP", addEndpointInv); JInvocation addEndpoint = endpointsVar.invoke("put").arg(newQN).arg(epVar); consBody.add(addEndpoint); JMethod getFooEndpoint = servCls.method(JMod.PUBLIC, serviceIntf, "get" + javify(endpoint.getName().getLocalPart())); JBlock geBody = getFooEndpoint.body(); geBody._return(JExpr.cast(serviceIntf, JExpr.direct("this").invoke(getEndpoint).arg(newQN))); JMethod getFooEndpoint1 = servCls.method(JMod.PUBLIC, serviceIntf, "get" + javify(endpoint.getName().getLocalPart())); getFooEndpoint1.param(String.class,"url"); JBlock geBody1 = getFooEndpoint1.body(); JInvocation getEndp = JExpr.invoke(getFooEndpoint);
public JMethod createCreateClassMethod(final JDefinedClass bean, final JFieldVar classes) { final JClass returnClazz = _classByNames( java.lang.Class.class.getName(), MessageFormat.format("? extends {0}", bean.name())); final JMethod method = bean.method(JMod.SYNCHRONIZED | JMod.PRIVATE | JMod.STATIC, returnClazz, "_createClass"); final JVar type = method.param(java.lang.String.class, "type"); method.body()._if(classes.invoke("containsKey").arg(type))._then()._return( JExpr.cast(returnClazz, classes.invoke("get").arg(type))); final JTryBlock _try = method.body()._try(); final JBlock body = _try.body(); final JVar packageName = body.decl(_String(), "packageName", packageName(bean)); final JVar typeName = body.decl(_String(), "typeName", setFirstCharacterToUpperCase(type)); final JVar className = body.decl(_String(), "className", format("{0}.{1}", packageName, typeName)); final JVar clazz = body.decl(_Class(), "clazz", classForName(className)); final JExpression condition = isAssignableFrom(bean, clazz).not(); final JBlock block = body._if(condition)._then().block(); block.invoke(classes, "put").arg(type).arg(JExpr._null()); block._return(JExpr._null()); body.invoke(classes, "put").arg(type).arg(clazz); body._return(JExpr.cast(returnClazz, clazz)); final JCatchBlock _catch = _try._catch(_classByNames(java.lang.ClassNotFoundException.class.getName())); _catch.param("exception"); _catch.body().invoke(classes, "put").arg(type).arg(JExpr._null()); _catch.body()._return(JExpr._null()); return method; }
jaxbEnumClass._extends(builderContext.getCodeModel().ref(JAXBEnum.class).narrow(type)); } catch (JClassAlreadyExistsException e) { throw new BuildException(e); JFieldVar instanceVar = jaxbEnumClass.field(JMod.PUBLIC | JMod.STATIC | JMod.FINAL, jaxbEnumClass, "INSTANCE", JExpr._new(jaxbEnumClass)); JMethod constructor = jaxbEnumClass.constructor(JMod.PUBLIC); constructor.body().invoke("super") .arg(JExpr.dotclass(builderContext.toJClass(type))) .arg(newQName(xmlRootElement)) .arg(newQName(xmlType)); JMethod staticParse = jaxbEnumClass.method(JMod.PUBLIC | JMod.STATIC, type, "parse" + type.getSimpleName())._throws(Exception.class); JVar xsrVar = staticParse.param(XoXMLStreamReader.class, "reader"); JVar contextVar = staticParse.param(builderContext.toJClass(RuntimeContext.class), "context"); JVar value = staticParse.param(String.class, "value"); staticParse.body()._return(instanceVar.invoke("parse").arg(xsrVar).arg(contextVar).arg(value)); contextVar = staticToString.param(builderContext.toJClass(RuntimeContext.class), "context"); value = staticToString.param(type, decapitalize(type.getSimpleName())); staticToString.body()._return(instanceVar.invoke("toString").arg(beanVar).arg(parameterNameVar).arg(contextVar).arg(value));
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; }