Examples with JAXBElement javax.xml.bind.JAXBElement used on opensource projects

Example 21 with JAXBElement

use of javax.xml.bind.JAXBElement in project midpoint by Evolveum.

the class ToolsUtils method serializeObject.

public static void serializeObject(Object object, Writer writer) throws JAXBException {
    if (object == null) {
        return;
    }
    Marshaller marshaller = JAXB_CONTEXT.createMarshaller();
    marshaller.setProperty(Marshaller.JAXB_ENCODING, StandardCharsets.UTF_8.name());
    marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
    marshaller.setProperty(Marshaller.JAXB_FRAGMENT, true);
    if (object instanceof ObjectType) {
        object = new JAXBElement(C_OBJECT, Object.class, object);
    }
    marshaller.marshal(object, writer);
}

Example 22 with JAXBElement

use of javax.xml.bind.JAXBElement in project midpoint by Evolveum.

the class BeanUnmarshaller method unmarshalEntry.

/**
	 * Parses either a map entry, or a fictitious heterogeneous list property.
	 *
	 * It makes sure that a 'key' property is inserted into 'bean' object, being sourced from 'node' structure.
	 * Node itself can be single-valued or multi-valued, corresponding to single or multi-valued 'key' property.
	 * ---
	 * A notable (and quite ugly) exception is processing of fictitious heterogeneous lists.
	 * In this case we have a ListXNode that should be interpreted as a MapXNode, inserting fictitious property
	 * named after abstract multivalued property in the parent bean.
	 *
	 * For example, when we have (embedded in ExecuteScriptType):
	 *   {
	 *     pipeline: *[
	 *       { element: search, ... },
	 *       { element: sequence, ... }
	 *     ]
	 *   }
	 *
	 * ...it should be, in fact, read as if it would be:
	 *
	 *   {
	 *     pipeline: {
	 *        scriptingExpression: [
	 *          { type: SearchExpressionType, ... },
	 *          { type: ExpressionSequenceType, ... }
	 *        ]
	 *     }
	 *   }
	 *
	 * (The only difference is in element names, which are missing in the latter snippet, but let's ignore that here.)
	 *
	 * Fictitious heterogeneous list entry here is "scriptingExpression", a property of pipeline (ExpressionPipelineType).
	 *
 	 * We have to create the following data structure (corresponding to latter snippet):
	 *
	 * instance of ExecuteScriptType:
	 *   scriptingExpression = instance of JAXBElement(pipeline, ExpressionPipelineType):			[1]
	 *     scriptingExpression = List of															[2]
	 *       - JAXBElement(search, SearchExpressionType)
	 *       - JAXBElement(sequence, ExpressionSequenceType)
	 *
	 * We in fact invoke this method twice with the same node (a two-entry list, marked as '*' in the first snippet):
	 * 1) bean=ExecuteScriptType, key=pipeline, node=HList(*), isHeteroListProperty=false
	 * 2) bean=ExpressionPipelineType, key=scriptingExpression, node=HList(*), isHeteroListProperty=true		<<<
	 *
	 * During the first call we fill in scriptingExpression (single value) in ExecuteScriptType [1]; during the second one
	 * we fill in scriptingExpression (multivalued) in ExpressionPipelineType [2].
	 *
	 * Now let's expand the sample.
	 *
	 * This XNode tree:
	 *   {
	 *     pipeline: *[
	 *       { element: search, type: RoleType, searchFilter: {...}, action: log },
	 *       { element: sequence, value: **[
	 *           { element: action, type: delete },
	 *           { element: action, type: assign, parameter: {...} },
	 *           { element: search, type: UserType }
	 *       ] }
	 *     ]
	 *   }
	 *
	 * Should be interpreted as:
	 *   {
	 *     pipeline: {
	 *       scriptingExpression: [
	 *          { type: SearchExpressionType, type: RoleType, searchFilter: {...}, action: log }
	 *          { type: ExpressionSequenceType, scriptingExpression: [
	 *                { type: ActionExpressionType, type: delete },
	 *                { type: ActionExpressionType, type: assign, parameter: {...} },
	 *                { type: SearchExpressionType, type: UserType }
	 *            ] }
	 *       ]
	 *     }
	 *   }
	 *
	 * Producing the following data:
	 *
	 * instance of ExecuteScriptType:
	 *   scriptingExpression = instance of JAXBElement(pipeline, ExpressionPipelineType):			[1]
	 *     scriptingExpression = List of															[2]
	 *       - JAXBElement(search, instance of SearchExpressionType):
	 *           type: RoleType,
	 *           searchFilter: (...),
	 *           action: log,
	 *       - JAXBElement(sequence, instance of ExpressionSequenceType):
	 *           scriptingExpression = List of
	 *             - JAXBElement(action, instance of ActionExpressionType):
	 *                 type: delete
	 *             - JAXBElement(action, instance of ActionExpressionType):
	 *                 type: assign
	 *                 parameter: (...),
	 *             - JAXBElement(search, instance of SearchExpressionType):
	 *                 type: UserType
	 *
	 * Invocations of this method will be:
	 *  1) bean=ExecuteScriptType, key=pipeline, node=HList(*), isHeteroListProperty=false
	 *  2) bean=ExpressionPipelineType, key=scriptingExpression, node=HList(*), isHeteroListProperty=true            <<<
	 *  3) bean=SearchExpressionType, key=type, node='type: c:RoleType', isHeteroListProperty=false
	 *  4) bean=SearchExpressionType, key=searchFilter, node=XNode(map:1 entries), isHeteroListProperty=false
	 *  5) bean=SearchExpressionType, key=action, node=XNode(map:1 entries), isHeteroListProperty=false
	 *  6) bean=ActionExpressionType, key=type, node='type: log', isHeteroListProperty=false
	 *  7) bean=ExpressionSequenceType, key=scriptingExpression, node=HList(**), isHeteroListProperty=true           <<<
	 *  8) bean=ActionExpressionType, key=type, node='type: delete', isHeteroListProperty=false
	 *  9) bean=ActionExpressionType, key=type, node='type: assign', isHeteroListProperty=false
	 * 10) bean=ActionExpressionType, key=parameter, node=XNode(map:2 entries), isHeteroListProperty=false
	 * 11) bean=ActionParameterValueType, key=name, node='name: role', isHeteroListProperty=false
	 * 12) bean=ActionParameterValueType, key=value, node='value: rome555c-7797-11e2-94a6-001e8c717e5b', isHeteroListProperty=false
	 * 13) bean=SearchExpressionType, key=type, node='type: UserType', isHeteroListProperty=false
	 *
	 * Here we have 2 calls with isHeteroListProperty=true; first for pipeline.scriptingExpression, second for
	 * sequence.scriptingExpression.
	 */
private <T> void unmarshalEntry(@NotNull T bean, @NotNull Class<T> beanClass, @NotNull QName key, @NotNull XNode node, @NotNull XNode containingNode, boolean isHeteroListProperty, @NotNull ParsingContext pc) throws SchemaException {
    //System.out.println("bean=" + bean.getClass().getSimpleName() + ", key=" + key.getLocalPart() + ", node=" + node + ", isHeteroListProperty=" + isHeteroListProperty);
    final String propName = key.getLocalPart();
    // this code is just to keep this method reasonably short
    PropertyAccessMechanism mechanism = new PropertyAccessMechanism();
    if (!mechanism.compute(bean, beanClass, propName, key, node, pc)) {
        return;
    }
    final String actualPropertyName = mechanism.actualPropertyName;
    final boolean storeAsRawType = mechanism.storeAsRawType;
    final Method getter = mechanism.getter;
    final Method setter = mechanism.setter;
    final boolean wrapInJaxbElement = mechanism.wrapInJaxbElement;
    if (Element.class.isAssignableFrom(mechanism.paramType)) {
        throw new IllegalArgumentException("DOM not supported in field " + actualPropertyName + " in " + beanClass);
    }
    // The type T that is expected by the bean, i.e. either by
    //   - setMethod(T value), or
    //   - Collection<T> getMethod()
    // We use it to retrieve the correct value when parsing the node.
    // We might specialize it using the information derived from the node (to deal with inclusive polymorphism,
    // i.e. storing ExclusionPolicyConstraintType where AbstractPolicyConstraintType is expected).
    @NotNull Class<?> paramType;
    if (!storeAsRawType && !isHeteroListProperty) {
        Class<?> t = specializeParamType(node, mechanism.paramType, pc);
        if (t == null) {
            // indicates a problem
            return;
        } else {
            paramType = t;
        }
    } else {
        paramType = mechanism.paramType;
    }
    if (!(node instanceof ListXNode) && Object.class.equals(paramType) && !storeAsRawType) {
        throw new IllegalArgumentException("Object property (without @Raw) not supported in field " + actualPropertyName + " in " + beanClass);
    }
    //		String paramNamespace = inspector.determineNamespace(paramType);
    boolean problem = false;
    Object propValue = null;
    Collection<Object> propValues = null;
    // (instead of list) and process it as a single value. Only when
    if (node instanceof ListXNode && (!node.isHeterogeneousList() || isHeteroListProperty)) {
        ListXNode xlist = (ListXNode) node;
        if (setter != null) {
            try {
                Object value = unmarshalSinglePropValue(node, actualPropertyName, paramType, storeAsRawType, beanClass, pc);
                if (wrapInJaxbElement) {
                    propValue = wrapInJaxbElement(value, mechanism.objectFactory, mechanism.elementFactoryMethod, propName, beanClass, pc);
                } else {
                    propValue = value;
                }
            } catch (SchemaException e) {
                problem = processSchemaException(e, node, pc);
            }
        } else {
            // No setter, we have to use collection getter
            propValues = new ArrayList<>(xlist.size());
            for (XNode xsubsubnode : xlist) {
                try {
                    Object valueToAdd;
                    Object value = unmarshalSinglePropValue(xsubsubnode, actualPropertyName, paramType, storeAsRawType, beanClass, pc);
                    if (value != null) {
                        if (isHeteroListProperty) {
                            QName elementName = xsubsubnode.getElementName();
                            if (elementName == null) {
                                // TODO better error handling
                                throw new SchemaException("Heterogeneous list with a no-elementName node: " + xsubsubnode);
                            }
                            Class valueClass = value.getClass();
                            QName jaxbElementName;
                            if (QNameUtil.hasNamespace(elementName)) {
                                jaxbElementName = elementName;
                            } else {
                                // Approximate solution: find element in schema registry - check for type compatibility
                                // in order to exclude accidental name matches (like c:expression/s:expression).
                                Optional<ItemDefinition> itemDefOpt = getSchemaRegistry().findItemDefinitionsByElementName(elementName).stream().filter(def -> getSchemaRegistry().findTypeDefinitionsByType(def.getTypeName()).stream().anyMatch(typeDef -> typeDef.getCompileTimeClass() != null && typeDef.getCompileTimeClass().isAssignableFrom(valueClass))).findFirst();
                                if (itemDefOpt.isPresent()) {
                                    jaxbElementName = itemDefOpt.get().getName();
                                } else {
                                    LOGGER.warn("Heterogeneous list member with unknown element name '" + elementName + "': " + value);
                                    // unqualified
                                    jaxbElementName = elementName;
                                }
                            }
                            @SuppressWarnings("unchecked") JAXBElement jaxbElement = new JAXBElement<>(jaxbElementName, valueClass, value);
                            valueToAdd = jaxbElement;
                        } else {
                            if (wrapInJaxbElement) {
                                valueToAdd = wrapInJaxbElement(value, mechanism.objectFactory, mechanism.elementFactoryMethod, propName, beanClass, pc);
                            } else {
                                valueToAdd = value;
                            }
                        }
                        propValues.add(valueToAdd);
                    }
                } catch (SchemaException e) {
                    problem = processSchemaException(e, xsubsubnode, pc);
                }
            }
        }
    } else {
        try {
            propValue = unmarshalSinglePropValue(node, actualPropertyName, paramType, storeAsRawType, beanClass, pc);
            if (wrapInJaxbElement) {
                propValue = wrapInJaxbElement(propValue, mechanism.objectFactory, mechanism.elementFactoryMethod, propName, beanClass, pc);
            }
        } catch (SchemaException e) {
            problem = processSchemaException(e, node, pc);
        }
    }
    if (setter != null) {
        try {
            setter.invoke(bean, propValue);
        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
            throw new SystemException("Cannot invoke setter " + setter + " on bean of type " + beanClass + ": " + e.getMessage(), e);
        }
    } else if (getter != null) {
        Object getterReturn;
        Collection<Object> col;
        try {
            getterReturn = getter.invoke(bean);
        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
            throw new SystemException("Cannot invoke getter " + getter + " on bean of type " + beanClass + ": " + e.getMessage(), e);
        }
        try {
            col = (Collection<Object>) getterReturn;
        } catch (ClassCastException e) {
            throw new SystemException("Getter " + getter + " on bean of type " + beanClass + " returned " + getterReturn + " instead of collection");
        }
        if (propValue != null) {
            col.add(propValue);
        } else if (propValues != null) {
            for (Object propVal : propValues) {
                col.add(propVal);
            }
        } else if (!problem) {
            throw new IllegalStateException("Strange. Multival property " + propName + " in " + beanClass + " produced null values list, parsed from " + containingNode);
        }
        if (!isHeteroListProperty) {
            checkJaxbElementConsistence(col, pc);
        }
    } else {
        throw new IllegalStateException("Uh? No setter nor getter.");
    }
}

Example 23 with JAXBElement

use of javax.xml.bind.JAXBElement in project midpoint by Evolveum.

the class JaxbDomHack method parseRawElement.

/**
	 * This is used in a form of "fromAny" to parse elements from a JAXB getAny method to prism. 
	 */
public <IV extends PrismValue, ID extends ItemDefinition, C extends Containerable> Item<IV, ID> parseRawElement(Object element, PrismContainerDefinition<C> definition) throws SchemaException {
    Validate.notNull(definition, "Attempt to parse raw element in a container without definition");
    QName elementName = JAXBUtil.getElementQName(element);
    ItemDefinition itemDefinition = definition.findItemDefinition(elementName);
    if (itemDefinition == null) {
        itemDefinition = locateItemDefinition(definition, elementName, element);
        if (itemDefinition == null) {
            throw new SchemaException("No definition for item " + elementName);
        }
    }
    PrismContext prismContext = definition.getPrismContext();
    Item<IV, ID> subItem;
    if (element instanceof Element) {
        // DOM Element
        subItem = prismContext.parserFor((Element) element).name(elementName).definition(itemDefinition).parseItem();
    } else if (element instanceof JAXBElement<?>) {
        // JAXB Element
        JAXBElement<?> jaxbElement = (JAXBElement<?>) element;
        Object jaxbBean = jaxbElement.getValue();
        if (itemDefinition == null) {
            throw new SchemaException("No definition for item " + elementName + " in container " + definition + " (parsed from raw element)", elementName);
        }
        if (itemDefinition instanceof PrismPropertyDefinition<?>) {
            // property
            PrismProperty<?> property = ((PrismPropertyDefinition<?>) itemDefinition).instantiate();
            property.setRealValue(jaxbBean);
            subItem = (Item<IV, ID>) property;
        } else if (itemDefinition instanceof PrismContainerDefinition<?>) {
            if (jaxbBean instanceof Containerable) {
                PrismContainer<?> container = ((PrismContainerDefinition<?>) itemDefinition).instantiate();
                PrismContainerValue subValue = ((Containerable) jaxbBean).asPrismContainerValue();
                container.add(subValue);
                subItem = (Item<IV, ID>) container;
            } else {
                throw new IllegalArgumentException("Unsupported JAXB bean " + jaxbBean.getClass());
            }
        } else if (itemDefinition instanceof PrismReferenceDefinition) {
            // TODO
            if (jaxbBean instanceof Referencable) {
                PrismReference reference = ((PrismReferenceDefinition) itemDefinition).instantiate();
                PrismReferenceValue refValue = ((Referencable) jaxbBean).asReferenceValue();
                reference.merge(refValue);
                subItem = (Item<IV, ID>) reference;
            } else {
                throw new IllegalArgumentException("Unsupported JAXB bean" + jaxbBean);
            }
        } else {
            throw new IllegalArgumentException("Unsupported definition type " + itemDefinition.getClass());
        }
    } else {
        throw new IllegalArgumentException("Unsupported element type " + element.getClass());
    }
    return subItem;
}

Example 24 with JAXBElement

use of javax.xml.bind.JAXBElement in project midpoint by Evolveum.

the class JaxbDomHack method locateItemDefinition.

private <T extends Containerable> ItemDefinition locateItemDefinition(PrismContainerDefinition<T> containerDefinition, QName elementQName, Object valueElements) throws SchemaException {
    ItemDefinition def = containerDefinition.findItemDefinition(elementQName);
    if (def != null) {
        return def;
    }
    if (valueElements instanceof Element) {
        // Try to locate xsi:type definition in the element
        def = resolveDynamicItemDefinition(containerDefinition, elementQName, (Element) valueElements, prismContext);
    }
    if (valueElements instanceof List) {
        List elements = (List) valueElements;
        if (elements.size() == 1) {
            Object element = elements.get(0);
            if (element instanceof JAXBElement) {
                Object val = ((JAXBElement) element).getValue();
                if (val.getClass().isPrimitive()) {
                    QName typeName = XsdTypeMapper.toXsdType(val.getClass());
                    PrismPropertyDefinitionImpl propDef = new PrismPropertyDefinitionImpl(elementQName, typeName, prismContext);
                    //						propDef.setMaxOccurs(maxOccurs);
                    propDef.setDynamic(true);
                    return propDef;
                }
            }
        }
    }
    if (def != null) {
        return def;
    }
    if (containerDefinition.isRuntimeSchema()) {
        // Try to locate global definition in any of the schemas
        def = resolveGlobalItemDefinition(containerDefinition, elementQName);
    }
    return def;
}

Example 25 with JAXBElement

use of javax.xml.bind.JAXBElement in project midpoint by Evolveum.

the class BeanMarshaller method marshalXmlTypeToMap.

private XNode marshalXmlTypeToMap(Object bean, SerializationContext ctx) throws SchemaException {
    Class<?> beanClass = bean.getClass();
    MapXNode xmap;
    if (bean instanceof SearchFilterType) {
        // this hack is here because of c:ConditionalSearchFilterType - it is analogous to situation when unmarshalling this type (TODO: rework this in a nicer way)
        xmap = marshalSearchFilterType((SearchFilterType) bean);
        if (SearchFilterType.class.equals(bean.getClass())) {
            // nothing more to serialize; otherwise we continue, because in that case we deal with a subclass of SearchFilterType
            return xmap;
        }
    } else {
        xmap = new MapXNode();
    }
    String namespace = inspector.determineNamespace(beanClass);
    if (namespace == null) {
        throw new IllegalArgumentException("Cannot determine namespace of " + beanClass);
    }
    List<String> propOrder = inspector.getPropOrder(beanClass);
    for (String fieldName : propOrder) {
        Method getter = inspector.findPropertyGetter(beanClass, fieldName);
        if (getter == null) {
            throw new IllegalStateException("No getter for field " + fieldName + " in " + beanClass);
        }
        Object getterResult = getValue(bean, getter, fieldName);
        if (getterResult == null) {
            continue;
        }
        Field field = inspector.findPropertyField(beanClass, fieldName);
        boolean isAttribute = inspector.isAttribute(field, getter);
        QName elementName = inspector.findFieldElementQName(fieldName, beanClass, namespace);
        if (getterResult instanceof Collection<?>) {
            Collection collection = (Collection) getterResult;
            if (collection.isEmpty()) {
                continue;
            }
            Iterator i = collection.iterator();
            Object getterResultValue = i.next();
            if (getterResultValue == null) {
                continue;
            }
            // TODO make sure it will be correct with respect to other items as well!
            if (getterResultValue instanceof JAXBElement && ((JAXBElement) getterResultValue).getName() != null) {
                elementName = ((JAXBElement) getterResultValue).getName();
            }
            ListXNode xlist = new ListXNode();
            for (Object value : collection) {
                if (value == null) {
                    continue;
                }
                Object valueToMarshal = value;
                if (value instanceof JAXBElement) {
                    valueToMarshal = ((JAXBElement) value).getValue();
                }
                QName typeName = inspector.findTypeName(field, valueToMarshal.getClass(), namespace);
                // note: fieldTypeName is used only for attribute values here (when constructing PrimitiveXNode)
                XNode marshaled = marshallValue(valueToMarshal, typeName, isAttribute, ctx);
                setExplicitTypeDeclarationIfNeeded(marshaled, getter, valueToMarshal, typeName);
                xlist.add(marshaled);
            }
            xmap.put(elementName, xlist);
        } else {
            QName fieldTypeName = inspector.findTypeName(field, getterResult.getClass(), namespace);
            Object valueToMarshall;
            if (getterResult instanceof JAXBElement) {
                valueToMarshall = ((JAXBElement) getterResult).getValue();
                elementName = ((JAXBElement) getterResult).getName();
            } else {
                valueToMarshall = getterResult;
            }
            XNode marshaled = marshallValue(valueToMarshall, fieldTypeName, isAttribute, ctx);
            // TODO reconcile with setExplioitTypeDeclarationIfNeeded
            if (!getter.getReturnType().equals(valueToMarshall.getClass()) && getter.getReturnType().isAssignableFrom(valueToMarshall.getClass()) && !(valueToMarshall instanceof Enum)) {
                PrismObjectDefinition def = prismContext.getSchemaRegistry().determineDefinitionFromClass(valueToMarshall.getClass());
                if (def != null) {
                    QName type = def.getTypeName();
                    marshaled.setTypeQName(type);
                    marshaled.setExplicitTypeDeclaration(true);
                }
            }
            xmap.put(elementName, marshaled);
        //				setExplicitTypeDeclarationIfNeeded(getter, valueToMarshall, xmap, fieldTypeName);
        }
    }
    return xmap;
}