Example usage for javax.lang.model.type TypeKind Object

List of usage examples for javax.lang.model.type TypeKind Object

Introduction

In this page you can find the example usage for javax.lang.model.type TypeKind Object.

Prototype

@HotSpotIntrinsicCandidate
public Object() 

Source Link

Document

Constructs a new object.

Usage

From source file:org.kie.workbench.common.forms.adf.processors.FormDefinitionsProcessor.java

private List<Map<String, String>> extracFormFields(TypeElement type, FieldPolicy policy,
        I18nSettings i18nSettings) throws Exception {

    final Elements elementUtils = processingEnv.getElementUtils();

    Collection<FieldInfo> fieldInfos = extractFieldInfos(type, fieldElement -> {
        if (policy.equals(FieldPolicy.ALL)) {
            AnnotationMirror annotation = GeneratorUtils.getAnnotation(elementUtils, fieldElement,
                    SkipFormField.class.getName());
            if (annotation != null) {
                return false;
            }//w  ww .j  a v  a 2s .  c  o m
        } else {
            AnnotationMirror annotation = GeneratorUtils.getAnnotation(elementUtils, fieldElement,
                    FormField.class.getName());
            if (annotation == null) {
                return false;
            }
        }
        return true;
    });

    List<Map<String, String>> elementsSettings = new ArrayList<>();

    for (FieldInfo fieldInfo : fieldInfos) {

        if (fieldInfo.getter != null && fieldInfo.setter != null) {

            String fieldName = fieldInfo.fieldElement.getSimpleName().toString();

            String fieldLabel = fieldName;
            String binding = fieldName;

            String methodName = "getFormElement_" + fieldName;

            Map<String, Object> elementContext = new HashMap<>();

            boolean isList = false;

            org.kie.workbench.common.forms.model.TypeKind typeKind = org.kie.workbench.common.forms.model.TypeKind.BASE;

            boolean overrideI18nLabel = false;

            TypeMirror finalType = fieldInfo.fieldElement.asType();

            String fieldModifier = "";

            if (finalType instanceof DeclaredType) {
                Element finalTypeElement = processingEnv.getTypeUtils().asElement(finalType);

                if (finalTypeElement.getKind().equals(ElementKind.CLASS)) {
                    FieldDefinition fieldDefinitionAnnotation = finalTypeElement
                            .getAnnotation(FieldDefinition.class);
                    if (fieldDefinitionAnnotation != null) {

                        // Override the using the i18n mechanism
                        if (fieldDefinitionAnnotation.labelMode().equals(LabelMode.OVERRIDE_I18N_KEY)) {
                            Collection<FieldInfo> labelInfos = extractFieldInfos((TypeElement) finalTypeElement,
                                    fieldElement -> fieldElement.getAnnotation(FieldLabel.class) != null);

                            if (labelInfos == null || labelInfos.size() != 1) {
                                throw new Exception("Problem processing FieldDefinition [" + finalType
                                        + "]: it should have one field marked as @FieldLabel");
                            }

                            FieldInfo labelInfo = labelInfos.iterator().next();

                            fieldLabel = finalType.toString() + i18nSettings.separator()
                                    + labelInfo.fieldElement.getSimpleName();
                        }

                        Collection<FieldInfo> fieldValue = extractFieldInfos((TypeElement) finalTypeElement,
                                fieldElement -> fieldElement.getAnnotation(FieldValue.class) != null);

                        if (fieldValue == null || fieldValue.size() != 1) {
                            throw new Exception("Problem processing FieldDefinition [" + finalType
                                    + "]: it should have one field marked as @FieldValue");
                        }
                        FieldInfo valueInfo = fieldValue.iterator().next();

                        binding += "." + valueInfo.getFieldElement().getSimpleName();

                        fieldModifier = fixClassName(finalType.toString()) + "_FieldStatusModifier";

                        finalType = valueInfo.getFieldElement().asType();

                        overrideI18nLabel = !fieldDefinitionAnnotation.labelMode()
                                .equals(LabelMode.DONT_OVERRIDE);
                    } else {
                        FormDefinition formDefinitionAnnotation = finalTypeElement
                                .getAnnotation(FormDefinition.class);

                        if (formDefinitionAnnotation != null) {
                            Collection<FieldInfo> labelInfos = extractFieldInfos((TypeElement) finalTypeElement,
                                    fieldElement -> fieldElement.getAnnotation(FieldLabel.class) != null);

                            if (labelInfos != null & labelInfos.size() == 1) {
                                FieldInfo labelInfo = labelInfos.iterator().next();
                                fieldLabel = finalType.toString() + i18nSettings.separator()
                                        + labelInfo.fieldElement.getSimpleName();
                                overrideI18nLabel = true;
                            }
                            typeKind = org.kie.workbench.common.forms.model.TypeKind.OBJECT;
                        }
                    }
                }

                DeclaredType fieldType = (DeclaredType) finalType;

                if (processingEnv.getTypeUtils().isAssignable(fieldType.asElement().asType(), listType)) {
                    if (fieldType.getTypeArguments().size() != 1) {
                        throw new IllegalArgumentException("Impossible to generate a field for type "
                                + fieldType.toString() + ". Type should have one and only one Type arguments.");
                    }
                    isList = true;
                    finalType = fieldType.getTypeArguments().get(0);
                    typeKind = org.kie.workbench.common.forms.model.TypeKind.OBJECT;
                } else if (elementUtils.getTypeElement(finalType.toString()).getSuperclass().toString()
                        .startsWith("java.lang.Enum")) {
                    typeKind = org.kie.workbench.common.forms.model.TypeKind.ENUM;
                }
            }

            elementContext.put("formModel", type.getQualifiedName().toString());
            elementContext.put("methodName", methodName);
            elementContext.put("fieldName", fieldName);
            elementContext.put("binding", binding);
            elementContext.put("type", typeKind.toString());
            elementContext.put("className", finalType.toString());
            elementContext.put("isList", String.valueOf(isList));
            elementContext.put("fieldModifier", fieldModifier);

            Map<String, String> params = new HashMap<>();
            elementContext.put("params", params);

            String afterElement = "";
            FormField settings = fieldInfo.fieldElement.getAnnotation(FormField.class);

            if (settings != null) {
                String typeName;
                try {
                    typeName = settings.type().getName();
                } catch (MirroredTypeException exception) {
                    typeName = exception.getTypeMirror().toString();
                }
                if (StringUtils.isEmpty(typeName)) {
                    typeName = FieldType.class.getName();
                }

                afterElement = settings.afterElement();

                elementContext.put("preferredType", typeName);
                if (!overrideI18nLabel) {
                    fieldLabel = settings.labelKey();
                }
                elementContext.put("required", Boolean.valueOf(settings.required()).toString());
                elementContext.put("readOnly", Boolean.valueOf(settings.readonly()).toString());

                for (FieldParam fieldParam : settings.settings()) {
                    params.put(fieldParam.name(), fieldParam.value());
                }

                elementContext.put("wrap", Boolean.valueOf(settings.layoutSettings().wrap()).toString());
                elementContext.put("horizontalSpan",
                        String.valueOf(settings.layoutSettings().horizontalSpan()));
                elementContext.put("verticalSpan", String.valueOf(settings.layoutSettings().verticalSpan()));
            } else {
                elementContext.put("preferredType", FieldType.class.getName());
                elementContext.put("required", Boolean.FALSE.toString());
                elementContext.put("readOnly", Boolean.FALSE.toString());
                elementContext.put("wrap", Boolean.FALSE.toString());
                elementContext.put("horizontalSpan", "1");
                elementContext.put("verticalSpan", "1");
            }

            if (!overrideI18nLabel) {
                if (!StringUtils.isEmpty(i18nSettings.keyPreffix())) {
                    fieldLabel = i18nSettings.keyPreffix() + i18nSettings.separator() + fieldLabel;
                }
            }

            elementContext.put("labelKey", fieldLabel);
            elementContext.put("afterElement", afterElement);

            extractFieldExtraSettings(elementContext, fieldInfo.fieldElement);

            StringBuffer methodCode = writeTemplate("templates/FieldElement.ftl", elementContext);

            Map<String, String> fieldSettings = new HashMap<>();
            fieldSettings.put("elementName", fieldName);
            fieldSettings.put("afterElement", afterElement);
            fieldSettings.put("methodName", methodName);
            fieldSettings.put("method", methodCode.toString());

            elementsSettings.add(fieldSettings);
        }
    }
    return elementsSettings;
}