Search in sources :

Example 1 with TypeHelper

use of commonj.sdo.helper.TypeHelper in project metro-jax-ws by eclipse-ee4j.

the class SDOUtils method validateSupportedType.

public static boolean validateSupportedType(HelperContext hc, String javaType, QName qname) {
    TypeHelper typeHelper = hc.getTypeHelper();
    if (qname != null) {
        Type type = typeHelper.getType(qname.getNamespaceURI(), qname.getLocalPart());
        String java = ((SDOType) type).getInstanceClassName();
        if (java != null) {
            return java.equals(javaType);
        }
        return false;
    } else {
        if (isPrimitive(javaType)) {
            return true;
        }
        try {
            Class cls = Thread.currentThread().getContextClassLoader().loadClass(javaType);
            Type type = typeHelper.getType(cls);
            return type != null;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
}
Also used : TypeHelper(commonj.sdo.helper.TypeHelper) Type(commonj.sdo.Type) SDOType(org.eclipse.persistence.sdo.SDOType) SDOType(org.eclipse.persistence.sdo.SDOType) TransformerException(javax.xml.transform.TransformerException) TransformerConfigurationException(javax.xml.transform.TransformerConfigurationException) IOException(java.io.IOException) ParserConfigurationException(javax.xml.parsers.ParserConfigurationException)

Example 2 with TypeHelper

use of commonj.sdo.helper.TypeHelper in project metro-jax-ws by eclipse-ee4j.

the class SDOWrapperAccessor method initBuilders.

protected void initBuilders() {
    HashMap<Object, PropertySetter> setByQName = new HashMap<>();
    HashMap<Object, PropertyGetter> getByQName = new HashMap<>();
    HashMap<Object, PropertySetter> setByLocalpart = new HashMap<>();
    HashMap<Object, PropertyGetter> getByLocalpart = new HashMap<>();
    HashSet<String> elementLocalNames = new HashSet<>();
    TypeHelper helper = contextWrapper.getHelperContext().getTypeHelper();
    Type type = helper.getType(contentClass);
    @SuppressWarnings("unchecked") List<Property> properties = (List<Property>) type.getDeclaredProperties();
    for (Property p : properties) {
        QName qname = SDOUtils.getPropertyElementName(contextWrapper.getHelperContext(), p);
        SDOPropertyBuilder pBuilder = new SDOPropertyBuilder(qname, p.getType().getInstanceClass());
        setByQName.put(qname, pBuilder);
        getByQName.put(qname, pBuilder);
        setByLocalpart.put(qname.getLocalPart(), pBuilder);
        getByLocalpart.put(qname.getLocalPart(), pBuilder);
        if (elementLocalNames.contains(qname.getLocalPart())) {
            elementLocalNameCollision = true;
        } else {
            elementLocalNames.add(qname.getLocalPart());
        }
    }
    if (elementLocalNameCollision) {
        propertySetters = setByQName;
        propertyGetters = getByQName;
    } else {
        propertySetters = setByLocalpart;
        propertyGetters = getByLocalpart;
    }
}
Also used : TypeHelper(commonj.sdo.helper.TypeHelper) HashMap(java.util.HashMap) PropertySetter(com.sun.xml.ws.spi.db.PropertySetter) QName(javax.xml.namespace.QName) Type(commonj.sdo.Type) PropertyGetter(com.sun.xml.ws.spi.db.PropertyGetter) DataObject(commonj.sdo.DataObject) List(java.util.List) Property(commonj.sdo.Property) HashSet(java.util.HashSet)

Example 3 with TypeHelper

use of commonj.sdo.helper.TypeHelper in project eclipselink by eclipse-ee4j.

the class OpenSequencedTypeTestCases method testClassIdentity.

public void testClassIdentity() {
    TypeHelper helper = TypeHelper.INSTANCE;
    SDOType typeFromTypeHelper = (SDOType) helper.getType(SDOConstants.ORACLE_SDO_URL, "OpenSequencedType");
    assertNotNull("OpenSequencedType not found in TypeHelper", typeFromTypeHelper);
    // Test that the implClass of the Type found in TypeHelper matches the
    // Class in our library (therefore not generated dynamically).
    Class<OpenSequencedTypeImpl> classFromLib = OpenSequencedTypeImpl.class;
    assertEquals("Classes did not match", classFromLib, typeFromTypeHelper.getImplClass());
}
Also used : TypeHelper(commonj.sdo.helper.TypeHelper) OpenSequencedTypeImpl(org.eclipse.persistence.sdo.dataobjects.OpenSequencedTypeImpl) SDOType(org.eclipse.persistence.sdo.SDOType)

Example 4 with TypeHelper

use of commonj.sdo.helper.TypeHelper in project metro-jax-ws by eclipse-ee4j.

the class SDOContextWrapper method getTypeName.

@Override
public QName getTypeName(TypeInfo tr) {
    QName res = model.getXsdTypeName(((Class<?>) tr.type).getName());
    if (res != null) {
        return res;
    }
    HelperContext hc = contextResolver.getHelperContext(isClient, serviceName, properties);
    TypeHelper th = hc.getTypeHelper();
    Type t = th.getType((Class<?>) tr.type);
    XSDHelper helper = hc.getXSDHelper();
    String localName = helper.getLocalName(t);
    String namespaceURI = helper.getNamespaceURI(t);
    if (namespaceURI == null) {
        namespaceURI = t.getURI();
    }
    if (localName == null) {
        localName = t.getName();
    }
    return new QName(namespaceURI == null ? "" : namespaceURI, localName);
}
Also used : TypeHelper(commonj.sdo.helper.TypeHelper) Type(commonj.sdo.Type) HelperContext(commonj.sdo.helper.HelperContext) SDOHelperContext(org.eclipse.persistence.sdo.helper.SDOHelperContext) QName(javax.xml.namespace.QName) XSDHelper(commonj.sdo.helper.XSDHelper)

Example 5 with TypeHelper

use of commonj.sdo.helper.TypeHelper in project eclipselink by eclipse-ee4j.

the class SDOUnmarshalListener method afterUnmarshal.

/**
 * @param target assumed to be non-null
 * @param parent may be null, indicating target is root object
 */
@Override
public void afterUnmarshal(Object target, Object parent) {
    SDODataObject targetDataObject;
    // assume target is DataObject or ChangeSummary
    try {
        targetDataObject = (SDODataObject) target;
    } catch (ClassCastException ccex) {
        // each time we hit a ChangeSummary store it to process later and set its root
        // object - this is because we can't fully process the cs's because they have
        // references that can't be resolved until the full tree is built
        SDOChangeSummary sdoChangeSummary = (SDOChangeSummary) target;
        sdoChangeSummary.setRootDataObject((DataObject) parent);
        getChangeSummaries().add(sdoChangeSummary);
        return;
    }
    // if getType is sequenced, then update values to settings map
    if (targetDataObject.getType().isSequenced()) {
        targetDataObject.getSequence().afterUnmarshal();
    }
    // the last object that will hit the afterUnmarshal method
    if (parent == null && null != changeSummaries) {
        XMLUnmarshaller unmarshaller = null;
        for (int i = 0, changeSummariesSize = changeSummaries.size(); i < changeSummariesSize; i++) {
            SDOChangeSummary nextCS = changeSummaries.get(i);
            // Set logging to true until finished building modified list.
            boolean loggingValue = nextCS.isLoggingMapping();
            nextCS.setLogging(true);
            // CREATES
            // For each xpath in the create attribute convert it to an sdo path and execute it against the root
            // dataobject to get the dataobject being pointed to and set that dataobject to be created
            List xpaths = nextCS.getCreatedXPaths();
            for (int j = 0, xpathsSize = xpaths.size(); j < xpathsSize; j++) {
                String nextXPath = (String) xpaths.get(j);
                String sdoPath = convertXPathToSDOPath(nextXPath);
                SDODataObject nextCreatedDO = targetDataObject.getDataObject(sdoPath);
                if (nextCreatedDO == null) {
                    int nextSlash = sdoPath.indexOf('/');
                    if (nextSlash != -1) {
                        sdoPath = sdoPath.substring(nextSlash + 1);
                    } else {
                        sdoPath = "/";
                    }
                    nextCreatedDO = targetDataObject.getDataObject(sdoPath);
                }
                if (nextCreatedDO != null) {
                    nextCreatedDO._setCreated(true);
                    nextCS.getOldContainers().remove(nextCreatedDO);
                } else {
                    throw SDOException.errorProcessingXPath(nextXPath);
                }
            }
            // clear the createxpaths list that was read in from XML
            nextCS.setCreatedXPaths(null);
            // MODIFIED
            List modifiedDoms = nextCS.getModifiedDoms();
            for (int j = 0, modifiedDomsSize = modifiedDoms.size(); j < modifiedDomsSize; j++) {
                Element nextNode = (Element) modifiedDoms.get(j);
                String refValue = nextNode.getAttributeNS(SDOConstants.SDO_URL, SDOConstants.CHANGESUMMARY_REF);
                if ((refValue == null) || (refValue.length() == 0)) {
                    throw SDOException.missingRefAttribute();
                }
                // nextModifiedDO is the real modified current data object
                String sdoPath = convertXPathToSDOPath(refValue);
                SDODataObject nextModifiedDO = targetDataObject.getDataObject(sdoPath);
                // if it failed, try peeling off the first fragment (may be the root
                if (nextModifiedDO == null) {
                    int nextSlash = sdoPath.indexOf('/');
                    if (nextSlash != -1) {
                        sdoPath = sdoPath.substring(nextSlash + 1);
                    } else {
                        sdoPath = "/";
                    }
                    nextModifiedDO = targetDataObject.getDataObject(sdoPath);
                }
                String unsetValue = nextNode.getAttributeNS(SDOConstants.SDO_URL, SDOConstants.CHANGESUMMARY_UNSET);
                List unsetValueList = new ArrayList();
                if ((unsetValue != null) && (unsetValue.length() > 0)) {
                    XMLConversionManager xmlConversionManager = ((SDOXMLHelper) aHelperContext.getXMLHelper()).getXmlConversionManager();
                    unsetValueList = xmlConversionManager.convertObject(unsetValue, List.class);
                }
                if (nextModifiedDO != null) {
                    nextModifiedDO._setModified(true);
                    SDOCSUnmarshalListener listener = new SDOCSUnmarshalListener(nextModifiedDO.getType().getHelperContext(), true);
                    if (null == unmarshaller) {
                        unmarshaller = ((SDOXMLHelper) aHelperContext.getXMLHelper()).getXmlContext().createUnmarshaller();
                    }
                    unmarshaller.setUnmarshalListener(listener);
                    unmarshaller.getProperties().put("sdoHelperContext", aHelperContext);
                    unmarshaller.setUnmappedContentHandlerClass(SDOUnmappedContentHandler.class);
                    Object unmarshalledNode = unmarshaller.unmarshal(nextNode, nextModifiedDO.getType().getXmlDescriptor().getJavaClass());
                    // unmarshalledDO is the modified dataobject from the changesummary xml
                    SDODataObject unmarshalledDO = null;
                    // Assumption: unmarshalledNode should always be either an instance of XMLRoot or DataObject
                    if (unmarshalledNode instanceof XMLRoot) {
                        unmarshalledDO = (SDODataObject) ((XMLRoot) unmarshalledNode).getObject();
                    } else if (unmarshalledNode instanceof DataObject) {
                        unmarshalledDO = (SDODataObject) unmarshalledNode;
                    }
                    List modifiedProps = new ArrayList();
                    Node n = nextNode.getFirstChild();
                    TypeHelper typeHelper = aHelperContext.getTypeHelper();
                    while (n != null) {
                        if (n.getNodeType() == Node.ELEMENT_NODE) {
                            String propName = n.getLocalName();
                            Property nextProp = unmarshalledDO.getInstanceProperty(propName);
                            if (nextProp == null) {
                                nextProp = typeHelper.getOpenContentProperty(n.getNamespaceURI(), propName);
                            }
                            if (!modifiedProps.contains(nextProp)) {
                                modifiedProps.add(nextProp);
                            }
                        }
                        n = n.getNextSibling();
                    }
                    // instead of iterating over all props can we just check elements in cs and get appropriate properties from DO
                    for (int k = 0, modifiedPropsSize = modifiedProps.size(); k < modifiedPropsSize; k++) {
                        SDOProperty nextProp = (SDOProperty) modifiedProps.get(k);
                        if (!nextProp.getType().isDataType()) {
                            if (nextProp.isMany()) {
                                // original value is the list from the changesummary xml
                                List originalValue = unmarshalledDO.getList(nextProp);
                                List newList = new ArrayList();
                                List toDelete = new ArrayList();
                                List indexsToDelete = new ArrayList();
                                for (int l = 0, originalValueSize = originalValue.size(); l < originalValueSize; l++) {
                                    SDODataObject nextInList = (SDODataObject) originalValue.get(l);
                                    String sdoRef = nextInList._getSdoRef();
                                    if (sdoRef != null) {
                                        // if sdoRef is not null then object is modified
                                        String sdoRefPath = convertXPathToSDOPath(sdoRef);
                                        int nextSlash = sdoRefPath.indexOf('/');
                                        if (nextSlash != -1) {
                                            sdoRefPath = sdoRefPath.substring(nextSlash + 1);
                                        } else {
                                            sdoRefPath = "/";
                                        }
                                        newList.add(targetDataObject.getDataObject(sdoRefPath));
                                    } else {
                                        // if sdo ref is null there is a deleted object
                                        toDelete.add(nextInList);
                                        indexsToDelete.add(l);
                                        newList.add(nextInList);
                                    }
                                }
                                // lw is the list from the real current data object
                                ListWrapper lw = ((ListWrapper) nextModifiedDO.getList(nextProp));
                                int indexsToDeleteSize = indexsToDelete.size();
                                if (indexsToDeleteSize > 0) {
                                    // after this loop, lw will have the entire list when logging was turned on
                                    nextCS.pauseLogging();
                                    for (int m = 0; m < indexsToDeleteSize; m++) {
                                        int toDeleteIndex = (Integer) indexsToDelete.get(m);
                                        SDODataObject nextToDelete = (SDODataObject) toDelete.get(m);
                                        lw.add(toDeleteIndex, nextToDelete);
                                    }
                                    nextCS.setPropertyInternal(nextModifiedDO, nextProp, lw);
                                    SDOSequence nextSeq = ((SDOSequence) nextCS.getOriginalSequences().get(nextModifiedDO));
                                    nextCS.resumeLogging();
                                    nextModifiedDO._setModified(true);
                                    for (int m = indexsToDeleteSize - 1; m >= 0; m--) {
                                        int toDeleteIndex = (Integer) indexsToDelete.get(m);
                                        SDODataObject nextToDelete = (SDODataObject) toDelete.get(m);
                                        if (nextSeq != null) {
                                            nextSeq.addSettingWithoutModifyingDataObject(-1, nextProp, nextToDelete);
                                        }
                                        nextToDelete.resetChanges();
                                        lw.remove(toDeleteIndex);
                                    }
                                }
                                nextCS.getOriginalElements().put(lw, newList);
                            } else {
                                SDODataObject value = unmarshalledDO.getDataObject(nextProp);
                                if (value != null) {
                                    String sdoRef = value._getSdoRef();
                                    if (sdoRef != null) {
                                        // modified
                                        nextModifiedDO._setModified(true);
                                    } else {
                                        // deleted
                                        value._setChangeSummary(nextCS);
                                        nextModifiedDO._setModified(true);
                                        nextCS.pauseLogging();
                                        boolean wasSet = nextModifiedDO.isSet(nextProp);
                                        Object existingValue = nextModifiedDO.get(nextProp);
                                        // grab index of nextProp's Setting for use during setting below
                                        Sequence nextModifiedDOSequence = nextModifiedDO.getSequence();
                                        int settingIdx = -1;
                                        if (nextModifiedDOSequence != null) {
                                            settingIdx = ((SDOSequence) nextModifiedDOSequence).getIndexForProperty(nextProp);
                                        }
                                        value._setContainmentPropertyName(null);
                                        value._setContainer(null);
                                        nextModifiedDO.set(nextProp, value);
                                        nextCS.setPropertyInternal(nextModifiedDO, nextProp, value);
                                        SDOSequence nextSeq = ((SDOSequence) nextCS.getOriginalSequences().get(nextModifiedDO));
                                        if (nextSeq != null) {
                                            nextSeq.addSettingWithoutModifyingDataObject(-1, nextProp, value);
                                        }
                                        nextCS.resumeLogging();
                                        nextModifiedDO._setModified(true);
                                        value.resetChanges();
                                        value.delete();
                                        if (wasSet) {
                                            // need to add at the right pos in the list, not at the end
                                            nextModifiedDO.set(nextProp, existingValue, false);
                                            if (settingIdx != -1) {
                                                nextModifiedDO.getSequence().addSettingWithoutModifyingDataObject(settingIdx, nextProp, existingValue);
                                            }
                                        } else {
                                            nextModifiedDO.unset(nextProp);
                                        }
                                    }
                                } else {
                                    nextModifiedDO._setModified(true);
                                    nextCS.setPropertyInternal(nextModifiedDO, nextProp, null);
                                }
                            }
                        } else {
                            nextModifiedDO._setModified(true);
                            Object value = unmarshalledDO.get(nextProp);
                            if (nextProp.isMany()) {
                                Property theProp = nextModifiedDO.getInstanceProperty(nextProp.getName());
                                if (theProp == null) {
                                    Property newProp = nextModifiedDO.defineOpenContentProperty(nextProp.getName(), new ArrayList(), nextProp.getType());
                                    nextModifiedDO.set(newProp, new ArrayList());
                                    theProp = newProp;
                                }
                                List lw = nextModifiedDO.getList(theProp.getName());
                                nextCS.setPropertyInternal(nextModifiedDO, theProp, lw);
                                nextCS.getOriginalElements().put(lw, ((ListWrapper) value).getCurrentElements());
                            } else {
                                nextCS.setPropertyInternal(nextModifiedDO, nextProp, value);
                            }
                        }
                    }
                    for (int k = 0, unsetValueListSize = unsetValueList.size(); k < unsetValueListSize; k++) {
                        SDOProperty nextProp = unmarshalledDO.getInstanceProperty((String) unsetValueList.get(k));
                        if (nextProp != null) {
                            Object oldValue = null;
                            if (nextProp.getType().isDataType() || nextProp.isMany()) {
                                // to get default
                                oldValue = unmarshalledDO.get(nextProp);
                            }
                            nextModifiedDO._setModified(true);
                            nextCS.setPropertyInternal(nextModifiedDO, nextProp, oldValue);
                            nextCS.unsetPropertyInternal(nextModifiedDO, nextProp);
                        } else {
                            nextProp = nextModifiedDO.getInstanceProperty((String) unsetValueList.get(k));
                            nextModifiedDO._setModified(true);
                            nextCS.setPropertyInternal(nextModifiedDO, nextProp, null);
                            nextCS.unsetPropertyInternal(nextModifiedDO, nextProp);
                        }
                    }
                } else {
                    throw SDOException.errorProcessingXPath(refValue);
                }
            }
            // clear modified doms list
            nextCS.setModifiedDoms(null);
            // clear deleted xpaths list
            nextCS.setDeletedXPaths(null);
            List created = nextCS.getCreated();
            for (int j = 0, createdSize = created.size(); j < createdSize; j++) {
                SDODataObject next = (SDODataObject) created.get(j);
                Property containmentProperty = next.getContainmentProperty();
                if (containmentProperty != null && containmentProperty.isMany()) {
                    SDODataObject container = next.getContainer();
                    ListWrapper list = (ListWrapper) container.get(containmentProperty);
                    if (!(nextCS.getOriginalElements().containsKey(list))) {
                        // if there was an object created as part of a list, and that list is not
                        // already in the original elements map. Add an empty list to the map.
                        nextCS.getOriginalElements().put(list, new ArrayList());
                    }
                }
            }
            nextCS.setLogging(loggingValue);
        }
        // reset changeSummary list - we are done with it
        changeSummaries = null;
    }
}
Also used : TypeHelper(commonj.sdo.helper.TypeHelper) XMLRoot(org.eclipse.persistence.oxm.XMLRoot) Element(org.w3c.dom.Element) Node(org.w3c.dom.Node) ArrayList(java.util.ArrayList) Sequence(commonj.sdo.Sequence) SDOSequence(org.eclipse.persistence.sdo.SDOSequence) SDOSequence(org.eclipse.persistence.sdo.SDOSequence) SDODataObject(org.eclipse.persistence.sdo.SDODataObject) DataObject(commonj.sdo.DataObject) SDOChangeSummary(org.eclipse.persistence.sdo.SDOChangeSummary) ArrayList(java.util.ArrayList) List(java.util.List) SDODataObject(org.eclipse.persistence.sdo.SDODataObject) DataObject(commonj.sdo.DataObject) XMLUnmarshaller(org.eclipse.persistence.oxm.XMLUnmarshaller) SDOProperty(org.eclipse.persistence.sdo.SDOProperty) Property(commonj.sdo.Property) SDOProperty(org.eclipse.persistence.sdo.SDOProperty) SDODataObject(org.eclipse.persistence.sdo.SDODataObject) XMLConversionManager(org.eclipse.persistence.internal.oxm.XMLConversionManager)

Aggregations

TypeHelper (commonj.sdo.helper.TypeHelper)5 Type (commonj.sdo.Type)3 DataObject (commonj.sdo.DataObject)2 Property (commonj.sdo.Property)2 List (java.util.List)2 QName (javax.xml.namespace.QName)2 SDOType (org.eclipse.persistence.sdo.SDOType)2 PropertyGetter (com.sun.xml.ws.spi.db.PropertyGetter)1 PropertySetter (com.sun.xml.ws.spi.db.PropertySetter)1 Sequence (commonj.sdo.Sequence)1 HelperContext (commonj.sdo.helper.HelperContext)1 XSDHelper (commonj.sdo.helper.XSDHelper)1 IOException (java.io.IOException)1 ArrayList (java.util.ArrayList)1 HashMap (java.util.HashMap)1 HashSet (java.util.HashSet)1 ParserConfigurationException (javax.xml.parsers.ParserConfigurationException)1 TransformerConfigurationException (javax.xml.transform.TransformerConfigurationException)1 TransformerException (javax.xml.transform.TransformerException)1 XMLConversionManager (org.eclipse.persistence.internal.oxm.XMLConversionManager)1