How to use sk.seges.sesam.pap.model.resolver.api

protected boolean isIdField(MutableDeclaredType typeElement, String fieldName) {
  if (typeElement.asElement() != null) {
    ExecutableElement method = ProcessorUtils.getMethod(fieldName, typeElement.asElement());
    if (method != null) {
      return  entityResolver.isIdMethod(method);
    }
  }
  return false;
}

  @Override
  public void finish(ConfigurationTypeElement configurationTypeElement) {
    if (!entityResolver.shouldHaveIdMethod(configurationTypeElement.getInstantiableDomain())) {
      pw.println("return true;");
    }
    pw.println("}");
    pw.println();
  }
}

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

} else if (!entityResolver.isImmutable(domainTypeElement.asElement())) {
  if ((domainGetterMethod == null && field != null && !entityResolver.isIdField(field)) || !entityResolver.isIdMethod(domainGetterMethod)) {
    processingEnv.getMessager().printMessage(Kind.ERROR,
        "[ERROR] Setter is not available for the field " + domainPathResolver.getCurrent() + " in the class " + domainTypeElement.toString(),

    if (getEntityResolver().isIdMethod(domainMethod)) {
      processingEnv.getMessager().printMessage(Kind.ERROR, "[ERROR] Id method can't be ignored. There should be an id method available for merging purposes.", configurationTypeElement.asConfigurationElement());
      return;
            ExecutableElement nestedIdMethod = currentElement.getIdMethod(getEntityResolver());
            if (nestedIdMethod == null && getEntityResolver().shouldHaveIdMethod(currentElement)) {
if (idMethod == null && getEntityResolver().shouldHaveIdMethod(domainTypeElement)) {
  processingEnv.getMessager().printMessage(Kind.ERROR, "[ERROR] Identifier method could not be found in the automatic way. Please specify id method using " +
      Id.class.getSimpleName() + " annotation or just specify id as a method name.", configurationTypeElement.asConfigurationElement());

ParameterElement[] converterParameters = parametersResolverProvider.getParameterResolver(ConverterConstructorParametersResolverProvider.UsageType.DEFINITION).getConstructorAditionalParameters();

} else if (!entityResolver.isImmutable(instantiableDomainTypeElement.asElement())) {
  ExecutableElement domainGetterMethod = instantiableDomainTypeElement.getGetterMethod(currentPath);
  if ((domainGetterMethod == null && field != null && !entityResolver.isIdField(field)) || !entityResolver.isIdMethod(domainGetterMethod)) {
    processingEnv.getMessager().printMessage(Kind.ERROR,
        "[ERROR] Setter is not available for the field " + currentPath + " in the class " + instantiableDomainTypeElement.toString(),

protected void printDtoInstancer(FormattedPrintWriter pw, EntityResolver entityResolver, DtoType type) {
  pw.println(type," " + RESULT + " = new ", type, "();");
  if ((type instanceof DtoDeclaredType) && entityResolver.shouldHaveIdMethod((DomainDeclaredType) type.getDomainDefinitionConfiguration().getInstantiableDomain())) {
    MutableExecutableElement idMethod = ((DtoDeclaredType)type).getIdMethod(entityResolver);            
    pw.println(RESULT + "." + MethodHelper.toSetter(idMethod) + "((", idMethod.asType().getReturnType(), ")id);");
  }
  pw.println("return " + RESULT + ";");
}

if (entityResolver.isIdMethod(context.getDtoMethod())) {

ParameterElement[] constructorAditionalParameters = parametersResolverProvider.getParameterResolver(ConverterConstructorParametersResolverProvider.UsageType.CONVERTER_PROVIDER_CONTEXT_CONSTRUCTOR).getConstructorAditionalParameters();

  protected void printDomainInstancer(FormattedPrintWriter pw, DomainDeclaredType domainTypeElement) {
    if (!entityResolver.shouldHaveIdMethod(domainTypeElement)) {
      pw.println(" return new ", domainTypeElement, "();");
    } else {
      pw.println(domainTypeElement, " " + RESULT_NAME, " = new ", domainTypeElement, "();");
      
      String setterMethod = MethodHelper.toSetter(domainTypeElement.getIdMethod(entityResolver));
      
      if (ProcessorUtils.hasMethod(setterMethod, domainTypeElement.asElement())) {
        pw.println(RESULT_NAME + "." + MethodHelper.toSetter(domainTypeElement.getIdMethod(entityResolver)) + "((", domainTypeElement.getId(entityResolver), ")" + "id);");
      } else {
        pw.println("if (id != null) {");
        pw.println("throw new ", RuntimeException.class, "(\"Unable to define ID for imutable entity. Please define " + setterMethod + " method for ", domainTypeElement, "!\");");
        pw.println("}");
      }
      pw.println("return " + RESULT_NAME + ";");
    }
  }
}

boolean idMethod = entityResolver.isIdMethod(context.getDtoMethod());

@Override
protected void processElement(ProcessorContext context) {
  FormattedPrintWriter pw = context.getPrintWriter();
  
  converterProviderPrinter = getConverterProviderPrinter(pw);
  TypeElement cachedConverterType = processingEnv.getElementUtils().getTypeElement(BasicCachedConverter.class.getCanonicalName());
  
  ParameterElement[] constructorAdditionalParameters = getParametersResolverProvider().getParameterResolver(UsageType.DEFINITION).getConstructorAditionalParameters();
  
  ConstructorPrinter constructorPrinter = new ConstructorPrinter(context.getOutputType(), processingEnv);
  constructorPrinter.printConstructors(cachedConverterType, constructorAdditionalParameters);
  TypeElement superClassElement = context.getOutputType().getSuperClass() != null ? context.getOutputType().getSuperClass().asElement() : null;
  for (ParameterElement constructorAdditionalParameter: constructorAdditionalParameters) {
    String parameterName = constructorAdditionalParameter.getName().toString();
    if (constructorAdditionalParameter.getPropagationType().equals(PropagationType.PROPAGATED_MUTABLE) && !containsField(superClassElement, constructorAdditionalParameter)) {
      MutableVariableElement field = processingEnv.getElementUtils().getParameterElement(constructorAdditionalParameter.getType(), parameterName);
      context.getOutputType().addField((MutableVariableElement) field.addModifier(Modifier.PROTECTED));
      MutableExecutableType setterMethod = processingEnv.getTypeUtils().getExecutable(
          processingEnv.getTypeUtils().toMutableType(processingEnv.getTypeUtils().getNoType(TypeKind.VOID)), MethodHelper.toSetter(parameterName)).
          addParameter(processingEnv.getElementUtils().getParameterElement(constructorAdditionalParameter.getType(), parameterName)).addModifier(Modifier.PUBLIC);
      context.getOutputType().addMethod(setterMethod);
      setterMethod.getPrintWriter().println("this." + parameterName + " = " + parameterName + ";");
    }
  }
  super.processElement(context);
  
  converterProviderPrinter.printConverterMethods(context.getOutputType(), false, ConverterInstancerType.REFERENCED_CONVERTER_INSTANCER);
}

@Override
public void print(TransferObjectContext context) {
  if (entityResolver.shouldHaveIdMethod(context.getConfigurationTypeElement().getInstantiableDomain())) {
    return;

pw.println();
if (entityResolver.shouldHaveIdMethod(configurationTypeElement.getInstantiableDomain())) {

idMethod = configurationElement.getInstantiableDomain().getIdMethod(entityResolver);
if (idMethod == null && entityResolver.shouldHaveIdMethod(configurationElement.getInstantiableDomain())) {
  processingEnv.getMessager().printMessage(Kind.ERROR, "[ERROR] Unable to find id method for " + configurationElement.toString(), configurationElement.asConfigurationElement());
  return;

  domainIdMethod = configurationElement.getInstantiableDomain().getIdMethod(entityResolver);
  if (domainIdMethod == null && entityResolver.shouldHaveIdMethod(configurationElement.getInstantiableDomain())) {
    processingEnv.getMessager().printMessage(Kind.ERROR, "[ERROR] Unable to find id method for " + configurationElement.toString(), configurationElement.asConfigurationElement());
    return;
if (dtoIdMethod == null && entityResolver.shouldHaveIdMethod(configurationElement.getInstantiableDomain())) {
  processingEnv.getMessager().printMessage(Kind.ERROR, "[ERROR] Unable to find id method for DTO class " + dtoType.getCanonicalName(), configurationElement.asConfigurationElement());
  return;