How to use

toReference

method

in

io.sundr.codegen.model.TypeDef

public TypeRef apply(TypeRef item) {
  return Collections.LIST.toReference(item);
  //TODO: Need a home for: .withDefaultImplementation(Constants.ARRAY_LIST)
}

/**
 * Creates a {@link ClassRef} for the current definition with the specified arguments.
 *
 * @param arguments The arguments to be passed to the reference.
 */
public ClassRef toReference(Collection<TypeRef> arguments) {
  return toReference(arguments);
}

  public ClassRef transition(TypeDef from, ClassRef to) {
    return from.toReference(to);
  }
};

public TypeRef apply(TypeRef item) {
  return Collections.ARRAY_LIST.toReference(item);
}

private String usingConstructor(List<String> item) {
  int size = item != null ? item.size() : 0;
  checkConstructorArguments(size);
  if (size == 0) {
    return "new " + typeDef.toReference(parameters) + "()";
  }
  return "new " + typeDef.toReference(parameters) + "(" + item.stream().collect(Collectors.joining(", ")) + ")";
}

  public ClassRef apply(TypeDef item) {
    List<TypeRef> parameters = new ArrayList<TypeRef>();
    for (TypeParamDef param : item.getParameters()) {
      parameters.add(param.toReference());
    }
    parameters.add(Q);
    return SHALLOW_FLUENT.apply(item).toReference(parameters);
  }
};

  && (extendsList.size() != 1 || !extendsList.contains(OBJECT.toReference()))) {
sb.append(SPACE).append(EXTENDS).append(SPACE);
sb.append(StringUtils.join(extendsList, COMA));

  public TypeDef apply(TypeDef item) {
    TypeDef builder = SHALLOW_BUILDER.apply(item);
    TypeDef fluent = FLUENT_IMPL.apply(item);
    List<TypeRef> parameters = new ArrayList<TypeRef>();
    for (TypeParamDef param : item.getParameters()) {
      parameters.add(param.toReference());
    }
    parameters.add(builder.toInternalReference());
    return new TypeDefBuilder(item)
        .withKind(Kind.CLASS)
        .withModifiers(TypeUtils.modifiersToInt(Modifier.PUBLIC))
        .withName(item.getName() + "Builder")
        .withParameters(item.getParameters())
        .withInnerTypes()
        .withExtendsList(fluent.toReference(parameters))
        .withImplementsList(BuilderContextManager.getContext().getVisitableBuilderInterface().toReference(item.toInternalReference(), builder.toInternalReference()))
        .build();
  }
};

  @Override
  public Method apply(Property property) {
    Method method = WITH_NEW_LIKE_NESTED.apply(property);
    if (!(property.getTypeRef() instanceof ClassRef)) {
      throw new IllegalStateException("Expected Nestable / Buildable type and found:" + property.getTypeRef());
    }
    ClassRef baseType = (ClassRef) TypeAs.UNWRAP_COLLECTION_OF.apply(property.getTypeRef());
    TypeRef returnType = property.hasAttribute(GENERIC_TYPE_REF) ? property.getAttribute(GENERIC_TYPE_REF) : T_REF;
    TypeDef nestedTypeImpl = PropertyAs.NESTED_CLASS_TYPE.apply(property);
    List<TypeRef> typeArguments = new ArrayList<TypeRef>();
    for (TypeRef ignore : baseType.getArguments()) {
      typeArguments.add(Q);
    }
    typeArguments.add(returnType);
    ClassRef rewrapedImpl = nestedTypeImpl.toReference(typeArguments);
    return new MethodBuilder(method)
        .addToArguments(0, INDEX)
        .withName(method.getName().replaceFirst("add", "set"))
        .editBlock()
        .withStatements(new StringStatement("return new " + rewrapedImpl.getName() + "(index, item);"))
        .endBlock()
        .build();
  }
};

  private static Method superConstructorOf(Method constructor, TypeDef constructorType) {
    List<AnnotationRef> annotations = new ArrayList<AnnotationRef>();
    for (AnnotationRef candidate : constructor.getAnnotations()) {
      if (!candidate.getClassRef().equals(BUILDABLE_ANNOTATION.getClassRef())) {
        annotations.add(candidate);
      }
    }

    return new MethodBuilder(constructor)
        .withAnnotations(annotations)
        .withReturnType(constructorType.toReference())
        .withNewBlock()
        .addNewStringStatementStatement("super(" + StringUtils.join(constructor.getArguments(), new Function<Property, String>() {
          public String apply(Property item) {
            return item.getName();
          }
        }, ", ") + ");")
        .endBlock()
        .build();
  }
}

  public ClassRef apply(TypeRef item) {
    TypeRef baseType = TypeAs.combine(UNWRAP_COLLECTION_OF, UNWRAP_ARRAY_OF).apply(item);
    if (baseType instanceof ClassRef) {
      baseType = new ClassRefBuilder((ClassRef)baseType).withArguments().build();
    }
    WildcardRef wildcardRef = new WildcardRefBuilder().addToBounds(baseType).build();
    return BuilderContextManager.getContext().getVisitableBuilderInterface().toReference(wildcardRef, Q);
  }
};

String builderClass = builder.toReference().getName();
statements.add(new StringStatement("if (" + argumentName + "!=null){ this." + fieldName + "= new " + builderClass + "(" + argumentName + "); _visitables.add(this." + fieldName + ");} return (" + returnType + ") this;"));
return statements;
  TypeRef dunwraped = combine(UNWRAP_COLLECTION_OF, UNWRAP_ARRAY_OF, UNWRAP_OPTIONAL_OF).apply(descendant.getTypeRef());
  TypeDef builder = BUILDER.apply(((ClassRef) dunwraped).getDefinition());
  String builderClass = builder.toReference().getName();
  statements.add(new StringStatement("if (" + argumentName + " instanceof " + dunwraped + "){ this." + fieldName + "= new " + builderClass + "((" + dunwraped + ")" + argumentName + "); _visitables.add(this." + fieldName + ");}"));

List<TypeRef> pivotParameters = new ArrayList<TypeRef>(superClassParameters);
pivotParameters.add(N.toReference());
superClassParameters.add(nested.toReference(pivotParameters));
    .withOuterType(outerInterface)
    .withImplementsList()
    .withExtendsList(BuilderContextManager.getContext().getNestedInterface().toReference(N.toReference()), superClassFluent)
    .build();

pivotParameters.add(N.toReference());
ClassRef nestedInterfaceRef = nestedInterfaceType.toReference(pivotParameters);
superClassParameters.add(nestedInterfaceRef);
    .withParameters(parameters)
    .withExtendsList(superClassFluent)
    .withImplementsList(nestedInterfaceRef, BuilderContextManager.getContext().getNestedInterface().toReference(N.toReference()))
    .build();

  public TypeDef apply(TypeDef item) {
    BuilderContext ctx = BuilderContextManager.getContext();
    TypeDef fluent = SHALLOW_FLUENT.apply(item);
    List<TypeParamDef> parameters = new ArrayList<TypeParamDef>(item.getParameters());
    List<TypeRef> superClassParameters = new ArrayList<TypeRef>();
    TypeParamDef nextParameter = getNextGeneric(item, parameters);
    ClassRef builableSuperClassRef = findBuildableSuperClassRef(item);
    TypeDef buildableSuperClass = findBuildableSuperClass(item);
    if (builableSuperClassRef != null) {
      superClassParameters.addAll(builableSuperClassRef.getArguments());
    }
    TypeParamDef parameterFluent = new TypeParamDefBuilder(nextParameter).addToBounds(fluent.toInternalReference()).build();
    parameters.add(parameterFluent);
    superClassParameters.add(parameterFluent.toReference());
    TypeDef superClass = buildableSuperClass != null
        ? SHALLOW_FLUENT.apply(buildableSuperClass)
        : ctx.getFluentInterface();
    return new TypeDefBuilder(item)
        .withKind(Kind.INTERFACE)
        .withModifiers(TypeUtils.modifiersToInt(Modifier.PUBLIC))
        .withName(item.getName() + "Fluent")
        .withPackageName(item.getPackageName())
        .withParameters(parameters)
        .withExtendsList(superClass.toReference(superClassParameters))
        .withImplementsList()
        .withInnerTypes()
        .build();
  }
};

public TypeDef apply(TypeDef item) {
  BuilderContext ctx = BuilderContextManager.getContext();
  TypeDef fluent = SHALLOW_FLUENT.apply(item);
  List<TypeParamDef> parameters = new ArrayList<TypeParamDef>(item.getParameters());
  List<TypeRef> superClassParameters = new ArrayList<TypeRef>();
  TypeParamDef nextParameter = getNextGeneric(item, parameters);
  ClassRef builableSuperClassRef = findBuildableSuperClassRef(item);
  if (builableSuperClassRef != null) {
    superClassParameters.addAll(builableSuperClassRef.getArguments());
  }
  TypeParamDef parameterFluent = new TypeParamDefBuilder(nextParameter).addToBounds(fluent.toInternalReference()).build();
  parameters.add(parameterFluent);
  superClassParameters.add(parameterFluent.toReference());
  TypeDef buildableSuperClass = findBuildableSuperClass(item);
  TypeDef superClass = buildableSuperClass != null
      ? FLUENT_IMPL.apply(buildableSuperClass)
      : ctx.getBaseFluentClass();
  return new TypeDefBuilder(item)
      .withKind(Kind.CLASS)
      .withModifiers(TypeUtils.modifiersToInt(Modifier.PUBLIC))
      .withName(item.getName() + "FluentImpl")
      .withPackageName(item.getPackageName())
      .withParameters(parameters)
      .withExtendsList(superClass.toReference(superClassParameters))
      .withImplementsList(SHALLOW_FLUENT.apply(item).toInternalReference())
      .withInnerTypes()
      .build();
}

  public TypeDef apply(TypeDef item) {
    List<TypeParamDef> parameters = new ArrayList<TypeParamDef>();
    for (TypeParamDef generic : item.getParameters()) {
      parameters.add(generic);
    }
    return new TypeDefBuilder(item)
        .withKind(Kind.CLASS)
        .withModifiers(TypeUtils.modifiersToInt(Modifier.PUBLIC))
        .withName("Editable" + item.getName())
        .withParameters(parameters)
        .withExtendsList(item.toInternalReference())
        .withImplementsList(BuilderContextManager.getContext().getEditableInterface().toReference(SHALLOW_BUILDER.apply(item).toInternalReference()))
        .withInnerTypes()
        .withProperties()
        .withMethods()
        .withConstructors()
        .build();
  }
};

ClassRef builderType = TypeAs.SHALLOW_BUILDER.apply(unwrappedClassRef.getDefinition()).toReference();
ClassRef rewraped = nestedType.toReference(typeArguments);

ClassRef rewraped = nestedType.toReference(typeArguments);
ClassRef rewrapedImpl = nestedTypeImpl.toReference(typeArguments);

ClassRef rewraped = nestedType.toReference(typeArguments);
ClassRef rewrapedImpl = nestedTypeImpl.toReference(typeArguments);