How to use

constructor

method

in

com.sun.codemodel.JDefinedClass

private JFieldVar addValueField(JDefinedClass _enum, JType type) {
  JFieldVar valueField = _enum.field(JMod.PRIVATE | JMod.FINAL, type, VALUE_FIELD_NAME);
  JMethod constructor = _enum.constructor(JMod.PRIVATE);
  JVar valueParam = constructor.param(type, VALUE_FIELD_NAME);
  JBlock body = constructor.body();
  body.assign(JExpr._this().ref(valueField), valueParam);
  return valueField;
}

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

private void addParcelSupport(JDefinedClass jclass) {
  jclass._implements(jclass.owner().directClass("android.os.Parcelable"));
  parcelableHelper.addWriteToParcel(jclass);
  parcelableHelper.addDescribeContents(jclass);
  parcelableHelper.addCreator(jclass);
  parcelableHelper.addConstructorFromParcel(jclass);
  // #742 : includeConstructors will include the default constructor
  if (!ruleFactory.getGenerationConfig().isIncludeConstructors()) {
    // Add empty constructor
    jclass.constructor(JMod.PUBLIC);
  }
}

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 createConstructors(JCodeModel model, TypeInfo typeInfo) {
  typeInfo.implClass.constructor(JMod.PUBLIC);
  
  JMethod ctor = typeInfo.implClass.constructor(JMod.PUBLIC);
  JVar idVar = ctor.param(URI.class, "id");
  
  ctor.body().invoke("super").arg(idVar);
  
}

private void createThingConstructors(JCodeModel model, TypeInfo typeInfo) {
  
  typeInfo.implClass.constructor(JMod.PUBLIC);
  
  JMethod ctor = typeInfo.implClass.constructor(JMod.PUBLIC);
  JVar idVar = ctor.param(URI.class, "id");
  ctor.body().assign(JExpr._this().ref("id"), idVar);
  
  
}

private JMethod createDefaultConstructor(JDefinedClass definedClass) {
  JMethod constructor = definedClass.constructor(JMod.PUBLIC);
  constructor.body().invoke("super").invoke("aaa");
  return constructor;
}

private void withDefaultConstructor(String className) {
  // Create default constructor
  JMethod constructor = this.pojo.constructor(JMod.PUBLIC);
  constructor.javadoc().add("Creates a new " + className + ".");
  JBlock defaultConstructorBody = constructor.body();
  defaultConstructorBody.invoke("super");
}

JMethod constructor = jClass.constructor(JMod.PUBLIC);
constructor.param(ref.fragmentManager(), "fm");
if (hasLocationsField) {

@Override
@Nonnull
protected JMethod createConstructor( @Nonnull JDefinedClass serializerClass, @Nonnull DomainObjectDescriptor domainObjectDescriptor ) {
 JMethod constructor = serializerClass.constructor( JMod.PUBLIC );
 constructor.body()
  .invoke( METHOD_SUPER ).arg( getDefaultElementName( domainObjectDescriptor ) ).arg( getNamespace( domainObjectDescriptor.getQualifiedName() ) )
  .arg( createDefaultVersionRangeInvocation(VERSION, VERSION) );
 return constructor;
}

private void renderPrivateJaxbConstructor(JDefinedClass classModel, List<FieldModel> fields) {
  JMethod method = classModel.constructor(JMod.PRIVATE);
  JBlock body = method.body();
  for (FieldModel fieldModel : fields) {
    body.directStatement("this." + fieldModel.fieldName + " = " + getInitString(fieldModel.fieldType) + ";");
  }
  method.javadoc().add("Private constructor used only by JAXB.");
}

protected void addConstructor() {
  JMethod constructor = definedClass.constructor(JMod.PRIVATE);
  JVar nameParam = constructor.param(String.class, "n");
  JVar valueParam = constructor.param(Integer.TYPE, "v");
  constructor.body()
      .assign(nameField, nameParam)
      .assign(valueField, valueParam);
}

private JMethod createPrismContextContainerableConstructor(JDefinedClass definedClass, JMethod setupContainerMethod) {
  JMethod constructor = definedClass.constructor(JMod.PUBLIC);
  constructor.param(PrismContext.class, "prismContext");
  JBlock body = constructor.body();
  body.invoke(setupContainerMethod)                                                        // setupContainerValue(
      .arg(JExpr._new(CLASS_MAP.get(PrismContainerValueImpl.class).narrow(new JClass[0]))  //    new PrismContainerValueImpl<>(
          .arg(JExpr._this())                                                      //       this,
          .arg(constructor.params().get(0)));                                      //       prismContext);
  return constructor;
}

private JMethod generateStandardConstructor( final ClassOutline clazz )
{
  final JMethod ctor = clazz.implClass.constructor( JMod.PUBLIC );
  ctor.body().directStatement( "// " + getMessage( "title" ) );
  ctor.body().invoke( "super" );
  ctor.javadoc().add( "Creates a new {@code " + clazz.implClass.name() + "} instance." );
  this.constructorCount = this.constructorCount.add( BigInteger.ONE );
  return ctor;
}

private JFieldVar addValueField(JDefinedClass _enum, JType type) {
  JFieldVar valueField = _enum.field(JMod.PRIVATE | JMod.FINAL, type, VALUE_FIELD_NAME);
  JMethod constructor = _enum.constructor(JMod.PRIVATE);
  JVar valueParam = constructor.param(type, VALUE_FIELD_NAME);
  JBlock body = constructor.body();
  body.assign(JExpr._this().ref(valueField), valueParam);
  return valueField;
}

private void renderBuilderConstructor(JDefinedClass classModel, List<FieldModel> fields) {
  JMethod method = classModel.constructor(JMod.PRIVATE);
  method.param(codeModel.ref("Builder"), "builder");
  JBlock body = method.body();
  for (FieldModel fieldModel : fields) {
    body.directStatement("this." + fieldModel.fieldName + " = builder." + Util.generateGetter(fieldModel.fieldName, isBoolean(fieldModel.fieldType)) + ";");
  }
}

private JFieldVar addValueField(JDefinedClass _enum) {
  JFieldVar valueField = _enum.field(JMod.PRIVATE | JMod.FINAL, String.class, VALUE_FIELD_NAME);
  JMethod constructor = _enum.constructor(JMod.PRIVATE);
  JVar valueParam = constructor.param(String.class, VALUE_FIELD_NAME);
  JBlock body = constructor.body();
  body.assign(JExpr._this().ref(valueField), valueParam);
  return valueField;
}

private JMethod createPrismContextObjectableConstructor(JDefinedClass definedClass) {
  JMethod constructor = definedClass.constructor(JMod.PUBLIC);
  constructor.param(PrismContext.class, "prismContext");
  JBlock body = constructor.body();
  body.invoke("setupContainer")
      .arg(JExpr._new(CLASS_MAP.get(PrismObjectImpl.class))
          .arg(JExpr.invoke("_getContainerName"))
          .arg(JExpr.invoke("getClass"))
          .arg(constructor.params().get(0)));
  return constructor;
}

protected void addConstructor() {
  JMethod constructor = definedClass.constructor(JMod.PRIVATE);
  JVar nameParam = constructor.param(String.class, "n");
  JVar oidStrParam = constructor.param(String.class, "os");
  JVar berTagValueParam = constructor.param(Integer.TYPE, "btv");
  constructor.body()
      .assign(nameField, nameParam)
      .assign(oidStrField, oidStrParam)
      .assign(berTagValueField, JExpr.cast(definedClass.owner().BYTE, berTagValueParam));
}

private void addParcelSupport(JDefinedClass jclass) {
  jclass._implements(jclass.owner().directClass("android.os.Parcelable"));
  parcelableHelper.addWriteToParcel(jclass);
  parcelableHelper.addDescribeContents(jclass);
  parcelableHelper.addCreator(jclass);
  parcelableHelper.addConstructorFromParcel(jclass);
  // #742 : includeConstructors will include the default constructor
  if (!ruleFactory.getGenerationConfig().isIncludeConstructors()) {
    // Add empty constructor
    jclass.constructor(JMod.PUBLIC);
  }
}