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()) {