Examples with CoreAbstractSession org.eclipse.persistence.internal.core.sessions.CoreAbstractSession used on opensource projects

Example 1 with CoreAbstractSession

use of org.eclipse.persistence.internal.core.sessions.CoreAbstractSession in project eclipselink by eclipse-ee4j.

the class SAXUnmarshaller method unmarshal.

@Override
public Object unmarshal(org.xml.sax.XMLReader xmlReader, InputSource inputSource, Class<?> clazz) {
    try {
        Context xmlContext = xmlUnmarshaller.getContext();
        if (xmlContext.hasDocumentPreservation() || (Node.class.isAssignableFrom(clazz) && xmlUnmarshaller.isApplicationXML())) {
            SAXDocumentBuilder saxDocumentBuilder = new SAXDocumentBuilder();
            xmlReader.setContentHandler(saxDocumentBuilder);
            xmlReader.parse(inputSource);
            return unmarshal(saxDocumentBuilder.getDocument().getDocumentElement(), clazz);
        }
        UnmarshalRecord unmarshalRecord = null;
        Descriptor xmlDescriptor = null;
        CoreAbstractSession session = null;
        boolean isPrimitiveWrapper = false;
        // via XMLRootRecord.
        if (clazz == CoreClassConstants.OBJECT) {
            SAXUnmarshallerHandler saxUnmarshallerHandler = new SAXUnmarshallerHandler(xmlUnmarshaller.getContext());
            saxUnmarshallerHandler.setXMLReader((XMLReader) xmlReader);
            saxUnmarshallerHandler.setUnmarshaller(xmlUnmarshaller);
            saxUnmarshallerHandler.setKeepAsElementPolicy(KEEP_UNKNOWN_AS_ELEMENT);
            xmlReader.setContentHandler(saxUnmarshallerHandler);
            xmlReader.parse(inputSource);
            // resolve any mapping references
            saxUnmarshallerHandler.resolveReferences();
            return saxUnmarshallerHandler.getObject();
        } else {
            // try and get a Unit Of Work from the XMLContext
            try {
                session = xmlContext.getSession(clazz);
                xmlDescriptor = (Descriptor) session.getDescriptor(clazz);
                unmarshalRecord = xmlUnmarshaller.createUnmarshalRecord(xmlDescriptor, session);
            } catch (XMLMarshalException xme) {
                if (xme.getErrorCode() == XMLMarshalException.DESCRIPTOR_NOT_FOUND_IN_PROJECT) {
                    isPrimitiveWrapper = isPrimitiveWrapper(clazz);
                    if (isPrimitiveWrapper) {
                        unmarshalRecord = xmlUnmarshaller.createRootUnmarshalRecord(clazz);
                    } else {
                        throw xme;
                    }
                } else {
                    throw xme;
                }
            }
        }
        XMLReader extendedXMLReader;
        if (xmlReader instanceof XMLReader) {
            extendedXMLReader = (XMLReader) xmlReader;
        } else {
            extendedXMLReader = new XMLReader(xmlReader);
        }
        unmarshalRecord.setXMLReader(extendedXMLReader);
        unmarshalRecord.setUnmarshaller(xmlUnmarshaller);
        setContentHandler(extendedXMLReader, unmarshalRecord);
        extendedXMLReader.setLexicalHandler(unmarshalRecord);
        extendedXMLReader.parse(inputSource);
        // resolve mapping references
        unmarshalRecord.resolveReferences(session, xmlUnmarshaller.getIDResolver());
        if (isPrimitiveWrapper || clazz == CoreClassConstants.OBJECT) {
            return unmarshalRecord.getCurrentObject();
        }
        return xmlDescriptor.wrapObjectInXMLRoot(unmarshalRecord, this.isResultAlwaysXMLRoot);
    } catch (IOException e) {
        throw XMLMarshalException.unmarshalException(e);
    } catch (SAXException e) {
        throw convertSAXException(e);
    } finally {
        xmlUnmarshaller.getStringBuffer().reset();
    }
}

Example 2 with CoreAbstractSession

use of org.eclipse.persistence.internal.core.sessions.CoreAbstractSession in project eclipselink by eclipse-ee4j.

the class DOMUnmarshaller method xmlToObject.

/**
 * INTERNAL: Convert the Oracle XMLDocument to the reference-class.
 */
public Object xmlToObject(DOMRecord xmlRow, Class<?> referenceClass) throws XMLMarshalException {
    try {
        // Try to get the Encoding and Version from DOM3 APIs if available
        String xmlEncoding = "UTF-8";
        String xmlVersion = "1.0";
        try {
            xmlEncoding = xmlRow.getDocument().getXmlEncoding() != null ? xmlRow.getDocument().getXmlEncoding() : xmlEncoding;
            xmlVersion = xmlRow.getDocument().getXmlVersion() != null ? xmlRow.getDocument().getXmlVersion() : xmlVersion;
        } catch (Exception ex) {
        // if the methods aren't available, then just use the default values
        }
        XMLContext xmlContext = xmlUnmarshaller.getXMLContext();
        // populate and return an XMLRoot
        if (referenceClass != null && (XMLConversionManager.getDefaultJavaTypes().get(referenceClass) != null || CoreClassConstants.XML_GREGORIAN_CALENDAR.isAssignableFrom(referenceClass) || CoreClassConstants.DURATION.isAssignableFrom(referenceClass))) {
            // we're assuming that since we're unmarshalling to a primitive
            // wrapper, the root element has a single text node
            Object nodeVal;
            try {
                Text rootTxt = (Text) xmlRow.getDOM().getFirstChild();
                nodeVal = rootTxt.getNodeValue();
            } catch (Exception ex) {
                // here, either the root element doesn't have a text node as a
                // first child, or there is no first child at all - in any case,
                // try converting null
                nodeVal = null;
            }
            Object obj = xmlContext.getSession().getDatasourcePlatform().getConversionManager().convertObject(nodeVal, referenceClass);
            Root xmlRoot = new XMLRoot();
            xmlRoot.setObject(obj);
            String lName = xmlRow.getDOM().getLocalName();
            if (lName == null) {
                lName = xmlRow.getDOM().getNodeName();
            }
            xmlRoot.setLocalName(lName);
            xmlRoot.setNamespaceURI(xmlRow.getDOM().getNamespaceURI());
            xmlRoot.setEncoding(xmlEncoding);
            xmlRoot.setVersion(xmlVersion);
            return xmlRoot;
        }
        Descriptor descriptor = null;
        CoreAbstractSession readSession = null;
        boolean shouldWrap = true;
        if (referenceClass == null) {
            QName rootQName = new QName(xmlRow.getNamespaceURI(), xmlRow.getLocalName());
            descriptor = xmlContext.getDescriptor(rootQName);
            if (null == descriptor) {
                String type = ((Element) xmlRow.getDOM()).getAttributeNS(javax.xml.XMLConstants.W3C_XML_SCHEMA_INSTANCE_NS_URI, "type");
                if (null != type) {
                    XPathFragment typeFragment = new XPathFragment(type);
                    String namespaceURI = xmlRow.resolveNamespacePrefix(typeFragment.getPrefix());
                    typeFragment.setNamespaceURI(namespaceURI);
                    descriptor = xmlContext.getDescriptorByGlobalType(typeFragment);
                }
            } else {
                if (null != descriptor.getDefaultRootElementField() && !descriptor.isResultAlwaysXMLRoot() && !xmlUnmarshaller.isResultAlwaysXMLRoot()) {
                    String descLocalName = descriptor.getDefaultRootElementField().getXPathFragment().getLocalName();
                    String localName = xmlRow.getDOM().getLocalName();
                    if (localName == null) {
                        localName = xmlRow.getDOM().getNodeName();
                    }
                    String namespaceURI = xmlRow.getDOM().getNamespaceURI();
                    if (descLocalName != null && descLocalName.equals(localName)) {
                        String descUri = descriptor.getDefaultRootElementField().getXPathFragment().getNamespaceURI();
                        if ((namespaceURI == null && descUri == null) || (namespaceURI != null && namespaceURI.length() == 0 && descUri == null) || (namespaceURI != null && namespaceURI.equals(descUri))) {
                            // found a descriptor based on root element then know we won't need to wrap in an XMLRoot
                            shouldWrap = false;
                        }
                    }
                }
            }
            if (null == descriptor) {
                throw XMLMarshalException.noDescriptorWithMatchingRootElement(rootQName.toString());
            } else {
                readSession = xmlContext.getSession(descriptor.getJavaClass());
            }
        } else {
            // for XMLObjectReferenceMappings we need a non-shared cache, so
            // try and get a Unit Of Work from the XMLContext
            readSession = xmlContext.getSession(referenceClass);
            descriptor = (Descriptor) readSession.getDescriptor(referenceClass);
            if (descriptor == null) {
                throw XMLMarshalException.descriptorNotFoundInProject(referenceClass.getName());
            }
        }
        Object object = null;
        if (null == xmlRow.getDOM().getAttributes().getNamedItemNS(javax.xml.XMLConstants.W3C_XML_SCHEMA_INSTANCE_NS_URI, Constants.SCHEMA_NIL_ATTRIBUTE)) {
            xmlRow.setUnmarshaller(xmlUnmarshaller);
            xmlRow.setDocPresPolicy(xmlContext.getDocumentPreservationPolicy((AbstractSession) readSession));
            XMLObjectBuilder objectBuilder = (XMLObjectBuilder) descriptor.getObjectBuilder();
            ReadObjectQuery query = new ReadObjectQuery();
            query.setReferenceClass(referenceClass);
            query.setSession((AbstractSession) readSession);
            object = objectBuilder.buildObject(query, xmlRow, null);
            // resolve mapping references
            xmlRow.resolveReferences(readSession, xmlUnmarshaller.getIDResolver());
        }
        String elementNamespaceUri = xmlRow.getDOM().getNamespaceURI();
        String elementLocalName = xmlRow.getDOM().getLocalName();
        if (elementLocalName == null) {
            elementLocalName = xmlRow.getDOM().getNodeName();
        }
        String elementPrefix = xmlRow.getDOM().getPrefix();
        if (shouldWrap || descriptor.isResultAlwaysXMLRoot() || isResultAlwaysXMLRoot) {
            return descriptor.wrapObjectInXMLRoot(object, elementNamespaceUri, elementLocalName, elementPrefix, xmlEncoding, xmlVersion, this.isResultAlwaysXMLRoot, true, xmlUnmarshaller);
        } else {
            return object;
        }
    } finally {
        xmlUnmarshaller.getStringBuffer().reset();
    }
}

Example 3 with CoreAbstractSession

use of org.eclipse.persistence.internal.core.sessions.CoreAbstractSession in project eclipselink by eclipse-ee4j.

the class XPathObjectBuilder method buildRow.

@Override
public XMLRecord buildRow(XMLRecord record, Object object, CoreAbstractSession session, Marshaller marshaller, XPathFragment rootFragment) {
    lazyInitialize();
    XPathNode textNode = rootXPathNode.getTextNode();
    List<XPathNode> nonAttributeChildren = rootXPathNode.getNonAttributeChildren();
    if (null == textNode && null == nonAttributeChildren) {
        return record;
    }
    Descriptor xmlDescriptor = (Descriptor) descriptor;
    XPathNode node = rootXPathNode;
    MarshalRecord marshalRecord = (MarshalRecord) record;
    QName schemaType = null;
    if (marshalRecord.getCycleDetectionStack().contains(object, marshaller.isEqualUsingIdenity())) {
        if (cycleRecoverableClass == null) {
            initCycleRecoverableClasses();
        }
        if (cycleRecoverableClass != null && cycleRecoverableClass.isAssignableFrom(object.getClass())) {
            try {
                Object jaxbMarshaller = marshaller.getProperty(Constants.JAXB_MARSHALLER);
                // Create a proxy instance of CycleRecoverable$Context, a parameter to
                // the onCycleDetected method
                Object contextProxy = CycleRecoverableContextProxy.getProxy(cycleRecoverableContextClass, jaxbMarshaller);
                // Invoke onCycleDetected method, passing in proxy, and reset
                // 'object' to the returned value
                Method onCycleDetectedMethod = object.getClass().getMethod(ON_CYCLE_DETECTED, cycleRecoverableContextClass);
                object = PrivilegedAccessHelper.invokeMethod(onCycleDetectedMethod, object, new Object[] { contextProxy });
            } catch (Exception e) {
                throw XMLMarshalException.marshalException(e);
            }
            // Returned object might have a different descriptor
            xmlDescriptor = (Descriptor) session.getDescriptor(object.getClass());
            if (xmlDescriptor != null) {
                node = ((ObjectBuilder) xmlDescriptor.getObjectBuilder()).getRootXPathNode();
            } else {
                node = null;
            }
            // Push new object
            marshalRecord.getCycleDetectionStack().push(object);
            // Write xsi:type if onCycleDetected returned an object of a type different than the one mapped
            if (xmlDescriptor != descriptor) {
                if (xmlDescriptor == null) {
                    schemaType = record.getConversionManager().schemaType(object.getClass());
                } else {
                    schemaType = xmlDescriptor.getSchemaReference().getSchemaContextAsQName();
                }
                marshalRecord.writeXsiTypeAttribute(xmlDescriptor, schemaType.getNamespaceURI(), schemaType.getLocalPart(), schemaType.getPrefix(), false);
            }
        } else {
            // Push the duplicate object anyway, so that we can get the complete cycle string
            marshalRecord.getCycleDetectionStack().push(object);
            throw XMLMarshalException.objectCycleDetected(marshalRecord.getCycleDetectionStack().getCycleString());
        }
    } else {
        marshalRecord.getCycleDetectionStack().push(object);
    }
    NamespaceResolver namespaceResolver = null;
    if (xmlDescriptor != null) {
        namespaceResolver = xmlDescriptor.getNamespaceResolver();
    }
    MarshalContext marshalContext = null;
    if (xmlDescriptor != null && xmlDescriptor.isSequencedObject()) {
        SequencedObject sequencedObject = (SequencedObject) object;
        marshalContext = new SequencedMarshalContext(sequencedObject.getSettings());
    } else {
        marshalContext = ObjectMarshalContext.getInstance();
    }
    if (null == nonAttributeChildren) {
        textNode.marshal((MarshalRecord) record, object, session, namespaceResolver, marshaller, marshalContext, rootFragment);
    } else {
        if (node == null) {
            // No descriptor for this object, so manually create a MappingNodeValue and marshal it
            XPathNode n = new XPathNode();
            CompositeObjectMapping<AbstractSession, AttributeAccessor, ContainerPolicy, Converter, ClassDescriptor, DatabaseField, XMLMarshaller, Session, UnmarshalKeepAsElementPolicy, XMLUnmarshaller, org.eclipse.persistence.oxm.record.XMLRecord> m = new XMLCompositeObjectMapping();
            m.setXPath(".");
            XMLCompositeObjectMappingNodeValue nv = new XMLCompositeObjectMappingNodeValue(m);
            n.setMarshalNodeValue(nv);
            nv.marshalSingleValue(new XPathFragment("."), marshalRecord, null, object, session, namespaceResolver, marshalContext);
        } else {
            for (int x = 0, size = marshalContext.getNonAttributeChildrenSize(node); x < size; x++) {
                XPathNode xPathNode = (XPathNode) marshalContext.getNonAttributeChild(x, node);
                xPathNode.marshal((MarshalRecord) record, object, session, namespaceResolver, marshaller, marshalContext.getMarshalContext(x), rootFragment);
            }
        }
    }
    marshalRecord.getCycleDetectionStack().pop();
    return record;
}

Example 4 with CoreAbstractSession

use of org.eclipse.persistence.internal.core.sessions.CoreAbstractSession in project eclipselink by eclipse-ee4j.

the class SAXUnmarshaller method unmarshal.

public Object unmarshal(InputSource inputSource, Class<?> clazz, XMLReader xmlReader) {
    if (inputSource != null && null == inputSource.getSystemId()) {
        inputSource.setSystemId(this.systemId);
    }
    UnmarshalRecord unmarshalRecord = null;
    Descriptor xmlDescriptor = null;
    // for XMLObjectReferenceMappings we need a non-shared cache, so
    // try and get a Unit Of Work from the XMLContext
    CoreAbstractSession session = null;
    // check for case where the reference class is a primitive wrapper - in this case, we
    // need to use the conversion manager to convert the node's value to the primitive
    // wrapper class, then create, populate and return an XMLRoot. This will be done
    // via XMLRootRecord.
    boolean isPrimitiveWrapper = false;
    if (clazz == CoreClassConstants.OBJECT) {
        try {
            SAXUnmarshallerHandler saxUnmarshallerHandler = new SAXUnmarshallerHandler(xmlUnmarshaller.getContext());
            saxUnmarshallerHandler.setXMLReader(xmlReader);
            saxUnmarshallerHandler.setUnmarshaller(xmlUnmarshaller);
            saxUnmarshallerHandler.setKeepAsElementPolicy(KEEP_UNKNOWN_AS_ELEMENT);
            setContentHandler(xmlReader, saxUnmarshallerHandler);
            xmlReader.parse(inputSource);
            // resolve any mapping references
            saxUnmarshallerHandler.resolveReferences();
            return saxUnmarshallerHandler.getObject();
        } catch (IOException e) {
            throw XMLMarshalException.unmarshalException(e);
        } catch (SAXException e) {
            throw convertSAXException(e);
        }
    } else {
        // try and get a Unit Of Work from the XMLContext
        try {
            session = xmlUnmarshaller.getContext().getSession(clazz);
            xmlDescriptor = (Descriptor) session.getDescriptor(clazz);
            unmarshalRecord = xmlUnmarshaller.createUnmarshalRecord(xmlDescriptor, session);
        } catch (XMLMarshalException xme) {
            if (xme.getErrorCode() == XMLMarshalException.DESCRIPTOR_NOT_FOUND_IN_PROJECT) {
                isPrimitiveWrapper = isPrimitiveWrapper(clazz);
                if (isPrimitiveWrapper) {
                    unmarshalRecord = xmlUnmarshaller.createRootUnmarshalRecord(clazz);
                } else {
                    throw xme;
                }
            } else {
                throw xme;
            }
        }
    }
    try {
        unmarshalRecord.setXMLReader(xmlReader);
        unmarshalRecord.setUnmarshaller(xmlUnmarshaller);
        setContentHandler(xmlReader, unmarshalRecord);
        xmlReader.setLexicalHandler(unmarshalRecord);
        xmlReader.parse(inputSource);
    } catch (IOException e) {
        throw XMLMarshalException.unmarshalException(e);
    } catch (SAXException e) {
        throw convertSAXException(e);
    } finally {
        xmlUnmarshaller.getStringBuffer().reset();
    }
    // resolve mapping references
    unmarshalRecord.resolveReferences(session, xmlUnmarshaller.getIDResolver());
    if (isPrimitiveWrapper) {
        return unmarshalRecord.getCurrentObject();
    }
    return xmlDescriptor.wrapObjectInXMLRoot(unmarshalRecord, this.isResultAlwaysXMLRoot);
}

Example 5 with CoreAbstractSession

use of org.eclipse.persistence.internal.core.sessions.CoreAbstractSession in project eclipselink by eclipse-ee4j.

the class XMLRelationshipMappingNodeValue method processChild.

// Protected to public
public void processChild(XPathFragment xPathFragment, UnmarshalRecord unmarshalRecord, Attributes atts, Descriptor xmlDescriptor, Mapping mapping) throws SAXException {
    if (xmlDescriptor == null) {
        // Use the DescriptorNotFoundContentHandler to "look ahead" and determine if this is a simple or complex element
        // if it is complex the exception should be thrown
        DescriptorNotFoundContentHandler handler = new DescriptorNotFoundContentHandler(unmarshalRecord, mapping);
        String qnameString = xPathFragment.getLocalName();
        if (xPathFragment.getPrefix() != null) {
            qnameString = xPathFragment.getPrefix() + Constants.COLON + qnameString;
        }
        handler.startElement(xPathFragment.getNamespaceURI(), xPathFragment.getLocalName(), qnameString, atts);
        XMLReader xmlReader = unmarshalRecord.getXMLReader();
        xmlReader.setContentHandler(handler);
        xmlReader.setLexicalHandler(handler);
        return;
    }
    if (xmlDescriptor.hasInheritance()) {
        unmarshalRecord.setAttributes(atts);
        CoreAbstractSession session = unmarshalRecord.getSession();
        Class<?> classValue = ((ObjectBuilder) xmlDescriptor.getObjectBuilder()).classFromRow(unmarshalRecord, session);
        if (classValue == null) {
            // no xsi:type attribute - look for type indicator on the default root element
            XPathQName leafElementType = unmarshalRecord.getLeafElementType();
            // if we have a user-set type, try to get the class from the inheritance policy
            if (leafElementType != null) {
                Object indicator = xmlDescriptor.getInheritancePolicy().getClassIndicatorMapping().get(leafElementType);
                if (indicator != null) {
                    classValue = (Class) indicator;
                }
            }
            // if xsi:type is overriden by JSON_TYPE_ATTRIBUTE_NAME unmarshall property
            if (classValue == null && unmarshalRecord.getUnmarshaller().isApplicationJSON() && unmarshalRecord.getUnmarshaller().getJsonTypeConfiguration().getJsonTypeAttributeName() != null && atts.getValue(unmarshalRecord.getUnmarshaller().getJsonTypeConfiguration().getJsonTypeAttributeName()) != null) {
                QName qname = new QName(xmlDescriptor.getSchemaReference().getSchemaContextAsQName().getNamespaceURI(), atts.getValue(unmarshalRecord.getUnmarshaller().getJsonTypeConfiguration().getJsonTypeAttributeName()));
                classValue = (Class) xmlDescriptor.getInheritancePolicy().getClassIndicatorMapping().get(qname);
            }
        }
        if (classValue != null) {
            xmlDescriptor = (Descriptor) session.getDescriptor(classValue);
        } else {
            // on the mapping -  make sure it is non-abstract
            if (Modifier.isAbstract(xmlDescriptor.getJavaClass().getModifiers())) {
                // need to throw an exception here
                throw DescriptorException.missingClassIndicatorField(unmarshalRecord, (org.eclipse.persistence.oxm.XMLDescriptor) xmlDescriptor.getInheritancePolicy().getDescriptor());
            }
        }
    }
    ObjectBuilder targetObjectBuilder = (ObjectBuilder) xmlDescriptor.getObjectBuilder();
    CoreAttributeGroup group = unmarshalRecord.getUnmarshalAttributeGroup();
    CoreAttributeGroup nestedGroup = null;
    if (group == XMLRecord.DEFAULT_ATTRIBUTE_GROUP) {
        nestedGroup = group;
    }
    if (nestedGroup == null) {
        CoreAttributeItem item = group.getItem(getMapping().getAttributeName());
        nestedGroup = item.getGroup(xmlDescriptor.getJavaClass());
        if (nestedGroup == null) {
            if (item.getGroup() == null) {
                nestedGroup = XMLRecord.DEFAULT_ATTRIBUTE_GROUP;
            } else {
                nestedGroup = item.getGroup();
            }
        }
    }
    UnmarshalRecord childRecord = unmarshalRecord.getChildUnmarshalRecord(targetObjectBuilder);
    childRecord.setAttributes(atts);
    childRecord.startDocument();
    childRecord.initializeRecord(null);
    childRecord.setUnmarshalAttributeGroup(nestedGroup);
    childRecord.startElement(xPathFragment.getNamespaceURI(), xPathFragment.getLocalName(), xPathFragment.getShortName(), atts);
    XMLReader xmlReader = unmarshalRecord.getXMLReader();
    xmlReader.setContentHandler(childRecord);
    xmlReader.setLexicalHandler(childRecord);
}