Examples with ParameterizedTypeName com.squareup.javapoet.ParameterizedTypeName used on opensource projects

Example 76 with ParameterizedTypeName

use of com.squareup.javapoet.ParameterizedTypeName in project react4j by react4j.

the class Generator method buildBuilder.

@Nonnull
private static TypeSpec buildBuilder(@Nonnull final ComponentDescriptor descriptor, @Nonnull final BuilderDescriptor builderDescriptor) {
    final TypeSpec.Builder builder = TypeSpec.classBuilder("Builder");
    ProcessorUtil.copyTypeParameters(descriptor.getElement(), builder);
    builder.addModifiers(Modifier.PRIVATE, Modifier.STATIC);
    final ArrayList<Step> steps = builderDescriptor.getSteps();
    for (int i = 0; i < steps.size(); i++) {
        builder.addSuperinterface(getParameterizedTypeName(descriptor, ClassName.bestGuess("Builder" + (i + 1))));
    }
    {
        final ParameterizedTypeName type = ParameterizedTypeName.get(JS_PROPERTY_MAP_CLASSNAME, TypeName.get(Object.class));
        final FieldSpec.Builder field = FieldSpec.builder(type, "_props", Modifier.PRIVATE, Modifier.FINAL);
        field.initializer("$T.of()", JS_PROPERTY_MAP_CLASSNAME);
        builder.addField(field.build());
    }
    final HashSet<String> stepMethodsAdded = new HashSet<>();
    for (final Step step : steps) {
        for (final StepMethod stepMethod : step.getMethods()) {
            if (stepMethodsAdded.add(stepMethod.getName() + stepMethod.getType().toString())) {
                if (!stepMethod.isBuildIntrinsic()) {
                    builder.addMethod(buildBuilderStepImpl(step, stepMethod));
                    if (stepMethod.isChildrenIntrinsic()) {
                        final ParameterizedTypeName type = ParameterizedTypeName.get(JS_ARRAY_CLASSNAME, REACT_NODE_CLASSNAME);
                        final FieldSpec.Builder field = FieldSpec.builder(type, "_children", Modifier.PRIVATE, Modifier.FINAL);
                        field.initializer("new $T<>()", JS_ARRAY_CLASSNAME);
                        builder.addField(field.build());
                    } else if (stepMethod.isChildIntrinsic()) {
                        final FieldSpec.Builder field = FieldSpec.builder(REACT_NODE_CLASSNAME, "_child", Modifier.PRIVATE);
                        builder.addField(field.build());
                    }
                }
            }
        }
    }
    builder.addMethod(buildBuildStepImpl(descriptor));
    return builder.build();
}

Example 77 with ParameterizedTypeName

use of com.squareup.javapoet.ParameterizedTypeName in project EasyRouter by Xiasm.

the class RouterProcessor method generatedGroup.

private void generatedGroup(TypeElement iRouteGroup) {
    // 创建参数类型 Map<String, RouteMeta>
    ParameterizedTypeName parameterizedTypeName = ParameterizedTypeName.get(ClassName.get(Map.class), ClassName.get(String.class), ClassName.get(RouteMeta.class));
    ParameterSpec altas = ParameterSpec.builder(parameterizedTypeName, "atlas").build();
    for (Map.Entry<String, List<RouteMeta>> entry : groupMap.entrySet()) {
        MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder(Constant.METHOD_LOAD_INTO).addModifiers(Modifier.PUBLIC).addAnnotation(Override.class).addParameter(altas);
        String groupName = entry.getKey();
        List<RouteMeta> groupData = entry.getValue();
        for (RouteMeta routeMeta : groupData) {
            // 函数体的添加
            methodBuilder.addStatement("atlas.put($S,$T.build($T.$L,$T.class,$S,$S))", routeMeta.getPath(), ClassName.get(RouteMeta.class), ClassName.get(RouteMeta.Type.class), routeMeta.getType(), ClassName.get(((TypeElement) routeMeta.getElement())), routeMeta.getPath(), routeMeta.getGroup());
        }
        String groupClassName = Constant.NAME_OF_GROUP + groupName;
        TypeSpec typeSpec = TypeSpec.classBuilder(groupClassName).addSuperinterface(ClassName.get(iRouteGroup)).addModifiers(Modifier.PUBLIC).addMethod(methodBuilder.build()).build();
        JavaFile javaFile = JavaFile.builder(Constant.PACKAGE_OF_GENERATE_FILE, typeSpec).build();
        try {
            javaFile.writeTo(filerUtils);
        } catch (IOException e) {
            e.printStackTrace();
        }
        rootMap.put(groupName, groupClassName);
    }
}

Example 78 with ParameterizedTypeName

use of com.squareup.javapoet.ParameterizedTypeName in project kripton by xcesco.

the class AbstractSelectCodeGenerator method generateCommonPart.

public void generateCommonPart(SQLiteModelMethod method, TypeSpec.Builder classBuilder, MethodSpec.Builder methodBuilder, Set<JQLProjection> fieldList, boolean mapFields, GenerationType generationType, TypeName forcedReturnType, JavadocPart... javadocParts) {
    SQLiteDaoDefinition daoDefinition = method.getParent();
    SQLiteEntity entity = daoDefinition.getEntity();
    // if true, field must be associate to ben attributes
    // TypeName returnType = method.getReturnClass();
    TypeName returnTypeName = forcedReturnType;
    if (returnTypeName == null) {
        returnTypeName = method.getReturnClass();
    }
    ModelAnnotation annotation = method.getAnnotation(BindSqlSelect.class);
    // parameters
    List<String> paramNames = new ArrayList<String>();
    List<String> paramGetters = new ArrayList<String>();
    List<TypeName> paramTypeNames = new ArrayList<TypeName>();
    List<String> usedBeanPropertyNames = new ArrayList<>();
    // used method parameters
    Set<String> usedMethodParameters = new HashSet<String>();
    final One<String> whereJQL = new One<>("");
    final One<String> havingJQL = new One<>("");
    final One<String> groupJQL = new One<>("");
    final One<String> orderJQL = new One<>("");
    // extract parts of jql statement
    JQLChecker.getInstance().replaceVariableStatements(method, method.jql.value, new JQLReplaceVariableStatementListenerImpl() {

        @Override
        public String onWhere(String statement) {
            whereJQL.value0 = statement;
            return null;
        }

        @Override
        public String onOrderBy(String statement) {
            orderJQL.value0 = statement;
            return null;
        }

        @Override
        public String onHaving(String statement) {
            havingJQL.value0 = statement;
            return null;
        }

        @Override
        public String onGroup(String statement) {
            groupJQL.value0 = statement;
            return null;
        }
    });
    SqlAnalyzer analyzer = new SqlAnalyzer();
    // String whereSQL =
    // annotation.getAttribute(AnnotationAttributeType.WHERE);
    analyzer.execute(BaseProcessor.elementUtils, method, whereJQL.value0);
    paramGetters.addAll(analyzer.getParamGetters());
    paramNames.addAll(analyzer.getParamNames());
    paramTypeNames.addAll(analyzer.getParamTypeNames());
    usedBeanPropertyNames.addAll(analyzer.getUsedBeanPropertyNames());
    usedMethodParameters.addAll(analyzer.getUsedMethodParameters());
    // String havingSQL =
    // annotation.getAttribute(AnnotationAttributeType.HAVING);
    analyzer.execute(BaseProcessor.elementUtils, method, havingJQL.value0);
    paramGetters.addAll(analyzer.getParamGetters());
    paramNames.addAll(analyzer.getParamNames());
    paramTypeNames.addAll(analyzer.getParamTypeNames());
    usedBeanPropertyNames.addAll(analyzer.getUsedBeanPropertyNames());
    usedMethodParameters.addAll(analyzer.getUsedMethodParameters());
    // String groupBySQL =
    // annotation.getAttribute(AnnotationAttributeType.GROUP_BY);
    analyzer.execute(BaseProcessor.elementUtils, method, groupJQL.value0);
    paramGetters.addAll(analyzer.getParamGetters());
    paramNames.addAll(analyzer.getParamNames());
    paramTypeNames.addAll(analyzer.getParamTypeNames());
    usedBeanPropertyNames.addAll(analyzer.getUsedBeanPropertyNames());
    usedMethodParameters.addAll(analyzer.getUsedMethodParameters());
    // String orderBySQL =
    // annotation.getAttribute(AnnotationAttributeType.ORDER_BY);
    analyzer.execute(BaseProcessor.elementUtils, method, orderJQL.value0);
    paramGetters.addAll(analyzer.getParamGetters());
    paramNames.addAll(analyzer.getParamNames());
    paramTypeNames.addAll(analyzer.getParamTypeNames());
    usedBeanPropertyNames.addAll(analyzer.getUsedBeanPropertyNames());
    usedMethodParameters.addAll(analyzer.getUsedMethodParameters());
    // add as used parameter dynamic components too
    if (method.hasDynamicWhereConditions()) {
        AssertKripton.assertTrueOrInvalidMethodSignException(!usedMethodParameters.contains(method.dynamicWhereParameterName), method, " parameter %s is used like SQL parameter and dynamic WHERE condition.", method.dynamicOrderByParameterName);
        usedMethodParameters.add(method.dynamicWhereParameterName);
        if (method.hasDynamicWhereArgs()) {
            AssertKripton.assertTrueOrInvalidMethodSignException(!usedMethodParameters.contains(method.dynamicWhereArgsParameterName), method, " parameter %s is used like SQL parameter and dynamic WHERE ARGS condition.", method.dynamicWhereArgsParameterName);
            usedMethodParameters.add(method.dynamicWhereArgsParameterName);
        }
    }
    if (method.hasDynamicOrderByConditions()) {
        AssertKripton.assertTrueOrInvalidMethodSignException(!usedMethodParameters.contains(method.dynamicOrderByParameterName), method, " parameter %s is used like SQL parameter and dynamic ORDER BY condition.", method.dynamicOrderByParameterName);
        usedMethodParameters.add(method.dynamicOrderByParameterName);
    }
    if (method.hasDynamicPageSizeConditions()) {
        AssertKripton.assertTrueOrInvalidMethodSignException(!usedMethodParameters.contains(method.dynamicPageSizeName), method, " parameter %s is used like SQL parameter and dynamic page size of LIMIT condition.", method.dynamicPageSizeName);
        usedMethodParameters.add(method.dynamicPageSizeName);
    }
    // generate method signature
    if (generationType.generateMethodSign) {
        generateMethodSignature(method, methodBuilder, returnTypeName);
    }
    // generate javadoc
    JavadocUtility.generateJavaDocForSelect(methodBuilder, paramNames, method, annotation, fieldList, selectType, javadocParts);
    if (generationType.generateMethodContent) {
        SplittedSql splittedSql = SqlSelectBuilder.generateSQL(method, methodBuilder, false);
        // retrieve content values
        methodBuilder.addStatement("$T _contentValues=contentValues()", KriptonContentValues.class);
        if (method.hasDynamicParts()) {
            generateSQLBuild(method, methodBuilder, splittedSql);
            methodBuilder.addStatement("String _sql=_sqlBuilder.toString()");
        } else {
            String sqlName = CaseFormat.LOWER_CAMEL.to(CaseFormat.UPPER_UNDERSCORE, method.buildSQLName());
            String sql = SqlSelectBuilder.convertJQL2SQL(method, true);
            classBuilder.addField(FieldSpec.builder(String.class, sqlName, Modifier.PRIVATE, Modifier.STATIC, Modifier.FINAL).initializer("$S", sql).build());
            methodBuilder.addComment("query SQL is statically defined");
            methodBuilder.addStatement("String _sql=$L", sqlName);
        }
        // build where condition (common for every type of select)
        StringBuilder logArgsBuffer = new StringBuilder();
        methodBuilder.addComment("add where arguments");
        {
            String separator = "";
            TypeName paramTypeName;
            // String paramName;
            boolean nullable;
            int i = 0;
            boolean rawParameters;
            String beanName = null;
            beanName = method.findEntityProperty();
            for (String item : paramGetters) {
                rawParameters = paramNames.get(i).indexOf(".") == -1;
                methodBuilder.addCode("_contentValues.addWhereArgs(");
                logArgsBuffer.append(separator + "%s");
                paramTypeName = paramTypeNames.get(i);
                // code for query arguments
                nullable = TypeUtility.isNullable(paramTypeName);
                if (rawParameters) {
                    if (nullable && !method.hasAdapterForParam(item)) {
                        methodBuilder.addCode("($L==null?\"\":", item);
                    }
                    // check for string conversion
                    TypeUtility.beginStringConversion(methodBuilder, paramTypeName);
                    SQLTransformer.javaMethodParam2WhereConditions(methodBuilder, method, item, paramTypeName);
                    // check for string conversion
                    TypeUtility.endStringConversion(methodBuilder, paramTypeName);
                    if (nullable && !method.hasAdapterForParam(item)) {
                        methodBuilder.addCode(")");
                    }
                } else {
                    // eventually we take associated property
                    SQLProperty property = usedBeanPropertyNames.get(i) == null ? null : entity.get(usedBeanPropertyNames.get(i));
                    if (nullable && !(property != null) && !method.hasAdapterForParam(item)) {
                        methodBuilder.addCode("($L==null?\"\":", item);
                    }
                    // check for string conversion
                    TypeUtility.beginStringConversion(methodBuilder, paramTypeName);
                    // if (property != null) {
                    // SQLTransformer.javaProperty2WhereCondition(methodBuilder,
                    // method, item, paramTypeName, property);
                    // } else {
                    SQLTransformer.javaProperty2WhereCondition(methodBuilder, method, beanName, paramTypeName, property);
                    // }
                    // check for string conversion
                    TypeUtility.endStringConversion(methodBuilder, paramTypeName);
                    if (nullable && !(property != null) && !method.hasAdapterForParam(item)) {
                        methodBuilder.addCode(")");
                    }
                }
                separator = ", ";
                i++;
                methodBuilder.addCode(");\n");
            }
        }
        methodBuilder.addStatement("String[] _sqlArgs=_contentValues.whereArgsAsArray()");
        if (daoDefinition.isLogEnabled()) {
            // generate log section - BEGIN
            methodBuilder.addComment("log section BEGIN");
            methodBuilder.beginControlFlow("if (_context.isLogEnabled())");
            // manage log
            methodBuilder.addComment("manage log");
            methodBuilder.addStatement("$T.info(_sql)", Logger.class);
            // log for where parames
            SqlBuilderHelper.generateLogForWhereParameters(method, methodBuilder);
            // generate log section - END
            methodBuilder.endControlFlow();
            methodBuilder.addComment("log section END");
        }
        if (generationType.generateCloseableCursor) {
            methodBuilder.beginControlFlow("try ($T _cursor = database().rawQuery(_sql, _sqlArgs))", Cursor.class);
        } else {
            methodBuilder.addStatement("$T _cursor = database().rawQuery(_sql, _sqlArgs)", Cursor.class);
        }
        if (daoDefinition.isLogEnabled()) {
            // generate log section - BEGIN
            methodBuilder.addComment("log section BEGIN");
            methodBuilder.beginControlFlow("if (_context.isLogEnabled())");
            methodBuilder.addCode("$T.info(\"Rows found: %s\",_cursor.getCount());\n", Logger.class);
            // generate log section - END
            methodBuilder.endControlFlow();
            methodBuilder.addComment("log section END");
        }
        switch(selectType) {
            case LISTENER_CURSOR:
                {
                    ClassName readCursorListenerToExclude = ClassName.get(OnReadCursorListener.class);
                    checkUnusedParameters(method, usedMethodParameters, readCursorListenerToExclude);
                }
                break;
            case LISTENER_BEAN:
                {
                    ParameterizedTypeName readBeanListenerToExclude = ParameterizedTypeName.get(ClassName.get(OnReadBeanListener.class), TypeName.get(entity.getElement().asType()));
                    checkUnusedParameters(method, usedMethodParameters, readBeanListenerToExclude);
                }
                break;
            default:
                checkUnusedParameters(method, usedMethodParameters, null);
                break;
        }
    }
}

Example 79 with ParameterizedTypeName

use of com.squareup.javapoet.ParameterizedTypeName in project kripton by xcesco.

the class AbstractCollectionBindTransform method generateParseOnJacksonInternal.

public void generateParseOnJacksonInternal(BindTypeContext context, Builder methodBuilder, String parserName, TypeName beanClass, String beanName, BindProperty property, boolean onString) {
    TypeName elementTypeName = extractTypeParameterName(property);
    // @formatter:off
    methodBuilder.beginControlFlow("if ($L.currentToken()==$T.START_ARRAY)", parserName, JsonToken.class);
    if (collectionType == CollectionType.ARRAY) {
        methodBuilder.addStatement("$T<$T> collection=new $T<>()", ArrayList.class, elementTypeName.box(), ArrayList.class);
    } else {
        // it's for sure a parametrized type
        ParameterizedTypeName collectionTypeName = (ParameterizedTypeName) property.getPropertyType().getTypeName();
        methodBuilder.addStatement("$T<$T> collection=new $T<>()", defineCollectionClass(collectionTypeName), elementTypeName.box(), defineCollectionClass(collectionTypeName));
    }
    methodBuilder.addStatement("$T item=$L", elementTypeName.box(), DEFAULT_VALUE);
    if (onString) {
        methodBuilder.addStatement("String tempValue=null");
    }
    BindTransform transform = BindTransformer.lookup(elementTypeName);
    BindProperty elementProperty = BindProperty.builder(elementTypeName, property).inCollection(true).nullable(false).build();
    methodBuilder.beginControlFlow("while ($L.nextToken() != $T.END_ARRAY)", parserName, JsonToken.class);
    if (onString) {
        methodBuilder.addStatement("tempValue=$L.getValueAsString()", parserName);
        methodBuilder.beginControlFlow("if ($L.currentToken()==$T.VALUE_STRING && \"null\".equals(tempValue))", parserName, JsonToken.class);
    } else {
        methodBuilder.beginControlFlow("if ($L.currentToken()==$T.VALUE_NULL)", parserName, JsonToken.class);
    }
    methodBuilder.addStatement("item=$L", DEFAULT_VALUE);
    methodBuilder.nextControlFlow("else");
    if (onString) {
        transform.generateParseOnJacksonAsString(context, methodBuilder, parserName, null, "item", elementProperty);
    } else {
        transform.generateParseOnJackson(context, methodBuilder, parserName, null, "item", elementProperty);
    }
    methodBuilder.endControlFlow();
    methodBuilder.addStatement("collection.add(item)");
    methodBuilder.endControlFlow();
    if (collectionType == CollectionType.ARRAY) {
        if (TypeUtility.isTypePrimitive(elementTypeName)) {
            methodBuilder.addStatement(setter(beanClass, beanName, property, "$T.as$TTypeArray(collection)"), CollectionUtils.class, elementTypeName.box());
        } else if (TypeUtility.isTypeWrappedPrimitive(elementTypeName)) {
            methodBuilder.addStatement(setter(beanClass, beanName, property, "$T.as$TArray(collection)"), CollectionUtils.class, elementTypeName);
        } else {
            methodBuilder.addStatement(setter(beanClass, beanName, property, "$T.asArray(collection, new $T[collection.size()])"), CollectionUtils.class, elementTypeName);
        }
    } else {
        methodBuilder.addStatement(setter(beanClass, beanName, property, "collection"));
    }
    if (onString) {
        // ELSE: check if empty string (== empty collection but not null)
        methodBuilder.nextControlFlow("else if ($L.currentToken()==$T.VALUE_STRING && !$T.hasText($L.getValueAsString()))", parserName, JsonToken.class, StringUtils.class, parserName);
        // create collection
        if (collectionType == CollectionType.ARRAY) {
            methodBuilder.addStatement("$T<$T> collection=new $T<>()", ArrayList.class, elementTypeName.box(), ArrayList.class);
        } else {
            // it's for sure a parametrized type
            ParameterizedTypeName collectionTypeName = (ParameterizedTypeName) property.getPropertyType().getTypeName();
            methodBuilder.addStatement("$T<$T> collection=new $T<>()", defineCollectionClass(collectionTypeName), elementTypeName.box(), defineCollectionClass(collectionTypeName));
        }
        // set collection
        if (collectionType == CollectionType.ARRAY) {
            if (TypeUtility.isTypePrimitive(elementTypeName)) {
                methodBuilder.addStatement(setter(beanClass, beanName, property, "$T.as$TTypeArray(collection)"), CollectionUtils.class, elementTypeName.box());
            } else if (TypeUtility.isTypeWrappedPrimitive(elementTypeName)) {
                methodBuilder.addStatement(setter(beanClass, beanName, property, "$T.as$TArray(collection)"), CollectionUtils.class, elementTypeName.box());
            } else {
                methodBuilder.addStatement(setter(beanClass, beanName, property, "$T.asArray(collection, new $T[collection.size()])"), CollectionUtils.class, elementTypeName);
            }
        } else {
            methodBuilder.addStatement(setter(beanClass, beanName, property, "collection"));
        }
    // END: we use the next endControlFlow
    }
    methodBuilder.endControlFlow();
// @formatter:on
}

Example 80 with ParameterizedTypeName

use of com.squareup.javapoet.ParameterizedTypeName in project kripton by xcesco.

the class AbstractCollectionBindTransform method generateParseOnXml.

@Override
public void generateParseOnXml(BindTypeContext context, MethodSpec.Builder methodBuilder, String parserName, TypeName beanClass, String beanName, BindProperty property) {
    TypeName elementTypeName = extractTypeParameterName(property);
    // @formatter:off
    methodBuilder.beginControlFlow("");
    switch(collectionType) {
        case ARRAY:
            methodBuilder.addStatement("$T<$T> collection=new $T<>()", ArrayList.class, elementTypeName.box(), ArrayList.class);
            break;
        case LIST:
        case SET:
            // it's for sure a parametrized type
            ParameterizedTypeName collectionTypeName = (ParameterizedTypeName) property.getPropertyType().getTypeName();
            methodBuilder.addStatement("$T<$T> collection=new $T<>()", defineCollectionClass(collectionTypeName), elementTypeName.box(), defineCollectionClass(collectionTypeName));
            break;
    }
    methodBuilder.addStatement("$T item", elementTypeName.box());
    BindTransform transform = BindTransformer.lookup(elementTypeName);
    BindProperty elementProperty = BindProperty.builder(elementTypeName, property).inCollection(true).build();
    if (property.xmlInfo.isWrappedCollection()) {
        // with wrap element
        methodBuilder.beginControlFlow("while ($L.nextTag() != $T.END_TAG && $L.getName().toString().equals($S))", parserName, XmlPullParser.class, parserName, property.xmlInfo.labelItem);
    } else {
        // no wrap element
        methodBuilder.addCode("// add first element\n");
        methodBuilder.addStatement("item=$L", DEFAULT_VALUE);
        methodBuilder.beginControlFlow("if ($L.isEmptyElement())", parserName);
        methodBuilder.addCode("// if there's a an empty collection it marked with attribute emptyCollection\n");
        methodBuilder.beginControlFlow("if ($T.getAttributeAsBoolean($L, $S, false)==false)", XmlAttributeUtils.class, parserName, EMPTY_COLLECTION_ATTRIBUTE_NAME);
        methodBuilder.addStatement("collection.add(item)");
        methodBuilder.endControlFlow();
        methodBuilder.addStatement("$L.nextTag()", parserName);
        methodBuilder.nextControlFlow("else");
        transform.generateParseOnXml(context, methodBuilder, parserName, null, "item", elementProperty);
        methodBuilder.addStatement("collection.add(item)");
        methodBuilder.endControlFlow();
        methodBuilder.beginControlFlow("while ($L.nextTag() != $T.END_TAG && $L.getName().toString().equals($S))", parserName, XmlPullParser.class, parserName, property.label);
    }
    // for all
    methodBuilder.beginControlFlow("if ($L.isEmptyElement())", parserName);
    methodBuilder.addStatement("item=$L", DEFAULT_VALUE);
    methodBuilder.addStatement("$L.nextTag()", parserName);
    methodBuilder.nextControlFlow("else");
    transform.generateParseOnXml(context, methodBuilder, parserName, null, "item", elementProperty);
    methodBuilder.endControlFlow();
    methodBuilder.addStatement("collection.add(item)");
    methodBuilder.endControlFlow();
    if (collectionType == CollectionType.ARRAY) {
        if (TypeUtility.isTypePrimitive(elementTypeName)) {
            methodBuilder.addStatement(setter(beanClass, beanName, property, "$T.as$TTypeArray(collection)"), CollectionUtils.class, elementTypeName.box());
        } else if (TypeUtility.isTypeWrappedPrimitive(elementTypeName)) {
            methodBuilder.addStatement(setter(beanClass, beanName, property, "$T.as$TArray(collection)"), CollectionUtils.class, elementTypeName);
        } else {
            methodBuilder.addStatement(setter(beanClass, beanName, property, "$T.asArray(collection, new $T[collection.size()])"), CollectionUtils.class, elementTypeName);
        }
    } else {
        methodBuilder.addStatement(setter(beanClass, beanName, property, "collection"));
    }
    if (!property.xmlInfo.isWrappedCollection()) {
        methodBuilder.addStatement("read=false");
    }
    methodBuilder.endControlFlow();
// @formatter:on
}