Build the code for the parameters of a method call.

@param builder the code builder
@param parameters the parameters

@return the code
502380
private CodeBlock methodCallParametersCode( CodeBlock.Builder builder, List<CodeBlock> parameters ) {
        if ( parameters.isEmpty() ) {
            return builder.add( "()" ).build();
        }

        builder.add( "(" );

        Iterator<CodeBlock> iterator = parameters.iterator();
        builder.add( iterator.next() );

        while ( iterator.hasNext() ) {
            builder.add( ", " );
            builder.add( iterator.next() );
        }

        builder.add( ")" );
        return builder.build();
    }
245859
public Node createOptionalParameters(JSType... parameterTypes) {
    FunctionParamBuilder builder = new FunctionParamBuilder(this);
    builder.addOptionalParams(parameterTypes);
    return builder.build();
  }
928356
public MethodDeclarationBuilder param(Type type, String name) {
    return new MethodDeclarationBuilder(
            builder,
            classIdentifier,
            memberFlags,
            returnType,
            methodName,
            methodHandler,
            parameters.append(new Parameter(type, name, parameters.size())));
  }
125029
@Nonnull
	public static IntToDoubleFunction intToDblFunctionFrom(Consumer<IntToDoubleFunctionBuilder> buildingFunction) {
		IntToDoubleFunctionBuilder builder = new IntToDoubleFunctionBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
726274
@Nonnull
	public static <T, R> LObjIntFltFunction<T, R> objIntFltFunctionFrom(Consumer<LObjIntFltFunctionBuilder<T, R>> buildingFunction) {
		LObjIntFltFunctionBuilder builder = new LObjIntFltFunctionBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
82351
@Nonnull
	public static <T1, T2> ToDoubleBiFunction<T1, T2> toDblBiFunctionFrom(Consumer<ToDoubleBiFunctionBuilder<T1, T2>> buildingFunction) {
		ToDoubleBiFunctionBuilder builder = new ToDoubleBiFunctionBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
283247
@Nonnull
	public static <T, R> LObjBiIntFunction<T, R> objBiIntFunctionFrom(Consumer<LObjBiIntFunctionBuilder<T, R>> buildingFunction) {
		LObjBiIntFunctionBuilder builder = new LObjBiIntFunctionBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
204429
@Nonnull
	public static <R> IntFunction<R> intFunctionFrom(Consumer<IntFunctionBuilder<R>> buildingFunction) {
		IntFunctionBuilder builder = new IntFunctionBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
709501
@Nonnull
	public static LByteToFltFunction byteToFltFunctionFrom(Consumer<LByteToFltFunctionBuilder> buildingFunction) {
		LByteToFltFunctionBuilder builder = new LByteToFltFunctionBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
850457
private CodeBlock methodCallCodeWithJMapperTypeParameters( CodeBlock.Builder builder, ImmutableList<? extends JMapperType> parameters
    ) {
        return methodCallParametersCode( builder, Lists.transform( parameters, new Function<JMapperType, CodeBlock>() {

            @Override
            public CodeBlock apply( JMapperType jMapperType ) {
                return jMapperType.getInstance();
            }
        } ) );
    }
1216035
@Nonnull
	public static LCharToFltFunction charToFltFunctionFrom(Consumer<LCharToFltFunctionBuilder> buildingFunction) {
		LCharToFltFunctionBuilder builder = new LCharToFltFunctionBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
847923
private static Iterable<ParameterSpec> parameters(Iterable<Parameter> parameters) {
    ImmutableList.Builder<ParameterSpec> builder = ImmutableList.builder();
    for (Parameter parameter : parameters) {
      ParameterSpec.Builder parameterBuilder =
          ParameterSpec.builder(TypeName.get(parameter.type()), parameter.name());
      for (AnnotationMirror annotation :
          Iterables.concat(parameter.nullable().asSet(), parameter.key().qualifier().asSet())) {
        parameterBuilder.addAnnotation(AnnotationSpec.get(annotation));
      }
      builder.add(parameterBuilder.build());
    }
    return builder.build();
  }
415125
public static Description buildDescriptionWith(Consumer<DescriptionBuilder> builder) {
        DescriptionBuilder builder1 = builder();
        builder.accept(builder1);
        return builder1.build();
    }
561669
private void buildConstructor( TypeSpec.Builder typeBuilder ) {
        MethodSpec.Builder constructorBuilder = MethodSpec.constructorBuilder().addModifiers( Modifier.PUBLIC );

        if ( !beanInfo.getParameterizedTypes().isEmpty() ) {
            Class mapperClass;
            String mapperNameFormat;
            if ( isSerializer() ) {
                mapperClass = Serializer.class;
                mapperNameFormat = TYPE_PARAMETER_SERIALIZER_FIELD_NAME;
            } else {
                mapperClass = Deserializer.class;
                mapperNameFormat = TYPE_PARAMETER_DESERIALIZER_FIELD_NAME;
            }

            for ( int i = 0; i < beanInfo.getParameterizedTypes().size(); i++ ) {
                JClassType argType = beanInfo.getParameterizedTypes().get( i );
                String mapperName = String.format( mapperNameFormat, i );
                TypeName mapperType = parameterizedName( mapperClass, argType );

                FieldSpec field = FieldSpec.builder( mapperType, mapperName, Modifier.PRIVATE, Modifier.FINAL ).build();
                typeBuilder.addField( field );

                ParameterSpec parameter = ParameterSpec.builder( mapperType, mapperName ).build();
                constructorBuilder.addParameter( parameter );
                constructorBuilder.addStatement( "this.$N = $N", field, parameter );
            }
        }

        typeBuilder.addMethod( constructorBuilder.build() );
    }
1235514
private MethodSpec.Builder createOptionsMethodBuilder() {
    TypeName optionsTypeName =
        ParameterizedTypeName.get(ClassName.get(VueComponentOptions.class),
            ClassName.get(component));

    MethodSpec.Builder optionsMethodBuilder = MethodSpec
        .methodBuilder("getOptions")
        .addModifiers(Modifier.PUBLIC)
        .returns(optionsTypeName)
        .addStatement("$T options = new $T()", optionsTypeName, optionsTypeName)
        .addStatement("Proto p = __proto__");

    Component annotation = component.getAnnotation(Component.class);

    if (!"".equals(annotation.name())) {
      optionsMethodBuilder.addStatement("options.setName($S)", annotation.name());
    }

    optionsMethodBuilder.addStatement(
        "options.setComponentExportedTypePrototype(p)",
        VueGWT.class,
        component);

    return optionsMethodBuilder;
  }
814426
@Nonnull
	public static <T> ToDoubleFunction<T> toDblFunctionFrom(Consumer<ToDoubleFunctionBuilder<T>> buildingFunction) {
		ToDoubleFunctionBuilder builder = new ToDoubleFunctionBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
1110590
@Nonnull
	public static LByteToSrtFunction byteToSrtFunctionFrom(Consumer<LByteToSrtFunctionBuilder> buildingFunction) {
		LByteToSrtFunctionBuilder builder = new LByteToSrtFunctionBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}