How to use

toInternalReference

method

in

io.sundr.codegen.model.TypeDef

  public void visit(ClassRefBuilder builder) {
    List<TypeRef> updatedArguments = new ArrayList<TypeRef>();
    for (TypeRef arg : builder.getArguments()) {
      if (arg.equals(builderType.toInternalReference())) {
        updatedArguments.add(shallowInlineType.toInternalReference());
      } else {
        updatedArguments.add(arg);
      }
    }
    builder.withArguments(updatedArguments);
  }
}).build();

public static Set<ClassRef> extractInterfacesFromType(TypeDef type) {
  Set<ClassRef> result = new LinkedHashSet<ClassRef>();
  if (type.getExtendsList().isEmpty()) {
    result.add(type.toInternalReference());
  } else {
    for (ClassRef interfaceType : type.getExtendsList()) {
      result.addAll(extractInterfacesFromClassRef(interfaceType));
    }
  }
  return result;
}

private Map<String, String> getReferenceMapInternal() {
  Map<String, String> mapping = new HashMap<String, String>();
  List<ClassRef> refs = new ArrayList<ClassRef>();
  for (TypeDef typeDef : getDefinitions()) {
    refs.add(typeDef.toInternalReference());
  }
  //It's best to have predictable order, so that we can generate uniform code.
  Collections.sort(refs, new Comparator<ClassRef>() {
    @Override
    public int compare(ClassRef o1, ClassRef o2) {
      return o1.getFullyQualifiedName().compareTo(o2.getFullyQualifiedName());
    }
  });
  for (ClassRef classRef : refs) {
    String key = classRef.getDefinition().getName();
    if (!mapping.containsKey(key)) {
      mapping.put(key, classRef.getDefinition().getFullyQualifiedName());
    }
  }
  mapping.putAll(custom);
  return mapping;
}

for (TypeDef alternative : alternatives) {
  if (!canBeExcluded(alternative, alternatives)) {
    interfaces.add(alternative.toInternalReference());
    terminatingTypes.addAll(getTerminatingTypes(alternative));
  interfaces.add(fallback.toInternalReference());
  terminatingTypes.addAll(getTerminatingTypes(fallback));
  for (TypeParamDef candidate : extractParameters(fallback)) {

  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();
  }
};

public ClassRef apply(Node<TypeDef> current) {
  if (current.getTransitions().isEmpty()) {
    return current.getItem().toInternalReference();
  } else {
    TypeDef clazz = current.getItem();
        : Combine.TYPEREFS.apply(Generify.CLASSREFS.apply(toCombine)).toInternalReference();
      toReCombine.add(selfRef);
      TypeDef reCombinedType = Combine.TYPEREFS.apply(toReCombine);
      final ClassRef reCombinedRef = reCombinedType.toInternalReference();
      ClassRef reCombined = reCombinedType.toInternalReference();
      reCombined = Combine.TYPEREFS.apply(toReCombine).toInternalReference();
      DslContextManager.getContext().getDefinitionRepository().register(reCombinedType, IS_GENERATED);
      DslContextManager.getContext().getDefinitionRepository().register(nextClazz.getDefinition(), IS_GENERATED);

public static ClassRef buildableRef(TypeRef typeRef) {
  ClassRef unwrapped = (ClassRef) TypeAs.combine(UNWRAP_COLLECTION_OF, UNWRAP_ARRAY_OF, UNWRAP_OPTIONAL_OF).apply(typeRef);
  return isAbstract(unwrapped) || unwrapped.getDefinition().getKind() == Kind.INTERFACE ? TypeAs.VISITABLE_BUILDER.apply(unwrapped) : TypeAs.BUILDER.apply(unwrapped.getDefinition()).toInternalReference();
}

  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();
  }
};

if (returnType instanceof ClassRef) {
  TypeDef toUnwrap = ((ClassRef)returnType).getDefinition();
  methods.add(new MethodBuilder(m).withReturnType(Generics.UNWRAP.apply(toUnwrap).toInternalReference()).build());
} else if (returnType.getAttributes().containsKey(ORIGINAL_REF)) {
  methods.add(new MethodBuilder(m).withReturnType((TypeRef) returnType.getAttributes().get(ORIGINAL_REF)).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();
}

alsoImport.add(builder.toInternalReference());

  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();
  }
};

refs.add(typeDef.toInternalReference());

.withReturnType(builderType.toInternalReference())
.withName("edit")
.withNewBlock()

baseType = propertyTypeDef.toInternalReference();

baseType = propertyTypeDef.toInternalReference();

baseType = propertyTypeDef.toInternalReference();

String ownPrefix = isCollection ? "addNew" : "withNew";
ownPrefix += BuilderUtils.fullyQualifiedNameDiff(baseType.toInternalReference(), originTypeDef);
String ownName = ownPrefix + (isCollection
    ? Singularize.FUNCTION.apply(property.getNameCapitalized())

baseType = propertyTypeDef.toInternalReference();

ClassRef unwrapped = (ClassRef) TypeAs.combine(UNWRAP_COLLECTION_OF, UNWRAP_ARRAY_OF, UNWRAP_OPTIONAL_OF).apply(typeRef);
ClassRef classRef = (ClassRef) typeRef;
ClassRef builderType = isAbstract(unwrapped) ||  unwrapped.getDefinition().getKind() == Kind.INTERFACE  ? TypeAs.VISITABLE_BUILDER.apply(unwrapped) : TypeAs.BUILDER.apply(unwrapped.getDefinition()).toInternalReference();