How to use

annotate

method

in

com.sun.codemodel.JDefinedClass

@Override
public void propertyInclusion(JDefinedClass clazz, JsonNode schema) {
  clazz.annotate(JsonSerialize.class).param("include", inclusionLevel);
}

@Override
public void propertyInclusion(JDefinedClass clazz, JsonNode schema) {
  clazz.annotate(JsonInclude.class).param("value", inclusionLevel);
}

@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());
  }
}

@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());
  }
}

private void addJsonTypeInfoAnnotation(JDefinedClass jclass, JsonNode node) {
  if (ruleFactory.getGenerationConfig().getAnnotationStyle() == AnnotationStyle.JACKSON2) {
    String annotationName = node.get("deserializationClassProperty").asText();
    JAnnotationUse jsonTypeInfo = jclass.annotate(JsonTypeInfo.class);
    jsonTypeInfo.param("use", JsonTypeInfo.Id.CLASS);
    jsonTypeInfo.param("include", JsonTypeInfo.As.PROPERTY);
    jsonTypeInfo.param("property", annotationName);
  }
}

@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);
  clazz.annotate(EqualsAndHashCode.class);
  try {
    clazz.annotate(Buildable.class)
        .param("editableEnabled", false)
        .param("validationEnabled", true)
    apiVersion = apiVersion.substring(apiGroup.length() + 1);
   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);
    JAnnotationArrayMember arrayMember = resourceClass.annotate(VelocityTransformations.class)
     .paramArray("value");
    arrayMember.annotate(VelocityTransformation.class).param("value", "/manifest.vm")
     .param("outputPath", "kubernetes.properties").param("gather", true);
   } else if (resourceClass.getPackage().name().startsWith("io.fabric8.openshift")) {
    JAnnotationArrayMember arrayMember = resourceClass.annotate(VelocityTransformations.class)
     .paramArray("value");
    arrayMember.annotate(VelocityTransformation.class).param("value", "/manifest.vm")

service = injector.annotate(Service.class).param("name",elementName);
injector.annotate(InjectionTarget.class).param("value",targetType);

  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;
  }
}

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;
}

  public void annotateGenerated(JDefinedClass definedClass) {
    definedClass.annotate(generatedClass)
        .param("value", generatorName);
  }
}

@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());
  }
}

@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());
  }
}

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);
}

/** Adding ability to annotate a class
 * @param clazz
 *          The annotation class to annotate the class with
 */
public JAnnotationUse annotate(Class <? extends Annotation> clazz){
  return annotate(owner().ref(clazz));
}

/** Adding ability to annotate a class
 * @param clazz
 *          The annotation class to annotate the class with
 */
public JAnnotationUse annotate(Class <? extends Annotation> clazz){
  return annotate(owner().ref(clazz));
}

private void createActivity() {
  JClass parentActivity;
  if (appDetails.isRoboguice() && appDetails.isActionBarSherlock()) {
    if (appDetails.isViewPager()) {
      parentActivity = ref.ref(appDetails.getRoboSherlockFragmentActivityPackage());
    } else {
      parentActivity = ref.ref(appDetails.getRoboSherlockActivityPackage());
    }
  } else if (appDetails.isActionBarSherlock()) {
    parentActivity = appDetails.isViewPager() ? ref.sFragmentActivity() : ref.sActivity();
  } else if (appDetails.isRoboguice()) {
    parentActivity = appDetails.isViewPager() ? ref.roboFragmentActivity() : ref.roboActivity();
  } else {
    parentActivity = appDetails.isViewPager() ? ref.fragmentActivity() : ref.activity();
  }
  jClass._extends(parentActivity);
  // @EActivity
  if (appDetails.isAndroidAnnotations()) {
    JAnnotationUse eactivityAnnotation = jClass.annotate(ref.eactivity());
    JFieldRef field = ref.r().staticRef("layout").ref(appDetails.getActivityLayout());
    eactivityAnnotation.param("value", field);
  }
}

 @Override
 protected void generateMethod(final ClassRepresentation clazz, final List<JFieldVar> excludeFields, final boolean hasSuperClassFields) {

  final JDefinedClass implClass = clazz.getClassOutline().implClass;
  implClass._implements(Serializable.class);
  implClass.annotate(SuppressWarnings.class).param(VALUE, SERIAL);
 }
}

  public void generate(String packageName, File destDir, PrintStream status) throws Exception {
    JCodeModel cm = new JCodeModel();
    JPackage jpackage = cm._package(packageName);
    JDefinedClass maduraResourceComponent = jpackage._class("MaduraResourceComponent");
    JAnnotationUse annotationUse = maduraResourceComponent.annotate(org.springframework.stereotype.Component.class);
    annotationUse.param("value", maduraResourceComponent.fullName());
    annotationUse = maduraResourceComponent.annotate(MessageResource.class);
    annotationUse.param("value", "messages");
//        JFieldVar serialVersionUIDField = maduraResourceComponent.field(JMod.FINAL|JMod.PRIVATE|JMod.STATIC, long.class, "serialVersionUID");
//        serialVersionUIDField.init(JExpr.lit(1L));
    cm.build(destDir, status);
  }

 JDefinedClass testme = codeModel._class("Testme");

JAnnotationUse patternListAnnotation = testme.annotate(Pattern.List.class);
JAnnotationArrayMember list = patternListAnnotation.paramArray("value");

list.annotate(Pattern.class).param("regexp", "first_expression").param("message", "first.Pattern.message");
list.annotate(Pattern.class).param("regexp", "second_expression").param("message", "second.Pattern.message");
list.annotate(Pattern.class).param("regexp", "third_expression").param("message", "third.Pattern.message");

if (appDetails.isAndroidAnnotations()) {
  jClass.annotate(ref.efragment()).param("value", ref.r().staticRef("layout").ref("fragment_sample"));