/** * INTERNAL: * Build the nested record, this can be overwriten by subclasses to use their subclass instance. */ public XMLRecord buildNestedRow(Element element) { DOMRecord record = new DOMRecord(element); record.setUnmarshaller(this.getUnmarshaller()); record.setOwningObject(this.getCurrentObject()); record.setDocPresPolicy(this.getDocPresPolicy()); record.setReferenceResolver(referenceResolver); return record; }
public Object put(Object key, Object value) throws ValidationException { if (key instanceof String) { return put((String)key, value); } else if (key instanceof DatabaseField) { return put((DatabaseField)key, value); } else if (key instanceof List) { return put((List<XMLField>)key, (List<XMLEntry>)value); } else { throw ValidationException.onlyFieldsAreValidKeysForDatabaseRows(); } }
/** * Stores the XML DOM value into the record. * Convert the DOM to text and add to the indexed record. */ public void setDOMInRecord(Element dom, Record record, EISInteraction call, EISAccessor accessor) { IndexedRecord indexedRecord = (IndexedRecord)record; indexedRecord.add(new org.eclipse.persistence.oxm.record.DOMRecord(dom).transformToXML()); }
/** * INTERNAL: * Create a record with the root element name get the namespace URI from the namespaceResolver. */ public DOMRecord(String rootElementName, String rootElementNamespaceURI) { this(); setDOM(createNewDocument(rootElementName, rootElementNamespaceURI)); }
/** * INTERNAL: * Create a record with the root element name get the namespace URI from the namespaceResolver. */ public DOMRecord(String rootElementName, NamespaceResolver namespaceResolver) { this(); String rootElementNamespaceURI = resolveNamespace(namespaceResolver, rootElementName); setDOM(createNewDocument(rootElementName, rootElementNamespaceURI)); }
Node root = record.getDOM(); org.w3c.dom.Document doc = record.getDocument(); XMLField xmlRootField = null; if (attributeValue == null) { root = XPathEngine.getInstance().create((XMLField) getField(), record.getDOM(), session); DOMRecord rootRecord = new DOMRecord(root); rootRecord.setSession(session); rootRecord.setDocPresPolicy(record.getDocPresPolicy()); rootRecord.setNamespaceResolver(record.getNamespaceResolver()); rootRecord.setMarshaller(record.getMarshaller()); record = rootRecord; ArrayList childNodes = getUnmappedChildNodes(record.getDOM().getChildNodes()); Object iter = cp.iteratorFor(attributeValue); int childNodeCount = 0; while (cp.hasNext(iter) && (childNodeCount < childNodes.size())) { Object element = cp.next(iter, session); element = convertObjectValueToDataValue(element, session, record.getMarshaller()); Object originalObject = element; Node nextChild = null; xmlRootField.setNamespaceResolver(record.getNamespaceResolver()); element = ((XMLRoot) element).getObject(); if (wasXMLRoot) { if (((XMLRoot) originalObject).getNamespaceURI() != null) { String prefix = record.getNamespaceResolver().resolveNamespaceURI(((XMLRoot) originalObject).getNamespaceURI());
private Object buildObjectValuesFromDOMRecord(DOMRecord record, AbstractSession session, ObjectBuildingQuery query, JoinedAttributeManager joinManager) { Node root = record.getDOM(); NodeList nodes = root.getChildNodes(); Collection unmappedChildren = getUnmappedChildNodes(nodes); if ((i == (length - 1)) || (next.getNodeValue().trim().length() > 0)) { objectValue = next.getNodeValue(); objectValue = convertDataValueToObjectValue(objectValue, session, record.getUnmarshaller()); return objectValue; DOMRecord nestedRecord = (DOMRecord) record.buildNestedRow((Element) next); schemaTypeQName = new QName(url, frag.getLocalName()); XMLContext xmlContext = nestedRecord.getUnmarshaller().getXMLContext(); referenceDescriptor = xmlContext.getDescriptorByGlobalType(frag); referenceDescriptor = getDescriptor(nestedRecord, session, new QName(nestedRecord.getNamespaceURI(), nestedRecord.getLocalName())); } catch (XMLMarshalException e) { referenceDescriptor = null; return ((XMLDescriptor) referenceDescriptor).wrapObjectInXMLRoot(objVal, next.getNamespaceURI(), next.getLocalName(), next.getPrefix(), false, record.isNamespaceAware(),record.getUnmarshaller());
element = bytes; } else { DOMRecord include = new DOMRecord(field.getLastXPathFragment().getLocalName()); include.setSession(session); include.put(includeField, c_id); element = include; XMLField incField = new XMLField(xpath); incField.setNamespaceResolver(resolver); Object obj = include.getIndicatingNoEntry(incField); if (obj != null && obj instanceof DOMRecord) { if (((DOMRecord) obj).getDOM().getNodeType() == Node.ELEMENT_NODE) { ((Element) ((DOMRecord) obj).getDOM()).setAttributeNS(javax.xml.XMLConstants.XMLNS_ATTRIBUTE_NS_URI, javax.xml.XMLConstants.XMLNS_ATTRIBUTE + XMLConstants.COLON + XMLConstants.XOP_PREFIX, XMLConstants.XOP_URL);
XMLField field = convertToXMLField(key); Object nodeValue = convertToNodeValue(value); NodeList replaced = null; boolean isEmptyCollection = false; if (nodeValue instanceof Collection) { isEmptyCollection = ((Collection)nodeValue).size() == 0; replaced = XPathEngine.getInstance().replaceCollection(convertToXMLField(key), dom, (Collection)nodeValue, session); } else { replaced = XPathEngine.getInstance().replaceValue(convertToXMLField(key), dom, nodeValue, session); XPathEngine.getInstance().create(convertToXMLField(key), dom, nodeValue, lastUpdatedField, getDocPresPolicy(), session); } else if (replaced.item(0) == getDOM()) { setDOM(getDocument().getDocumentElement());
public Object getIndicatingNoEntry(DatabaseField key, boolean shouldReturnNode, boolean checkForXsiNil) { XMLField field = convertToXMLField(key); getValueFromAttribute((Attr)node, field); return getValueFromElement((Element)node.getParentNode(), node, field); return buildNestedRow((Element)node);
public Object getValuesIndicatingNoEntry(DatabaseField key, boolean shouldReturnNodes, AbstractNullPolicy nullPolicy) { XMLField field = convertToXMLField(key); NodeList nodeList = UnmarshalXPathEngine.getInstance().selectNodes(dom, field, field.getNamespaceResolver(), nullPolicy); while (tokenizer.hasMoreElements()) { String token = tokenizer.nextToken(); Object nextItem = convertValue((Element)next.getParentNode(), field, token); list.add(nextItem); result.add(null); } else { result.add(getValueFromElement((Element)next.getParentNode(), next, field)); result.add(buildNestedRow((Element)nodeList.item(x)));
public void addObjectToCache(Object obj, Node node, XMLMapping selfRecordMapping) { // Can't process non-element nodes if (node.getNodeType() != Node.ELEMENT_NODE) { return; } AbstractSession session = context.getSession(obj); XMLDescriptor xmlDescriptor = (XMLDescriptor)session.getDescriptor(obj); DOMRecord row = new DOMRecord((Element)node); row.setSession(session); Vector pk = xmlDescriptor.getObjectBuilder().extractPrimaryKeyFromRow(row, session); if (xmlDescriptor.shouldPreserveDocument() || xmlDescriptor.getPrimaryKeyFieldNames().size() > 0) { if ((pk == null) || (pk.size() == 0)) { pk = new Vector(); pk.addElement(new WeakObjectWrapper(obj)); } CacheKey key = session.getIdentityMapAccessorInstance().acquireDeferredLock(pk, xmlDescriptor.getJavaClass(), xmlDescriptor); if ((xmlDescriptor).shouldPreserveDocument()) { key.setRecord(row); } key.setObject(obj); key.releaseDeferredLock(); } }
/** * Create a new row/record for the object builder with the given name and * namespace resolver instead of the namespace resolver from the descriptor. * This allows subclasses to define different record types. */ public AbstractRecord createRecord(String rootName, String rootUri, AbstractSession session) { XMLRecord xmlRec = new DOMRecord(rootName, rootUri); xmlRec.setSession(session); return xmlRec; }
DOMRecord row = new DOMRecord(csNode); row.setSession((AbstractSession) session); XMLField field = new XMLField(xPath); field.setNamespaceResolver(typeHelper.getNamespaceResolver()); row.put(field, value);
public List<XMLEntry> getValuesIndicatingNoEntry(List<DatabaseField> keys, boolean shouldReturnNodes) { List<XMLField> xmlFields = convertToXMLField(keys); List<XMLEntry> values = UnmarshalXPathEngine.getInstance().selectNodes(dom, xmlFields, xmlFields.get(0).getNamespaceResolver()); if(shouldReturnNodes) { return values; } for(XMLEntry next:values) { Node nextNode = (Node)next.getValue(); if(!(nextNode.getNodeType() == Node.ELEMENT_NODE)) { Object value = getValueFromElement((Element)nextNode.getParentNode(), nextNode, next.getXMLField()); next.setValue(value); } else { next.setValue(buildNestedRow((Element)nextNode)); } } return values; }
/** * INTERNAL: * Add the field-value pair to the document. */ public void add(DatabaseField key, Object value) { // Value may be a direct value, nested record, or collection of values. Object nodeValue = convertToNodeValue(value); XPathEngine.getInstance().create(convertToXMLField(key), dom, nodeValue, session); }
public Object put(List<XMLField> xmlFields, List<XMLEntry> values) { Vector valuesToWrite = (Vector)convertToNodeValue(values); List<XMLEntry> replaced = null; replaced = XPathEngine.getInstance().replaceCollection(xmlFields, valuesToWrite, dom, getDocPresPolicy(), lastUpdatedField, session); if(replaced.size() == 0) { XPathEngine.getInstance().create(xmlFields, dom, valuesToWrite, lastUpdatedField, getDocPresPolicy(), session); } return replaced; }
/** * PUBLIC: * Clear the sub-nodes of the DOM. */ public void clear() { if(getDOM() instanceof Element) { String domName = ((Element)getDOM()).getTagName(); this.dom = createNewDocument(domName, null); this.currentNode = this.dom; } }
/** * INTERNAL: * Convert the value which may be a direct value, nested record, or set of nested records, * to a node value usable with the XPathEngine. */ private Object convertToNodeValue(Object value) { if (value instanceof List) { List values = (List)value; Vector nodeValues = new Vector(values.size()); for (int index = 0; index < values.size(); index++) { Object nestedValue = values.get(index); nodeValues.add(convertToNodeValue(nestedValue)); } return nodeValues; } else if (value instanceof DOMRecord) { return ((DOMRecord)value).getDOM(); } else if (value != null && value.getClass() == XMLEntry.class) { XMLEntry entry = (XMLEntry)value; entry.setValue(convertToNodeValue(entry.getValue())); return entry; } else { return value; } }
Object currentObject = record.getCurrentObject(); Object value = getAttributeAccessor().getAttributeValueFromObject(currentObject); container = value != null ? value : cp.containerInstance(); org.w3c.dom.Element root = (Element) record.getDOM(); NamedNodeMap attributes = root.getAttributes(); Attr next;