@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())); } }
@Override public void propertyOrder(JDefinedClass clazz, JsonNode propertiesNode) { JAnnotationArrayMember annotationValue = clazz.annotate(JsonPropertyOrder.class).paramArray("value"); for (Iterator<String> properties = propertiesNode.fieldNames(); properties.hasNext();) { annotationValue.param(properties.next()); } }
xmlTypeModelClass).getAnnotationMembers().get("propOrder"); xmlElementWrapperAnnotation.param("name", wrapperXmlName); xmlElementWrapperAnnotation.param("name", getXsdDeclaration(fieldPropertyInfo).getName()); "required"); if (wrapperXmlRequired != null) { xmlElementWrapperAnnotation.param("required", wrapperXmlRequired); "nillable"); if (wrapperXmlNillable != null) { xmlElementWrapperAnnotation.param("nillable", wrapperXmlNillable); "namespace"); if (wrapperXmlNamespace != null) { xmlElementWrapperAnnotation.param("namespace", wrapperXmlNamespace); for (JAnnotationUse subAnnotation : annotationArrayMember.annotations()) { if (getAnnotationMemberExpression(subAnnotation, "namespace") == null) { subAnnotation.param("namespace", candidate.getFieldTargetNamespace()); xmlElementAnnotation.param("name", xmlName); xmlElementAnnotation.param("name", candidate.getFieldName()); "namespace"); if (xmlNamespace != null) { xmlElementAnnotation.param("namespace", xmlNamespace);
private void write(Fault fault) throws JClassAlreadyExistsException { String className = Names.customExceptionClassName(fault); JDefinedClass cls = cm._class(className, ClassType.CLASS); 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();
JDefinedClass generatedClass = codeModel._class(modifiers, generatedBeanQualifiedName, ClassType.CLASS); EBeanHolder holder = eBeansHolder.create(element, getTarget(), generatedClass); JClass eBeanClass = codeModel.directClass(eBeanQualifiedName); holder.generatedClass._extends(eBeanClass); holder.generatedClass.annotate(SuppressWarnings.class).param("value", "unused"); holder.generatedClass.javadoc().append(SUPPRESS_WARNING_COMMENT); holder.init = holder.generatedClass.method(PRIVATE, codeModel.VOID, "init_"); holder.init.body().assign((JFieldVar) holder.contextRef, JExpr.invoke("getContext")); JMethod onFinishInflate = holder.generatedClass.method(PUBLIC, codeModel.VOID, "onFinishInflate"); onFinishInflate.annotate(Override.class); onFinishInflate.javadoc().append(ALREADY_INFLATED_COMMENT); JBlock ifNotInflated = onFinishInflate.body()._if(JExpr.ref("mAlreadyInflated_").not())._then(); ifNotInflated.assign(mAlreadyInflated_, JExpr.TRUE); onFinishInflate.body().invoke(JExpr._super(), "onFinishInflate");
parserBuilder.setXmlType(xmlType); parserBuilder.setAllowUnkown(false); parserBuilder.setBaseClass(builderContext.getCodeModel().ref(JAXBObject.class).narrow(type)); parserBuilder.getMethod()._throws(Exception.class); parserBuilder.getReaderClass().annotate(SuppressWarnings.class).paramArray("value").param("StringEquality"); JBlock body = parserBuilder.getMethod().body(); body.add(new JBlankLine()); body.add(new JLineComment("Check for xsi:nil")); body._if(parserBuilder.getXSR().invoke("isXsiNil"))._then()._return(JExpr._null()); JBlock contextNullBlock = body._if(parserBuilder.getContextVar().eq(JExpr._null()))._then(); contextNullBlock.assign(parserBuilder.getContextVar(), JExpr._new(builderContext.toJClass(RuntimeContext.class))); body.add(new JBlankLine()); JType beanType = builderContext.getCodeModel()._ref(type); readObject = body.decl(beanType, decapitalize(varName), JExpr._new(beanType)); if (parserBuilder.getVariableManager().containsId(lifecycleCallbackVar.name())) { lifecycleCallbackRef = jaxbObjectClass.staticRef(lifecycleCallbackVar.name());
final JDefinedClass $output = codeModel._class(outfqcn); $output.annotate(Generated.class).param("value", Translator.class.getName()).param("date", new Date().toString()).param("comments", "based on " + sourceJarName); $output.annotate(SuppressWarnings.class).param("value", "rawtypes"); $output.constructor(JMod.PRIVATE); JClass $MethodLocation = codeModel.ref("com.cloudbees.groovy.cps.MethodLocation"); $output.method(JMod.PRIVATE|JMod.STATIC, $MethodLocation, "loc").tap( m -> { JVar $methodName = m.param(String.class, "methodName"); m.body()._return(JExpr._new($MethodLocation).arg($output.dotclass()).arg($methodName)); });
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")); labelTextField.annotate(ref.viewById()); JMethod onCreateViewMethod = jClass.method(JMod.NONE, jCodeModel.VOID, "afterViews"); onCreateViewMethod.annotate(ref.afterViews()); onCreateViewMethodBody = onCreateViewMethod.body(); JAnnotationUse injectViewAnnotation = labelTextField.annotate(ref.injectView()); JFieldRef field = ref.r().staticRef("id").ref("label_text"); injectViewAnnotation.param("value", field); onViewCreatedMethodBody.invoke(JExpr._super(), "onViewCreated").arg(viewParam).arg(savedInstanceStateParam);
protected JClass generateExceptionClass(MessagePartInfo part, JCodeModel model, JType paramType, JDefinedClass exCls) { exCls._extends(Exception.class); JAnnotationUse webFaultAnn = exCls.annotate(WebFault.class); webFaultAnn.param("name", part.getName().getLocalPart()); webFaultAnn.param("targetNamespace", part.getName().getNamespaceURI()); exCls.field(JMod.PRIVATE, paramType, "faultInfo"); JMethod getFaultInfo = exCls.method(JMod.PUBLIC, paramType, "getFaultInfo"); getFaultInfo.body()._return(JExpr.ref("faultInfo")); JMethod cons = exCls.constructor(JMod.PUBLIC); cons.param(String.class, "message"); cons.param(paramType, "faultInfo"); cons.body().invoke("super").arg(JExpr.ref("message")); cons.body().assign(JExpr.refthis("faultInfo"), JExpr.ref("faultInfo")); cons = exCls.constructor(JMod.PUBLIC); cons.param(String.class, "message"); cons.param(paramType, "faultInfo"); cons.param(Throwable.class, "t"); cons.body().invoke("super").arg(JExpr.ref("message")).arg(JExpr.ref("t")); cons.body().assign(JExpr.refthis("faultInfo"), JExpr.ref("faultInfo")); return exCls; } }
targetType = cm.ref(name); injector = cm._class(name+"Injector"); String elementName = c.name(); if(c.local()) { service = injector.annotate(Service.class).param("name",elementName); injector.annotate(InjectionTarget.class).param("value",targetType); injector._extends(cm.ref(NoopConfigInjector.class)); injectAttributeMethod = null; injectMethod = null; injectMethod = injector.method(JMod.PUBLIC, void.class, "inject"); injectMethod.param(Dom.class, "dom"); injectMethod.param(targetType, "target"); injectMethod.body(); injectAttributeMethod = injector.method(JMod.PUBLIC,void.class,"injectAttribute");
private void writeXmlTypeDeclaration(JDefinedClass cls, String typeName, String namespaceUri, Collection<MemberInfo> members) { if (cls == null) return; JAnnotationUse xmlTypeAnn = cls.annotate(cm.ref(XmlType.class)); xmlTypeAnn.param("name", typeName); xmlTypeAnn.param("namespace", namespaceUri); if (members.size() > 1) { JAnnotationArrayMember paramArray = xmlTypeAnn.paramArray("propOrder"); for (MemberInfo memInfo : members) { paramArray.param(memInfo.getParamName()); } } }
public JCodeModel generate(JCodeModel jCodeModel, RefHelper ref) throws IOException { logger = LoggerFactory.getLogger(getClass()); try { jClass = jCodeModel._class(appDetails.getApplicationPackage()); jClass._extends(ref.application()); jClass.annotate(ref.reportsCrashes()).param("formKey", "YOUR_FORM_KEY"); JMethod onCreateMethod = jClass.method(JMod.PUBLIC, jCodeModel.VOID, "onCreate"); onCreateMethod.annotate(ref.override()); JBlock onCreateMethodBody = onCreateMethod.body(); onCreateMethodBody.staticInvoke(ref.acra(), "init").arg(JExpr._this()); onCreateMethodBody.invoke(JExpr._super(), "onCreate"); } catch (JClassAlreadyExistsException e1) { logger.error("Classname already exists", e1); } return jCodeModel; }
private void generateCastMethod(JCodeModel codeModel, EBeanHolder holder) { JType objectType = codeModel._ref(Object.class); JMethod method = holder.generatedClass.method(JMod.PRIVATE, objectType, "cast_"); JTypeVar genericType = method.generify("T"); method.type(genericType); JVar objectParam = method.param(objectType, "object"); method.annotate(SuppressWarnings.class).param("value", "unchecked"); method.body()._return(JExpr.cast(genericType, objectParam)); holder.cast = method; }
@Override public void propertyOrder(JDefinedClass clazz, JsonNode propertiesNode) { JAnnotationArrayMember annotationValue = clazz.annotate(JsonPropertyOrder.class).paramArray("value"); clazz.annotate(JsonDeserialize.class) .param("using", JsonDeserializer.None.class); clazz.annotate(ToString.class); .param("editableEnabled", false) .param("validationEnabled", true) .param("generateBuilderPackage", true) .param("builderPackage", "io.fabric8.kubernetes.api.builder") .annotationParam("inline", Inline.class) .param("type", new JCodeModel()._class("io.fabric8.kubernetes.api.model.Doneable")) .param("prefix", "Doneable") .param("value", "done"); resourceClass.annotate(ApiVersion.class).param("value", apiVersion); resourceClass.annotate(ApiGroup.class).param("value", apiGroup); resourceListClass.annotate(ApiVersion.class).param("value", apiVersion); resourceListClass.annotate(ApiGroup.class).param("value", apiGroup); .paramArray("value"); arrayMember.annotate(VelocityTransformation.class).param("value", "/manifest.vm") .param("outputPath", "kubernetes.properties").param("gather", true); .paramArray("value"); arrayMember.annotate(VelocityTransformation.class).param("value", "/manifest.vm") .param("outputPath", "openshift.properties").param("gather", true);
/** * This method adds {@link ContentType} annotation and a CONTENT TYPE * constant of type "public static final String" to the JAXB generated Java * class. It reads the "meta:content-type" annotation element in the schema * and adds a corresponding Java annotation if not empty. * * @param implClass the element which will be annotated * @param customizations schema customizations for this element */ private void addContentTypeAnnotation(JDefinedClass implClass, CCustomizations customizations) { if (implClass == null) { return; } CPluginCustomization customization = customizations.find(NAMESPACE_URI, ELEMENT_CONTENT_TYPE); if (customization == null) { return; } customization.markAsAcknowledged(); String contentType = customization.element.getTextContent(); if (contentType != null) { JAnnotationUse annotation = implClass.annotate(ContentType.class); annotation.param("value", contentType.trim()); final JCodeModel codeModel = implClass.owner(); JExpression contentTypeConst = JExpr.lit(contentType); @SuppressWarnings("unused") JFieldVar contentTypeField = implClass.field(JMod.PUBLIC | JMod.STATIC | JMod.FINAL, codeModel.ref(String.class), CONTENT_TYPE_CONST, contentTypeConst); } }
Class<? extends Annotation> r = (Class<? extends Annotation>)rt; return new TypedAnnotationWriter( r,method.getReturnType(),use.annotationParam(name,r)).createProxy(); if(m.getDefaultValue()!=null) { if(targ.equals(targ.owner().ref((Class)m.getDefaultValue()))) return proxy; // defaulted use.param(name,targ); return proxy; use.param(name,(String)arg); return proxy; use.param(name,(Boolean)arg); return proxy; use.param(name,(Integer)arg); return proxy; use.param(name,(Class)arg); return proxy; use.param(name,(Enum)arg); return proxy;
private void writeXmlElementDeclaration(JDefinedClass cls, String elementName, String namespaceUri) { if (cls == null) return; JAnnotationUse xmlRootElementAnn = cls.annotate(XmlRootElement.class); xmlRootElementAnn.param("name", elementName); if (namespaceUri.length() > 0) { xmlRootElementAnn.param("namespace", namespaceUri); } JAnnotationUse xmlAccessorTypeAnn = cls.annotate(cm.ref(XmlAccessorType.class)); xmlAccessorTypeAnn.param("value", XmlAccessType.FIELD); }
private void annotateMetatadataValidator(JDefinedClass clazz) { if (clazz.name().equals("PodTemplateSpec")) { return; } for (Map.Entry<String, JFieldVar> f : clazz.fields().entrySet()) { if (f.getKey().equals("metadata") && f.getValue().type().name().equals("ObjectMeta")) { try { JAnnotationUse annotation = f.getValue().annotate(new JCodeModel()._class("io.fabric8.kubernetes.api.model.validators.CheckObjectMeta")); if (isMinimal(clazz)) { annotation.param("minimal", true); } else { annotation .param("regexp", "^" + getObjectNamePattern(clazz) + "$") .param("max", getObjectNameMaxLength(clazz)); } } catch (JClassAlreadyExistsException e) { e.printStackTrace(); } return; } } }
public JCodeModel generate(JCodeModel jCodeModel, RefHelper ref) throws IOException { logger = LoggerFactory.getLogger(getClass()); try { jClass = jCodeModel._class(appDetails.getRestClientPackage(), INTERFACE); /* * @Rest( rootUrl = "<ROOT_URL>", converters = * StringHttpMessageConverter.class) */ JAnnotationUse rest = jClass.annotate(ref.rest()); rest.param("rootUrl", appDetails.getRestTemplateUrl()); rest.param("converters", ref.stringHttpMessageConverter().dotclass()); // TODO search the JMod for interface method JMethod mainMethod = jClass.method(JMod.ABSTRACT | JMod.PUBLIC, jCodeModel.VOID, "main"); JAnnotationUse get = mainMethod.annotate(ref.get()); get.param("value", "/"); } catch (JClassAlreadyExistsException e1) { logger.error("Classname already exists", e1); } return jCodeModel; } }