How to use

constructors

method

in

com.sun.codemodel.JDefinedClass

processMethodCollectionForSerializableSupport(jclass.constructors(), dataOutputStream);

private void removeConstructors(ClassOutline classOutline) {
  JDefinedClass impl = classOutline.implClass;
  Iterator<JMethod> constructors = impl.constructors();
  while (constructors.hasNext()) {
    JMethod constructor = constructors.next();
    if (constructor.hasSignature(new JType[]{impl})
        /* || constructor.hasSignature(new JType[]{}) */) {             // default constructor has to be kept there!
      constructors.remove();
    }
  }
}

/**
 * Return all of the <code>JavaConstructors</code> for this <code>JavaClass</code>.
 *
 * @return A <code>Collection</code> containing this <code>JavaClass'</code> <code>JavaConstructors</code>.
 */
@SuppressWarnings("unchecked")
public Collection<JavaConstructor> getConstructors() {
  ArrayList<JavaConstructor> constructors = new ArrayList<JavaConstructor>();
  Iterator<JMethod> it = xjcClass.constructors();
  while (it.hasNext()) {
    constructors.add(new XJCJavaConstructorImpl(it.next(), jCodeModel, dynamicClassLoader, this));
  }
  return constructors;
}

private Map<String, JVar> getSuperParametersToAdd(JClass pojo) {
  Map<String, JVar> tFields = new LinkedHashMap<>();
  JClass parent = pojo._extends();
  if (!parent.name().equals(Object.class.getSimpleName())) {
    parent = CodeModelHelper.findFirstClassBySimpleName(this.pojoModel, parent.name());
    if (parent instanceof JDefinedClass) {
      JDefinedClass jParent = (JDefinedClass) parent;
      JMethod constructor = null;
      Iterator<JMethod> constructors = jParent.constructors();
      while (constructors.hasNext()) {
        JMethod targetConstructor = constructors.next();
        if (constructor == null || constructor.params().size() < targetConstructor.params().size()) {
          constructor = targetConstructor;
        }
      }
      for (JVar var : constructor.params()) {
        tFields.put(var.name(), var);
      }
    }
  }
  return tFields;
}

processMethodCollectionForSerializableSupport(jclass.constructors(), dataOutputStream);

 public JMethod generate(ClassContext classContext, FieldItem fieldItem, JDefinedClass theClass) {

  if (processedClassesMap.keySet().contains(theClass)) {
   return (JMethod) processedClassesMap.get(theClass);

  }
  else {
   final JCodeModel codeModel = getCodeModel(classContext);

   final JVar enumCodeMap = theClass.field(JMod.PRIVATE + JMod.STATIC, Map.class, "enumCodeMap");

   final JMethod constructor = (JMethod) theClass.constructors().next();
   constructor.body()._if(JOp.eq(enumCodeMap, JExpr._null()))._then().assign(
     enumCodeMap,
     JExpr._new(codeModel.ref(HashMap.class)));

   constructor.body().invoke(enumCodeMap, "put").arg(JExpr._this()).arg(JExpr.ref("v"));

   final JMethod getEnumCodeMap = theClass.method(JMod.PUBLIC | JMod.STATIC, codeModel
     .ref(Map.class), "getEnumCodeMap");
   getEnumCodeMap.body()._return(enumCodeMap);
   processedClassesMap.put(theClass, getEnumCodeMap);
   return getEnumCodeMap;
  }
 }
}

 public JMethod generate(ClassContext classContext, FieldItem fieldItem, JDefinedClass theClass) {

  if (processedClassesMap.keySet().contains(theClass)) {
   return (JMethod) processedClassesMap.get(theClass);

  }
  else {
   final JCodeModel codeModel = getCodeModel(classContext);

   final JVar $values = theClass.field(JMod.PRIVATE + JMod.STATIC, List.class, "values");

   final JMethod constructor = (JMethod) theClass.constructors().next();
   constructor.body()._if(JOp.eq($values, JExpr._null()))._then().assign(
     $values,
     JExpr._new(codeModel.ref(ArrayList.class)));

   constructor.body().invoke($values, "add").arg(JExpr._this());

   final JMethod values = theClass.method(JMod.PUBLIC | JMod.STATIC, theClass.array(), "values");
   values.body()._return(
     JExpr.cast(theClass.array(), $values.invoke("toArray").arg(
       JExpr.newArray(theClass, JExpr.invoke($values, "size")))));
   processedClassesMap.put(theClass, values);
   return values;
  }
 }
}

 public JMethod generate(ClassContext classContext, FieldItem fieldItem, JDefinedClass theClass) {

  if (processedClassesMap.keySet().contains(theClass)) {
   return (JMethod) processedClassesMap.get(theClass);

  }
  else {
   final JCodeModel codeModel = getCodeModel(classContext);

   final JVar $codes = theClass.field(JMod.PRIVATE + JMod.STATIC, List.class, "codes");

   final JMethod constructor = (JMethod) theClass.constructors().next();
   constructor.body()._if(JOp.eq($codes, JExpr._null()))._then().assign(
     $codes,
     JExpr._new(codeModel.ref(ArrayList.class)));

   constructor.body().invoke($codes, "add").arg(JExpr.ref("v"));

   final JMethod values = theClass.method(JMod.PUBLIC | JMod.STATIC, codeModel
     .ref(String.class)
     .array(), "codes");
   values.body()._return(
     JExpr.cast(codeModel.ref(String.class).array(), $codes.invoke("toArray").arg(
       JExpr.newArray(codeModel.ref(String.class), JExpr.invoke($codes, "size")))));
   processedClassesMap.put(theClass, values);
   return values;
  }
 }
}

public void addDelegatingSerializerToConstructor( @Nonnull JDefinedClass serializerClass, @Nonnull JClass fieldType ) {
 JType fieldSerializerType = getSerializerRefFor( fieldType );
 JMethod constructor = ( JMethod ) serializerClass.constructors().next();
 String paramName = NamingSupport.createVarName( fieldSerializerType.name() );
 //Check whether the serializer still exists
 for ( JVar param : constructor.listParams() ) {
  if ( param.type().equals( fieldSerializerType ) ) {
   return;
  }
 }
 //It does not exist, therefore let us add the serializer and map it
 JVar param = constructor.param( fieldSerializerType, paramName );
 constructor.body().add( JExpr.invoke( "add" ).arg( param ).invoke( "responsibleFor" ).arg( JExpr.dotclass( fieldType ) )
              .invoke( "map" )
              .arg( JExpr.lit( 1 ) ).arg( JExpr.lit( 0 ) ).arg( JExpr.lit( 0 ) )
              .invoke( "toDelegateVersion" )
              .arg( JExpr.lit( 1 ) ).arg( JExpr.lit( 0 ) ).arg( JExpr.lit( 0 ) ) );
}

final Iterator<JMethod> constructors = definedClass.constructors();
if (!constructors.hasNext()) {