How to use

fields

method

in

com.sun.codemodel.JDefinedClass

private JFieldVar searchClassAndSuperClassesForField(String property, JDefinedClass jclass) {
  Map<String, JFieldVar> fields = jclass.fields();
  JFieldVar field = fields.get(property);
  if (field == null) {
    return searchSuperClassesForField(property, jclass);
  }
  return field;
}

/**
 * @see EnumRule
 */
private static JExpression getDefaultEnum(JType fieldType, JsonNode node) {
  JDefinedClass enumClass = (JDefinedClass) fieldType;
  JType backingType = enumClass.fields().get("value").type();
  JInvocation invokeFromValue = enumClass.staticInvoke("fromValue");
  invokeFromValue.arg(getDefaultValue(backingType, node));
  return invokeFromValue;
}

TreeSet<String> fieldNames = new TreeSet<>(jclass.fields().keySet());
for (String fieldName : fieldNames) {
  JFieldVar fieldVar = jclass.fields().get(fieldName);
    processFieldVarForSerializableSupport(jclass.fields().get(fieldName), dataOutputStream);

JFieldVar field = jclass.fields().get(fieldName);

JInvocation superInvocation = constructorBody.invoke("super");
Map<String, JFieldVar> fields = jclass.fields();
Map<String, JVar> classFieldParams = new HashMap<>();

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

private JMethod addInternalGetMethodJava7(JDefinedClass jclass, JsonNode propertiesNode) {
  JMethod method = jclass.method(PROTECTED, jclass.owner()._ref(Object.class), DEFINED_GETTER_NAME);
  JVar nameParam = method.param(String.class, "name");
  JVar notFoundParam = method.param(jclass.owner()._ref(Object.class), "notFoundValue");
  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();
      addGetPropertyCase(jclass, propertySwitch, propertyName, propertyType, node);
    }
  }
  JClass extendsType = jclass._extends();
  if (extendsType != null && extendsType instanceof JDefinedClass) {
    JDefinedClass parentClass = (JDefinedClass) extendsType;
    JMethod parentMethod = parentClass.getMethod(DEFINED_GETTER_NAME,
        new JType[] { parentClass.owner()._ref(String.class), parentClass.owner()._ref(Object.class) });
    propertySwitch._default().body()
    ._return(_super().invoke(parentMethod).arg(nameParam).arg(notFoundParam));
  } else {
    propertySwitch._default().body()
    ._return(notFoundParam);
  }
  return method;
}

public void addWriteToParcel(JDefinedClass jclass) {
  JMethod method = jclass.method(JMod.PUBLIC, void.class, "writeToParcel");
  JVar dest = method.param(jclass.owner().directClass("android.os.Parcel"), "dest");
  method.param(int.class, "flags");
  // Call super.writeToParcel
  if (extendsParcelable(jclass)) {
    method.body().directStatement("super.writeToParcel(dest, flags);");
  }
  for (JFieldVar f : jclass.fields().values()) {
    if( (f.mods().getValue() & JMod.STATIC) == JMod.STATIC ) {
      continue;
    }
    if (f.type().erasure().name().equals("List")) {
      method.body().invoke(dest, "writeList").arg(f);
    } else {
      method.body().invoke(dest, "writeValue").arg(f);
    }
  }
}

JsonNode node = property.getValue();
String fieldName = ruleFactory.getNameHelper().getPropertyName(propertyName, node);
JType propertyType = jclass.fields().get(fieldName).type();
JExpression condition = lit(propertyName).invoke("equals").arg(nameParam);
propertyConditional = propertyConditional == null ? propertyConditional = body._if(condition)

JsonNode node = property.getValue();
String fieldName = ruleFactory.getNameHelper().getPropertyName(propertyName, node);
JType propertyType = jclass.fields().get(fieldName).type();

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

private void addHashCode(JDefinedClass jclass, JsonNode node) {
  Map<String, JFieldVar> fields = removeFieldsExcludedFromEqualsAndHashCode(jclass.fields(), node);

private void addEquals(JDefinedClass jclass, JsonNode node) {
  Map<String, JFieldVar> fields = removeFieldsExcludedFromEqualsAndHashCode(jclass.fields(), node);

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

private void addToString(JDefinedClass jclass) {
  Map<String, JFieldVar> fields = jclass.fields();
  JMethod toString = jclass.method(JMod.PUBLIC, String.class, "toString");
  Set<String> excludes = new HashSet<>(Arrays.asList(ruleFactory.getGenerationConfig().getToStringExcludes()));

if (clazz.fields().containsKey("kind") && clazz.fields().containsKey("metadata")) {
 String resourceName;

private JFieldVar searchClassAndSuperClassesForField(String property, JDefinedClass jclass) {
  Map<String, JFieldVar> fields = jclass.fields();
  JFieldVar field = fields.get(property);
  if (field == null) {
    return searchSuperClassesForField(property, jclass);
  }
  return field;
}

private JFieldVar getReferencedField(JFieldVar field, ClassOutline classOutline) {
  QName qname = getFieldReferenceUseAnnotationQName(field, classOutline);
  CPropertyInfo propertyInfo = classOutline.target.getProperty(qname.getLocalPart());
  if (propertyInfo == null) {
    throw new IllegalArgumentException("No property "+qname.getLocalPart()+" in "+classOutline.target);
  }
  return classOutline.implClass.fields().get(propertyInfo.getName(false));
}

public static JFieldVar field(FieldOutline fieldOutline) {
  final JDefinedClass theClass = fieldOutline.parent().implClass;
  return theClass.fields().get(
      fieldOutline.getPropertyInfo().getName(false));
}

/**
 * Adds "@Generated" to the classes, methods, and fields.
 */
private void augument(ClassOutline co) {
  annotate(co.implClass);
  for (JMethod m : co.implClass.methods())
    annotate(m);
  for (JFieldVar f : co.implClass.fields().values())
    annotate(f);
}