Examples with BindXml com.abubusoft.kripton.annotation.BindXml used on opensource projects

Example 1 with BindXml

use of com.abubusoft.kripton.annotation.BindXml in project kripton by xcesco.

the class BindEntityBuilder method parse.

public static BindEntity parse(final BindModel model, TypeElement element) {
    final Elements elementUtils = BaseProcessor.elementUtils;
    final InnerCounter counterPropertyInValue = new InnerCounter();
    final Converter<String, String> typeNameConverter = CaseFormat.UPPER_CAMEL.converterTo(CaseFormat.LOWER_CAMEL);
    final TypeElement beanElement = element;
    final BindEntity currentEntity = new BindEntity(beanElement.getSimpleName().toString(), beanElement, AnnotationUtility.buildAnnotationList(element, classAnnotationFilter));
    // tag typeName
    String tagName = AnnotationUtility.extractAsString(beanElement, BindType.class, AnnotationAttributeType.VALUE);
    if (StringUtils.hasText(tagName)) {
        currentEntity.xmlInfo.label = tagName;
    } else {
        currentEntity.xmlInfo.label = typeNameConverter.convert(beanElement.getSimpleName().toString());
    }
    final boolean bindAllFields = AnnotationUtility.getAnnotationAttributeAsBoolean(currentEntity, BindType.class, AnnotationAttributeType.ALL_FIELDS, Boolean.TRUE);
    PropertyUtility.buildProperties(elementUtils, currentEntity, new PropertyFactory<BindEntity, BindProperty>() {

        @Override
        public BindProperty createProperty(BindEntity entity, Element propertyElement) {
            return new BindProperty(currentEntity, propertyElement, AnnotationUtility.buildAnnotationList(propertyElement));
        }
    }, propertyAnnotationFilter, new PropertyCreatedListener<BindEntity, BindProperty>() {

        @Override
        public boolean onProperty(BindEntity entity, BindProperty property) {
            // if we are build Map, the model are not null
            boolean contextExternal = (model == null);
            // if @BindDisabled is present, exit immediately
            if (property.hasAnnotation(BindDisabled.class)) {
                if (bindAllFields) {
                    return false;
                } else {
                    throw new InvalidDefinition(String.format("In class '%s', @%s can not be used with @%s(allField=false)", property.getParent().getElement().asType().toString(), BindDisabled.class.getSimpleName(), BindType.class.getSimpleName()));
                }
            }
            boolean enabled = bindAllFields;
            ModelAnnotation annotationBind = property.getAnnotation(Bind.class);
            enabled = enabled || (annotationBind != null && AnnotationUtility.extractAsBoolean(property, annotationBind, AnnotationAttributeType.ENABLED));
            // we have to analyze in every case.
            if (!enabled && !contextExternal) {
                return false;
            }
            ModelAnnotation annotationBindXml = property.getAnnotation(BindXml.class);
            property.order = 0;
            property.mapKeyName = Bind.MAP_KEY_DEFAULT;
            property.mapValueName = Bind.MAP_VALUE_DEFAULT;
            // label for item and collection elements are the same for
            // default
            property.label = typeNameConverter.convert(property.getName());
            property.xmlInfo.labelItem = property.label;
            property.xmlInfo.wrappedCollection = false;
            property.xmlInfo.xmlType = XmlType.valueOf(XmlType.TAG.toString());
            property.xmlInfo.mapEntryType = MapEntryType.valueOf(MapEntryType.TAG.toString());
            // check if there is an adapter
            if ((property.getAnnotation(BindAdapter.class) != null)) {
                BindTransform transform = BindTransformer.lookup(TypeUtility.typeName(property.typeAdapter.dataType));
                if (!transform.isTypeAdapterSupported()) {
                    String msg = String.format("In class '%s', property '%s' uses @BindAdapter with unsupported 'dataType' '%s'", beanElement.asType().toString(), property.getName(), property.typeAdapter.dataType);
                    throw (new IncompatibleAnnotationException(msg));
                }
                if (property.getPropertyType().isPrimitive()) {
                    String msg = String.format("In class '%s', property '%s' is primitive of type '%s' and it can not be annotated with @BindAdapter", beanElement.asType().toString(), property.getName(), property.getPropertyType().getTypeName());
                    throw (new IncompatibleAnnotationException(msg));
                }
            }
            // @Bind management
            if (annotationBind != null) {
                int order = AnnotationUtility.extractAsInt(property.getElement(), Bind.class, AnnotationAttributeType.ORDER);
                property.order = order;
                String tempName = AnnotationUtility.extractAsString(property.getElement(), Bind.class, AnnotationAttributeType.VALUE);
                if (StringUtils.hasText(tempName)) {
                    // for the moment are the same
                    property.label = tempName;
                    property.xmlInfo.labelItem = property.label;
                }
                // map info
                String mapKeyName = AnnotationUtility.extractAsString(property.getElement(), Bind.class, AnnotationAttributeType.MAP_KEY_NAME);
                if (StringUtils.hasText(mapKeyName))
                    property.mapKeyName = mapKeyName;
                String mapValueName = AnnotationUtility.extractAsString(property.getElement(), Bind.class, AnnotationAttributeType.MAP_VALUE_NAME);
                if (StringUtils.hasText(mapValueName))
                    property.mapValueName = mapValueName;
            }
            // @BindXml management
            if (annotationBindXml != null) {
                String mapEntryType = AnnotationUtility.extractAsEnumerationValue(property.getElement(), BindXml.class, AnnotationAttributeType.MAP_ENTRY_TYPE);
                if (StringUtils.hasText(mapEntryType))
                    property.xmlInfo.mapEntryType = MapEntryType.valueOf(mapEntryType);
                // define element tag typeName
                String tempElementName = AnnotationUtility.extractAsString(property.getElement(), BindXml.class, AnnotationAttributeType.XML_ELEMENT_TAG);
                if (StringUtils.hasText(tempElementName)) {
                    property.xmlInfo.labelItem = tempElementName;
                    property.xmlInfo.wrappedCollection = true;
                }
                String xmlType = AnnotationUtility.extractAsEnumerationValue(property.getElement(), BindXml.class, AnnotationAttributeType.XML_TYPE);
                if (StringUtils.hasText(xmlType))
                    property.xmlInfo.xmlType = XmlType.valueOf(xmlType);
            }
            if (property.xmlInfo.xmlType == XmlType.ATTRIBUTE) {
                BindTransform transform = BindTransformer.lookup(property.getPropertyType().getTypeName());
                // check if property is a array
                if (property.isBindedArray() && !(transform instanceof ByteArrayBindTransform)) {
                    String msg = String.format("In class '%s', property '%s' is an array and it can not be mapped in a xml attribute", beanElement.asType().toString(), property.getName());
                    throw (new IncompatibleAttributesInAnnotationException(msg));
                }
                // check if property is a collection
                if (property.isBindedCollection()) {
                    String msg = String.format("In class '%s', property '%s' is a collection and it can not be mapped in a xml attribute", beanElement.asType().toString(), property.getName());
                    throw (new IncompatibleAttributesInAnnotationException(msg));
                }
                // check if property is a map
                if (property.isBindedMap()) {
                    String msg = String.format("In class '%s', property '%s' is an map and it can not be mapped in a xml attribute", beanElement.asType().toString(), property.getName());
                    throw (new IncompatibleAttributesInAnnotationException(msg));
                }
                if (transform != null && transform instanceof ObjectBindTransform) {
                    String msg = String.format("In class '%s', property '%s' is an object and it can not be mapped in a xml attribute", beanElement.asType().toString(), property.getName());
                    throw (new IncompatibleAttributesInAnnotationException(msg));
                }
            }
            if (property.xmlInfo.xmlType == XmlType.VALUE || property.xmlInfo.xmlType == XmlType.VALUE_CDATA) {
                counterPropertyInValue.inc();
                BindTransform transform = BindTransformer.lookup(property.getPropertyType().getTypeName());
                // check if property is a array
                if (property.isBindedArray() && !(transform instanceof ByteArrayBindTransform)) {
                    String msg = String.format("In class '%s', property '%s' is an array and it can not be mapped in a xml value", beanElement.asType().toString(), property.getName());
                    throw (new IncompatibleAttributesInAnnotationException(msg));
                }
                // check if property is a collection
                if (property.isBindedCollection()) {
                    String msg = String.format("In class '%s', property '%s' is a collection and it can not be mapped in a xml value", beanElement.asType().toString(), property.getName());
                    throw (new IncompatibleAttributesInAnnotationException(msg));
                }
                // check if property is a map
                if (property.isBindedMap()) {
                    String msg = String.format("In class '%s', property '%s' is a map and it can not be mapped in a xml value", beanElement.asType().toString(), property.getName());
                    throw (new IncompatibleAttributesInAnnotationException(msg));
                }
                if (transform != null && transform instanceof ObjectBindTransform) {
                    String msg = String.format("In class '%s', property '%s' is an object and it can not be mapped in a xml value", beanElement.asType().toString(), property.getName());
                    throw (new IncompatibleAttributesInAnnotationException(msg));
                }
            }
            if (counterPropertyInValue.value() > 1) {
                String msg = String.format("In class '%s', property '%s' and other properties are mapped in a xml value, but only one property for class can be a xml value", beanElement.asType().toString(), property.getName());
                throw (new IncompatibleAttributesInAnnotationException(msg));
            }
            property.bindedObject = BindTransformer.isBindedObject(property);
            // set inCollection to true, permits this.
            if (property.bindedObject && contextExternal) {
                property.inCollection = true;
            }
            return true;
        }
    });
    // if we don't have model, we dont save bean definition
    if (model != null) {
        model.entityAdd(currentEntity);
    }
    return currentEntity;
}