How to use

ConverterTypeElement

in

sk.seges.sesam.pap.model.model

  DtoDeclaredType rawDto = returnDtoType.getConverter().getConfiguration().getRawDto();
  nestedPrinter.print(new ServiceConverterProviderPrinterContext(rawDto, localMethod, returnDtoType.getConverter().getConfiguration()));
DtoType parameterDtoType = processingEnv.getTransferObjectUtils().getDtoType(dtoType);
if (parameterDtoType.getConverter() != null) {
  DomainDeclaredType rawDomain = parameterDtoType.getConverter().getConfiguration().getRawDomain();
  nestedPrinter.print(new ServiceConverterProviderPrinterContext(rawDomain, localMethod));

  @Override
  protected ParameterElement[] getConverterParameters(ConverterTypeElement converterTypeElement, ExecutableElement method) {
    
    if (converterTypeElement == null) {
      return parametersResolverProvider.getParameterResolver(usageType).getConstructorAditionalParameters();
    }
    
    return toParameters(converterTypeElement.getConverterParameters(parametersResolverProvider.getParameterResolver(usageType)));
  }
}

@Override
protected boolean checkPreconditions(ProcessorContext context, boolean alreadyExists) {
  if (!ConverterProcessingHelper.isConverterGenerated(context.getTypeElement(), processingEnv)) {
    return false;
  }
  ConfigurationTypeElement configurationElement = getConfigurationElement(context);
  ConverterTypeElement converter = configurationElement.getConverter();
  if (converter == null || !converter.isGenerated()) {
    return false;
  }
  return super.checkPreconditions(context, alreadyExists);
}
 

pw.print(context.getConverter().getConverterBase(), " " + converterName + " = ");
processingEnv.getUsedTypes().addAll(new TypeExtractor(true).extractDeclaredType(context.getConverter().getConfiguration().getDomain()));
Field field = new Field(
    (context.getDomainMethodReturnType().getKind().equals(MutableTypeKind.TYPEVAR) ? "(" + context.getConverter().getDomain().toString(ClassSerializer.SIMPLE, true) + ")" : "") +
    TransferObjectElementPrinter.DOMAIN_NAME  + "." + context.getDomainFieldName(), context.getConverter().getDomain());
TransferObjectMappingAccessor transferObjectMappingAccessor = new TransferObjectMappingAccessor(context.getDtoMethod(), processingEnv);
if (transferObjectMappingAccessor.isValid() && transferObjectMappingAccessor.getConverter() != null) {
  converterProviderPrinter.printDomainGetConverterMethodName(context.getConverter().getDomain(), field, null, pw, false);
} else {
  converterProviderPrinter.printObtainConverterFromCache(pw, ConverterTargetType.DOMAIN, context.getConverter().getConfiguration().getInstantiableDomain(), field, null, true);
MutableTypeMirror delegateCast = getDelegateCast(context.getConverter().getDomain(), false);

protected void printCopyByConverter(TransferObjectContext context, PathResolver domainPathResolver, FormattedPrintWriter pw) {
  String converterName = "converter" + MethodHelper.toMethod("", context.getDtoFieldName());
  pw.print(context.getConverter().getConverterBase(), " " + converterName + " = ");
  Field field = new Field((context.getDomainMethodReturnType().getKind().equals(MutableTypeKind.TYPEVAR) ? "(" + context.getConverter().getDto() + ")"
      : "") + TransferObjectElementPrinter.DTO_NAME + "." + MethodHelper.toGetter(context.getDtoFieldName()), context.getConverter().getDto());
  TransferObjectMappingAccessor transferObjectMappingAccessor = new TransferObjectMappingAccessor(context.getDtoMethod(), processingEnv);
  if (transferObjectMappingAccessor.isValid() && transferObjectMappingAccessor.getConverter() != null) {
    converterProviderPrinter.printDtoGetConverterMethodName(context.getConverter().getDto(), field, context.getDtoMethod(), pw, false);
  } else {
    converterProviderPrinter.printObtainConverterFromCache(pw, ConverterTargetType.DTO, context.getConverter().getDomain(), field,
        context.getDomainMethod(), true);
    pw.print(CastUtils.class, ".cast(");
  pw.print("(", getWildcardDelegate(context.getConverter().getDomain()), ")");
  pw.print(converterName + ".fromDto(");
    pw.print(CastUtils.class, ".cast(");
  } else {
    pw.print("(", context.getConverter().getDto() ,")");
    pw.print(", ", getTypeVariableDelegate(getDelegateCast(context.getConverter().getDto(), true)), ".class)");

@Override
protected void printAnnotations(ProcessorContext context) {
  
  FormattedPrintWriter pw = context.getPrintWriter();
  
  pw.println("@SuppressWarnings(\"serial\")");
  ConfigurationTypeElement configurationTypeElement = getConfigurationElement(context);
  
  pw.print("@", TransferObjectMapping.class, "(");
  pw.println("dtoClass = " + configurationTypeElement.getDto().getSimpleName() + ".class,");
  pw.println("		domainClassName = \"" + configurationTypeElement.getInstantiableDomainSpecified().getQualifiedName().toString() + "\", ");
  pw.println("		configurationClassName = \"" + context.getTypeElement().toString() + "\", ");
  pw.print("		generateConverter = false, generateDto = false");
  if (configurationTypeElement.getConverter() != null) {
    pw.println(", ");
    pw.print("		converterClassName = \"");
    pw.print(configurationTypeElement.getConverter().getCanonicalName());
    pw.print("\"");
  }
  
  pw.println(")");
  
  super.printAnnotations(context);
}

protected void printCopyNested(PathResolver domainPathResolver, String fullPath, DomainDeclaredType referenceDomainType, ExecutableElement method,
    FormattedPrintWriter pw, Field field, String dtoName) {
  DomainDeclaredType instantiableDomain = (DomainDeclaredType)referenceDomainType.getConverter().getInstantiableDomain();
  pw.print(referenceDomainType, " " + domainPathResolver.getCurrent() + " = ");
  if (instantiableDomain.getId(entityResolver) != null) {
    if (referenceDomainType.getConverter() == null) {
      processingEnv.getMessager().printMessage(Kind.ERROR, "[ERROR] No converter/configuration for " + referenceDomainType + " was found. Please, define configuration for "
          + referenceDomainType);
    }
    converterProviderPrinter.printObtainConverterFromCache(pw, ConverterTargetType.DTO, referenceDomainType, field, method, true);
    pw.println(".createDomainInstance(" + dtoName + "."
        + MethodHelper.toGetter(fullPath + MethodHelper.toMethod(MethodHelper.toField(instantiableDomain.getIdMethod(entityResolver)))) + ");");
  } else {
    pw.println(TransferObjectElementPrinter.RESULT_NAME + "." + MethodHelper.toGetter(domainPathResolver.getCurrent()) + ";");
    pw.println("if (" + domainPathResolver.getCurrent() + " == null) {");
    pw.print(domainPathResolver.getCurrent() + " = ");
    // TODO add NPE check
    converterProviderPrinter.printObtainConverterFromCache(pw, ConverterTargetType.DTO, referenceDomainType, field, method, true);
    pw.println(".createDomainInstance(null);");
    pw.println("}");
  }
}

private void collectTypeConverters(MutableTypeMirror type, Set<ConverterTypeElement> converters, List<ConverterConstructorParameter> parameters) {
  DtoType dtoType = processingEnv.getTransferObjectUtils().getDtoType(type);
  ConverterTypeElement converter = dtoType.getConverter();

  if (converter != null && !converters.contains(converter)) {
    parameters.addAll(converter.getConverterParameters(parametersResolverProvider.getParameterResolver(UsageType.DEFINITION), ConverterInstancerType.SERVICE_CONVERETR_INSTANCER));
    converters.add(converter);
    
    if (dtoType.getKind().equals(MutableTypeKind.CLASS) || dtoType.getKind().equals(MutableTypeKind.INTERFACE)) {
      for (MutableTypeVariable typeVariable: ((MutableDeclaredType)dtoType).getTypeVariables()) {
        for (MutableTypeMirror lowerBound: typeVariable.getLowerBounds()) {
          collectTypeConverters(lowerBound, converters, parameters);
        }
        for (MutableTypeMirror upperBound: typeVariable.getUpperBounds()) {
          collectTypeConverters(upperBound, converters, parameters);
        }
      }
    }
  }
}
 

private void printDtoTypeVariables(Set<? extends MutableTypeMirror> types, ExecutableElement localMethod, ConverterProviderElementPrinter nestedPrinter) {
  for (MutableTypeMirror type: types) {
    DtoType dtoType = processingEnv.getTransferObjectUtils().getDtoType(type);
    if (dtoType.getKind().isDeclared() && dtoType.getConverter() != null) {
      ServiceConverterProviderPrinterContext context = new ServiceConverterProviderPrinterContext((DtoDeclaredType)dtoType, localMethod, dtoType.getConverter().getConfiguration());
      nestedPrinter.print(context);
    }
  }
}

@Override
protected MutableDeclaredType[] getOutputClasses(RoundContext context) {
  TypeElement domain = new TransferObjectMappingAccessor(context.getTypeElement(), processingEnv).getDomain();
  if (domain == null) {
    //if there no domain defined, converter does not make sense
    return new MutableDeclaredType[] {};
  }
  if (domain.getModifiers().contains(Modifier.ABSTRACT)) {
    return new MutableDeclaredType[] {};
  }
  ConverterTypeElement converter = getConfigurationElement(context).getConverter();
  if (converter == null || !converter.isGenerated()) {
    return new MutableDeclaredType[] {};
  }
  return new MutableDeclaredType[] { converter };
}