// !! !!
// required conditions: 1) DataObject is open
// purpose: when property is undefined, set still does 'set', get still 'get', instance property
// list is still ok.
// test undefined is not in instance property list
// tset after set, it is in the list, and value is what we want
public void testSetGetWithUnDefinedProperty_openDataObject() {
try {
dataObject.set(UNDEFINED_PROPERTY_INDEX, CONTROL_STRING_1); // set undefined Property value
} catch (SDOException e) {
assertEquals(SDOException.PROPERTY_NOT_FOUND_AT_INDEX, e.getErrorCode());
return;
}
fail("an SDOException should have occurred.");
}
// required conditions: 1) DataObject is not open
// purpose: IllegalArgumentException can be thrown for undefined Property when get.
public void testGetInvalidPropertyIndex_WithDataObject_Not_Open() {
try {
dataObject_Not_Open.get(UNDEFINED_PROPERTY_INDEX); // get undefined Property value
} catch (SDOException e) {
assertEquals(SDOException.PROPERTY_NOT_FOUND_AT_INDEX, e.getErrorCode());
return;
}
fail("an SDOException should have occurred.");
}
// required condition: none
// purpose: test get with index -1
public void testGetWith_MINUS_ONE() {
try {
dataObject_Not_Open.get(MINUS_ONE); // get undefined Property value
fail("An IllegalArgumentException should have been thrown.");
} catch (SDOException e) {
assertEquals(SDOException.PROPERTY_NOT_FOUND_AT_INDEX, e.getErrorCode());
return;
}
fail("an SDOException should have occurred.");
}
// required conditions: 1) DataObject is not open
// purpose: IllegalArgumentException can be thrown for valid Property index when set.
public void testSetValidPropertyINdex_WithDataObject_Not_Open() {
try {
dataObject_Not_Open.set(
DEFINED_PROPERTY_INDEX, CONTROL_STRING_1); // set defined Property value
} catch (SDOException e) {
assertEquals(SDOException.PROPERTY_NOT_FOUND_AT_INDEX, e.getErrorCode());
return;
}
fail("an SDOException should have occurred.");
}
// required condition: none
// purpose: test set with -1
public void testSetWith_MINUS_ONE() {
try {
SDOProperty NUll = null;
dataObject_Not_Open.set(MINUS_ONE, CONTROL_STRING_1); // set undefined Property value
} catch (SDOException e) {
assertEquals(SDOException.PROPERTY_NOT_FOUND_AT_INDEX, e.getErrorCode());
return;
}
fail("an SDOException should have occurred.");
}
/** INTERNAL: */
public Class getImplClass() {
if ((javaImplClass == null) && (getImplClassName() != null)) {
try {
SDOClassLoader loader = ((SDOXMLHelper) aHelperContext.getXMLHelper()).getLoader();
javaImplClass = loader.loadClass(getImplClassName(), this);
xmlDescriptor.setJavaClass(javaImplClass);
} catch (ClassNotFoundException e) {
throw SDOException.classNotFound(e, getURI(), getName());
} catch (SecurityException e) {
throw SDOException.classNotFound(e, getURI(), getName());
}
}
return javaImplClass;
}
public void testDefine() {
DefaultSchemaResolver schemaResolver = new DefaultSchemaResolver();
schemaResolver.setBaseSchemaLocation(getSchemaLocation());
try {
((SDOXSDHelper) xsdHelper).define(new StreamSource(getSchemaToDefine()), schemaResolver);
} catch (SDOException e) {
assertEquals(SDOException.REFERENCED_PROPERTY_NOT_FOUND, e.getErrorCode());
return;
}
fail("An exception should have occurred but didn't");
}
/**
* INTERNAL: Make this Type an opened Type to allow open content by assigning true value or a Type
* not to accept any additional properties by assigning false value, {@link isOpen()}.
*
* @param bOpen boolean value implying if this Type is open
*/
public void setOpen(boolean bOpen) {
if (isDataType() && bOpen) {
throw SDOException.typeCannotBeOpenAndDataType(getURI(), getName());
}
if (open != bOpen) {
open = bOpen;
if (open) {
if (isSubType()) {
Type baseType = (Type) getBaseTypes().get(0);
if (!baseType.isOpen()) {
addOpenMappings();
}
} else {
addOpenMappings();
}
if (isBaseType()) {
for (int i = 0; i < getSubTypes().size(); i++) {
SDOType nextSubType = (SDOType) getSubTypes().get(i);
nextSubType.setOpen(bOpen);
}
}
}
}
}
private void save(XMLDocument xmlDocument, Writer outputWriter, XMLMarshaller anXMLMarshaller)
throws IOException {
if (xmlDocument == null) {
throw new IllegalArgumentException(
SDOException.cannotPerformOperationWithNullInputParameter("save", "xmlDocument"));
}
// Ask the SDOXMLDocument if we should include the XML declaration in the resulting XML
anXMLMarshaller.setFragment(!xmlDocument.isXMLDeclaration());
anXMLMarshaller.setEncoding(xmlDocument.getEncoding());
anXMLMarshaller.setSchemaLocation(xmlDocument.getSchemaLocation());
anXMLMarshaller.setNoNamespaceSchemaLocation(xmlDocument.getNoNamespaceSchemaLocation());
WriterRecord writerRecord;
if (anXMLMarshaller.isFormattedOutput()) {
writerRecord = new FormattedWriterRecord();
} else {
writerRecord = new WriterRecord();
}
writerRecord.setWriter(outputWriter);
writerRecord.setMarshaller(anXMLMarshaller);
((SDOMarshalListener) anXMLMarshaller.getMarshalListener())
.setMarshalledObject(xmlDocument.getRootObject());
((SDOMarshalListener) anXMLMarshaller.getMarshalListener())
.setMarshalledObjectRootQName(
new QName(xmlDocument.getRootElementURI(), xmlDocument.getRootElementName()));
((SDOMarshalListener) anXMLMarshaller.getMarshalListener()).setRootMarshalRecord(writerRecord);
anXMLMarshaller.marshal(xmlDocument, writerRecord);
outputWriter.flush();
}
public DataObject create(String uri, String typeName) {
Type sdoType = getHelperContext().getTypeHelper().getType(uri, typeName);
if (sdoType != null) {
return create(sdoType);
}
throw new IllegalArgumentException(SDOException.typeNotFound(uri, typeName));
}
public DataObject create(Type type) {
if (type == null) {
throw new IllegalArgumentException(
SDOException.cannotPerformOperationWithNullInputParameter("create", "type"));
}
SDOType sdoType = (SDOType) type;
if (sdoType.isAbstract()) {
// throw illegal arg exception
// spec page 40
throw new IllegalArgumentException(
SDOException.errorCreatingDataObjectForType(sdoType.getURI(), sdoType.getName()));
}
if (sdoType.isDataType()) {
SDOTypeHelper sth = (SDOTypeHelper) getHelperContext().getTypeHelper();
sdoType = (SDOType) sth.getWrappersHashMap().get(sdoType.getQName());
}
Class implClass;
try {
implClass = sdoType.getImplClass();
if (implClass != null) {
// initialization of the properties Map Implementation will be done in the default
// constructor call below
// testcase is in org.apache.tuscany.sdo.test
SDODataObject theDataObject = (SDODataObject) implClass.newInstance();
theDataObject._setType(sdoType);
theDataObject._setHelperContext(getHelperContext());
return theDataObject;
}
} catch (InstantiationException e) {
throw new IllegalArgumentException(
SDOException.errorCreatingDataObjectForClass(
e, (sdoType).getInstanceClassName(), sdoType.getURI(), sdoType.getName()));
} catch (IllegalAccessException e) {
throw new IllegalArgumentException(
SDOException.errorCreatingDataObjectForClass(
e, (sdoType).getInstanceClassName(), sdoType.getURI(), sdoType.getName()));
}
SDODataObject dataObject = new SDODataObject();
dataObject._setType(sdoType);
dataObject._setHelperContext(getHelperContext());
return dataObject;
}
/**
* Return the content of the appinfo declared for this Property and source. If the property is
* defined by ref= the appinfo of the referenced element or attribute is included. The appinfo
* start and end tags and content are returned. The xml namespace context is preserved in the
* appinfo element. If more than one appinfo with the same source is declared on the same Type
* their contents are concatenated.
*
* @param property the Property with the appinfo declaration
* @param source the source of the appinfo declaration.
* @return the appinfo declared for this Property and source.
*/
public String getAppinfo(Property property, String source) {
if (property == null) {
throw SDOException.noAppInfoForNull();
}
if (source == null) {
source = "";
}
return (String) ((SDOProperty) property).getAppInfoMap().get(source);
}
/**
* Returns the DataObject saved as an XML document with the specified root element. Same as
* StringWriter stringWriter = new StringWriter(); save(createDocument(dataObject, rootElementURI,
* rootElementName), stringWriter, null); stringWriter.toString();
*
* @param dataObject specifies DataObject to be saved
* @param rootElementURI the Target Namespace URI of the root XML element
* @param rootElementName the Name of the root XML element
* @return the saved XML document as a string
* @throws IllegalArgumentException if the dataObject tree is not closed or has no container.
*/
public String save(DataObject dataObject, String rootElementURI, String rootElementName) {
try {
StringWriter writer = new StringWriter();
save(dataObject, rootElementURI, rootElementName, writer, getXmlMarshaller(null));
return writer.toString();
} catch (XMLMarshalException e) {
throw SDOException.xmlMarshalExceptionOccurred(e, rootElementURI, rootElementName);
}
}
/**
* Return the appinfo declared for this Type and source. The appinfo start and end tags and
* content are returned. The xml namespace context is preserved in the appinfo element. If more
* than one appinfo with the same source is declared on the same Type their contents are
* concatenated.
*
* @param type the type with the appinfo declaration
* @param source the source of the appinfo declaration.
* @return the appinfo declared for this Type and source.
*/
public String getAppinfo(Type type, String source) {
if (type == null) {
throw SDOException.noAppInfoForNull();
}
if (source == null) {
source = "";
}
return (String) ((SDOType) type).getAppInfoMap().get(source);
}
/**
* INTERNAL: Set this Type to a simple Type by passing in boolean value true. Otherwise, If
* boolean value is passed in, instances of this type implement DataObject.
*
* @param datatype boolean value implying if it is a simple Type
*/
public void setDataType(boolean datatype) {
if (datatype && isOpen()) {
throw SDOException.typeCannotBeOpenAndDataType(getURI(), getName());
}
isDataType = datatype;
if (datatype) {
setFinalized(true);
}
}
private void handleXMLMarshalException(XMLMarshalException xmlException) throws IOException {
if (xmlException.getErrorCode() == XMLMarshalException.NO_DESCRIPTOR_WITH_MATCHING_ROOT_ELEMENT
|| xmlException.getErrorCode() == XMLMarshalException.DESCRIPTOR_NOT_FOUND_IN_PROJECT) {
throw SDOException.globalPropertyNotFound();
} else if (xmlException.getCause() instanceof IOException) {
throw (IOException) xmlException.getCause();
} else {
throw xmlException;
}
}
private void save(XMLDocument xmlDocument, Writer outputWriter, XMLMarshaller anXMLMarshaller)
throws IOException {
if (xmlDocument == null) {
throw new IllegalArgumentException(
SDOException.cannotPerformOperationWithNullInputParameter("save", "xmlDocument"));
}
// Ask the SDOXMLDocument if we should include the XML declaration in the resulting XML
anXMLMarshaller.setFragment(!xmlDocument.isXMLDeclaration());
anXMLMarshaller.setEncoding(xmlDocument.getEncoding());
anXMLMarshaller.setSchemaLocation(xmlDocument.getSchemaLocation());
anXMLMarshaller.setNoNamespaceSchemaLocation(xmlDocument.getNoNamespaceSchemaLocation());
WriterRecord writerRecord;
if (anXMLMarshaller.isFormattedOutput()) {
writerRecord = new FormattedWriterRecord();
} else {
writerRecord = new WriterRecord();
}
writerRecord.setWriter(outputWriter);
writerRecord.setMarshaller(anXMLMarshaller);
((SDOMarshalListener) anXMLMarshaller.getMarshalListener())
.setMarshalledObject(xmlDocument.getRootObject());
((SDOMarshalListener) anXMLMarshaller.getMarshalListener())
.setMarshalledObjectRootQName(
new QName(xmlDocument.getRootElementURI(), xmlDocument.getRootElementName()));
((SDOMarshalListener) anXMLMarshaller.getMarshalListener()).setRootMarshalRecord(writerRecord);
try {
anXMLMarshaller.marshal(xmlDocument, writerRecord);
} catch (XMLMarshalException xme) {
if (xme.getErrorCode() == XMLMarshalException.DESCRIPTOR_NOT_FOUND_IN_PROJECT) {
if (aHelperContext
!= ((SDOType) xmlDocument.getRootObject().getType()).getHelperContext()) {
throw SDOException.dataObjectNotFromHelperContext();
}
}
}
outputWriter.flush();
}
public void save(XMLDocument xmlDocument, Result result, Object options) throws IOException {
if (xmlDocument == null) {
throw new IllegalArgumentException(
SDOException.cannotPerformOperationWithNullInputParameter("save", "xmlDocument"));
}
if (result instanceof StreamResult) {
StreamResult streamResult = (StreamResult) result;
Writer writer = streamResult.getWriter();
if (null == writer) {
save(xmlDocument, streamResult.getOutputStream(), options);
} else {
save(xmlDocument, writer, options);
}
} else {
// get XMLMarshaller once - as we may create a new instance if this helper isDirty=true
XMLMarshaller anXMLMarshaller = getXmlMarshaller(options);
// Ask the SDOXMLDocument if we should include the XML declaration in the resulting XML
anXMLMarshaller.setFragment(!xmlDocument.isXMLDeclaration());
anXMLMarshaller.setEncoding(xmlDocument.getEncoding());
anXMLMarshaller.setSchemaLocation(xmlDocument.getSchemaLocation());
anXMLMarshaller.setNoNamespaceSchemaLocation(xmlDocument.getNoNamespaceSchemaLocation());
((SDOMarshalListener) anXMLMarshaller.getMarshalListener())
.setMarshalledObject(xmlDocument.getRootObject());
((SDOMarshalListener) anXMLMarshaller.getMarshalListener())
.setMarshalledObjectRootQName(
new QName(xmlDocument.getRootElementURI(), xmlDocument.getRootElementName()));
if (result instanceof SAXResult) {
ContentHandlerRecord marshalRecord = new ContentHandlerRecord();
marshalRecord.setContentHandler(((SAXResult) result).getHandler());
marshalRecord.setMarshaller(anXMLMarshaller);
((SDOMarshalListener) anXMLMarshaller.getMarshalListener())
.setRootMarshalRecord(marshalRecord);
anXMLMarshaller.marshal(xmlDocument, marshalRecord);
} else if (result instanceof DOMResult) {
NodeRecord marshalRecord = new NodeRecord();
marshalRecord.setDOM(((DOMResult) result).getNode());
marshalRecord.setMarshaller(anXMLMarshaller);
((SDOMarshalListener) anXMLMarshaller.getMarshalListener())
.setRootMarshalRecord(marshalRecord);
anXMLMarshaller.marshal(xmlDocument, marshalRecord);
} else {
StringWriter writer = new StringWriter();
this.save(xmlDocument, writer, options);
String xml = writer.toString();
StreamSource source = new StreamSource(new java.io.StringReader(xml));
anXMLMarshaller.getTransformer().transform(source, result);
}
}
}
/**
* Return the JAXB mapping for the SDO property. They are matched on their XML schema
* representation.
*/
Mapping getJAXBMappingForProperty(SDOProperty sdoProperty) {
DatabaseMapping sdoMapping = sdoProperty.getXmlMapping();
XMLField field;
if (sdoMapping instanceof XMLObjectReferenceMapping) {
XMLObjectReferenceMapping referenceMapping = (XMLObjectReferenceMapping) sdoMapping;
field = (XMLField) referenceMapping.getFields().get(0);
} else {
field = (XMLField) sdoMapping.getField();
}
TreeObjectBuilder treeObjectBuilder = (TreeObjectBuilder) descriptor.getObjectBuilder();
XPathNode xPathNode = treeObjectBuilder.getRootXPathNode();
XPathFragment xPathFragment = field.getXPathFragment();
while (xPathNode != null && xPathFragment != null) {
if (xPathFragment.isAttribute()) {
if (sdoProperty.isMany()
&& !sdoProperty.isContainment()
&& !sdoProperty.getType().isDataType()) {
xPathFragment = null;
break;
}
Map attributeChildrenMap = xPathNode.getAttributeChildrenMap();
if (null == attributeChildrenMap) {
xPathNode = null;
} else {
xPathNode = (XPathNode) attributeChildrenMap.get(xPathFragment);
}
} else if (xPathFragment.nameIsText()) {
xPathNode = xPathNode.getTextNode();
} else {
Map nonAttributeChildrenMap = xPathNode.getNonAttributeChildrenMap();
if (null == nonAttributeChildrenMap) {
xPathNode = null;
} else {
xPathNode = (XPathNode) nonAttributeChildrenMap.get(xPathFragment);
}
}
xPathFragment = xPathFragment.getNextFragment();
if (xPathFragment != null && xPathFragment.nameIsText()) {
if (sdoProperty.isMany() && !sdoProperty.isContainment()) {
xPathFragment = null;
break;
}
}
}
if (null == xPathFragment && xPathNode != null) {
if (xPathNode.getNodeValue().isMappingNodeValue()) {
MappingNodeValue mappingNodeValue = (MappingNodeValue) xPathNode.getNodeValue();
return mappingNodeValue.getMapping();
}
}
throw SDOException.sdoJaxbNoMappingForProperty(sdoProperty.getName(), field.getXPath());
}
/**
* Serializes an XMLDocument as an XML document into the outputStream. If the DataObject's Type
* was defined by an XSD, the serialization will follow the XSD. Otherwise the serialization will
* follow the format as if an XSD were generated as defined by the SDO specification. The
* OutputStream will be flushed after writing. Does not perform validation to ensure compliance
* with an XSD.
*
* @param xmlDocument specifies XMLDocument to be saved
* @param outputStream specifies the OutputStream to write to.
* @param options implementation-specific options.
* @throws IOException for stream exceptions.
* @throws IllegalArgumentException if the dataObject tree is not closed or has no container.
*/
public void save(XMLDocument xmlDocument, OutputStream outputStream, Object options)
throws IOException {
if (xmlDocument == null) {
throw new IllegalArgumentException(
SDOException.cannotPerformOperationWithNullInputParameter("save", "xmlDocument"));
}
XMLMarshaller xmlMarshaller = getXmlMarshaller(options);
String encoding = xmlMarshaller.getEncoding();
if (xmlDocument.getEncoding() != null) {
encoding = xmlDocument.getEncoding();
}
OutputStreamWriter writer = new OutputStreamWriter(outputStream, encoding);
save(xmlDocument, writer, xmlMarshaller);
}
/**
* Lazy load the WebLogic MBeanServer instance.
*
* @return
*/
private static MBeanServer getWLSMBeanServer() {
if (wlsMBeanServer == null) {
Context weblogicContext = null;
try {
weblogicContext = new InitialContext();
try {
// The lookup string used depends on the context from which this class is being
// accessed, i.e. servlet, EJB, etc. Try java:comp/env lookup
wlsMBeanServer = (MBeanServer) weblogicContext.lookup(WLS_ENV_CONTEXT_LOOKUP);
} catch (NamingException e) {
// Lookup failed - try java:comp
try {
wlsMBeanServer = (MBeanServer) weblogicContext.lookup(WLS_CONTEXT_LOOKUP);
} catch (NamingException ne) {
throw SDOException.errorPerformingWLSLookup(WLS_MBEAN_SERVER, ne);
}
}
} catch (NamingException nex) {
throw SDOException.errorCreatingWLSInitialContext(nex);
}
}
return wlsMBeanServer;
}
/**
* INTERNAL: This convenience method will look up a WebLogic execute thread from the runtime MBean
* tree. The execute thread contains application information. This code will use the name of the
* current thread to lookup the corresponding ExecuteThread. The ExecuteThread will allow us to
* obtain the application name (and version, etc).
*
* @return application name or null if the name cannot be obtained
*/
private static Object getExecuteThread() {
if (getWLSMBeanServer() != null) {
// Lazy load the ThreadPoolRuntime instance
if (wlsThreadPoolRuntime == null) {
ObjectName service = null;
ObjectName serverRuntime = null;
try {
service = new ObjectName(WLS_SERVICE_KEY);
} catch (Exception x) {
throw SDOException.errorGettingWLSObjectName(
WLS_RUNTIME_SERVICE + " [" + WLS_SERVICE_KEY + "]", x);
}
try {
serverRuntime = (ObjectName) wlsMBeanServer.getAttribute(service, WLS_SERVER_RUNTIME);
} catch (Exception x) {
throw SDOException.errorGettingWLSObjectName(WLS_SERVER_RUNTIME, x);
}
try {
wlsThreadPoolRuntime =
(ObjectName) wlsMBeanServer.getAttribute(serverRuntime, WLS_THREADPOOL_RUNTIME);
} catch (Exception x) {
throw SDOException.errorGettingWLSObjectName(WLS_THREADPOOL_RUNTIME, x);
}
}
try {
return wlsMBeanServer.invoke(
wlsThreadPoolRuntime,
WLS_EXECUTE_THREAD_GET_METHOD_NAME,
new Object[] {Thread.currentThread().getName()},
new String[] {String.class.getName()});
} catch (Exception x) {
throw SDOException.errorInvokingWLSMethodReflectively(
WLS_EXECUTE_THREAD_GET_METHOD_NAME, WLS_THREADPOOL_RUNTIME, x);
}
}
return null;
}
public DataObject create(Class interfaceClass) {
if (interfaceClass == null) {
throw new IllegalArgumentException(
SDOException.cannotPerformOperationWithNullInputParameter("create", "interfaceClass"));
}
Type type = getHelperContext().getTypeHelper().getType(interfaceClass);
if (type != null) {
return create(type);
}
// at this point the type may not have been defined or there could be a classloader issue
SDOXMLHelper xmlHelper = (SDOXMLHelper) getHelperContext().getXMLHelper();
ClassLoader contextLoader = xmlHelper.getLoader();
ClassLoader interfaceLoader = interfaceClass.getClassLoader();
boolean loadersAreRelated = false;
// check the hierarchy to see if the interface loader is a parent of the context loader
List<ClassLoader> visitedLoaders = new ArrayList<ClassLoader>();
while (contextLoader != null && !loadersAreRelated) {
if (visitedLoaders.contains(contextLoader)) {
// if we encounter a loader we've already checked, break out
break;
}
visitedLoaders.add(contextLoader);
if (contextLoader == interfaceLoader) {
loadersAreRelated = true;
}
ClassLoader parentLoader = contextLoader.getParent();
if (contextLoader == parentLoader) {
break;
}
contextLoader = parentLoader;
}
throw new IllegalArgumentException(
SDOException.typeNotFoundForInterface(interfaceClass.getName(), loadersAreRelated));
}
private XMLUnmarshaller getXmlUnmarshaller(Object options) {
XMLUnmarshaller xmlUnmarshaller = getXmlUnmarshaller().clone();
if (null == options) {
return xmlUnmarshaller;
}
try {
DataObject optionsDO = (DataObject) options;
if (optionsDO.isSet(SDOConstants.ATTACHMENT_UNMARSHALLER_OPTION)) {
xmlUnmarshaller.setAttachmentUnmarshaller(
(XMLAttachmentUnmarshaller) optionsDO.get(SDOConstants.ATTACHMENT_UNMARSHALLER_OPTION));
}
return xmlUnmarshaller;
} catch (ClassCastException ccException) {
throw SDOException.optionsMustBeADataObject(
ccException, SDOConstants.ORACLE_SDO_URL, SDOConstants.XMLHELPER_LOAD_OPTIONS);
}
}
private XMLMarshaller getXmlMarshaller(Object options) {
XMLMarshaller xmlMarshaller = getXmlMarshaller().clone();
if (null == options) {
return xmlMarshaller;
}
try {
DataObject optionsDO = (DataObject) options;
if (optionsDO.isSet(SDOConstants.ATTACHMENT_MARSHALLER_OPTION)) {
xmlMarshaller.setAttachmentMarshaller(
(XMLAttachmentMarshaller) optionsDO.get(SDOConstants.ATTACHMENT_MARSHALLER_OPTION));
}
xmlMarshaller.setMarshalListener(
new SDOMarshalListener(xmlMarshaller, (SDOTypeHelper) aHelperContext.getTypeHelper()));
return xmlMarshaller;
} catch (ClassCastException ccException) {
throw SDOException.optionsMustBeADataObject(
ccException, SDOConstants.ORACLE_SDO_URL, SDOConstants.XMLHELPER_LOAD_OPTIONS);
}
}
/**
* INTERNAL: Saves the DataObject as an XML document with the specified root element. Same as
* save(createDocument(dataObject, rootElementURI, rootElementName), writer, null);
*
* @param dataObject specifies DataObject to be saved
* @param rootElementURI the Target Namespace URI of the root XML element
* @param rootElementName the Name of the root XML element
* @param writer specifies the Writer to write to.
* @throws IOException for stream exceptions.
* @throws IllegalArgumentException if the dataObject tree is not closed or has no container.
*/
private void save(
DataObject rootObject,
String rootElementURI,
String rootElementName,
Writer writer,
XMLMarshaller anXMLMarshaller)
throws XMLMarshalException {
SDOXMLDocument xmlDocument =
(SDOXMLDocument) createDocument(rootObject, rootElementURI, rootElementName);
// Ask the SDOXMLDocument if we should include the XML declaration in the resulting XML
anXMLMarshaller.setFragment(!xmlDocument.isXMLDeclaration());
WriterRecord writerRecord;
if (anXMLMarshaller.isFormattedOutput()) {
writerRecord = new FormattedWriterRecord();
} else {
writerRecord = new WriterRecord();
}
writerRecord.setWriter(writer);
writerRecord.setMarshaller(anXMLMarshaller);
((SDOMarshalListener) anXMLMarshaller.getMarshalListener()).setMarshalledObject(rootObject);
((SDOMarshalListener) anXMLMarshaller.getMarshalListener())
.setMarshalledObjectRootQName(new QName(rootElementURI, rootElementName));
((SDOMarshalListener) anXMLMarshaller.getMarshalListener()).setRootMarshalRecord(writerRecord);
try {
anXMLMarshaller.marshal(xmlDocument, writerRecord);
} catch (XMLMarshalException xme) {
if (xme.getErrorCode() == XMLMarshalException.DESCRIPTOR_NOT_FOUND_IN_PROJECT) {
if (aHelperContext != ((SDOType) rootObject.getType()).getHelperContext()) {
throw SDOException.dataObjectNotFromHelperContext();
}
}
}
try {
writer.flush();
} catch (IOException ex) {
throw XMLMarshalException.marshalException(ex);
}
}
public Class getInstanceClass() {
if ((javaClass == null) && (javaClassName != null)) {
try {
SDOClassLoader loader = ((SDOXMLHelper) aHelperContext.getXMLHelper()).getLoader();
Class clazz = loader.getParent().loadClass(javaClassName);
if (isValidInstanceClass(clazz)) {
javaClass = clazz;
} else {
javaClass = getClass();
}
} catch (ClassNotFoundException e) {
javaClass = getClass();
} catch (SecurityException e) {
throw SDOException.classNotFound(e, getURI(), getName());
}
}
if (javaClass == getClass()) {
return null;
}
return javaClass;
}
/**
* INTERNAL: This method will return the key to be used to store/retrieve the delegates for a
* given application.
*
* <p>OC4J classLoader levels: 0 - APP.web (servlet/jsp) or APP.wrapper (ejb) 1 - APP.root (parent
* for helperContext) 2 - default.root 3 - system.root 4 - oc4j.10.1.3 (remote EJB) or
* org.eclipse.persistence:11.1.1.0.0 5 - api:1.4.0 6 - jre.extension:0.0.0 7 -
* jre.bootstrap:1.5.0_07 (with various J2SE versions)
*
* @return Application classloader for OC4J, application name for WebLogic, otherwise
* Thread.currentThread().getContextClassLoader()
*/
private static Object getDelegateMapKey(ClassLoader classLoader) {
String classLoaderName = classLoader.getClass().getName();
// Default to Thread.currentThread().getContextClassLoader()
Object delegateKey = classLoader;
// Delegates in OC4J server will be keyed on classloader
if (classLoaderName.startsWith(OC4J_CLASSLOADER_NAME)) {
// Check to see if we are running in a Servlet container or a local EJB container
if ((classLoader.getParent() != null) //
&& ((classLoader.toString().indexOf(SDOConstants.CLASSLOADER_WEB_FRAGMENT) != -1) //
|| (classLoader.toString().indexOf(SDOConstants.CLASSLOADER_EJB_FRAGMENT) != -1))) {
classLoader = classLoader.getParent();
}
delegateKey = classLoader;
// Delegates in WebLogic server will be keyed on application name
} else if (classLoaderName.contains(WLS_CLASSLOADER_NAME)) {
Object executeThread = getExecuteThread();
if (executeThread != null) {
try {
Method getMethod =
PrivilegedAccessHelper.getPublicMethod(
executeThread.getClass(),
WLS_APPLICATION_NAME_GET_METHOD_NAME,
PARAMETER_TYPES,
false);
delegateKey = PrivilegedAccessHelper.invokeMethod(getMethod, executeThread);
// ExecuteThread returns null
if (delegateKey == null) {
delegateKey = classLoader;
}
} catch (Exception e) {
throw SDOException.errorInvokingWLSMethodReflectively(
WLS_APPLICATION_NAME_GET_METHOD_NAME, WLS_EXECUTE_THREAD, e);
}
}
}
return delegateKey;
}
/**
* According to the requirement, correspondingly perform isset, unset or set function.
*
* @param frag one string fragment in the path
* @param path the String representation of path based access
* @param caller the DataObject that pass path information in
* @param value the value to be set as the target property's value
* @param lastSlashIndex the last index of '/' in the path string
* @param convertValue boolean used for set if we should convert the value
* @param _case an int value indicating what kind of operation to use: set, isset or unset.
* @return true if operation is isset and property's value is set, otherwise false.
*/
private boolean setIsSetUnSet(
String frag,
String path,
DataObject caller,
Object value,
int lastSlashIndex,
boolean convertValue,
int _case) {
int indexOfDot = frag.lastIndexOf('.');
int indexOfOpenBracket = frag.lastIndexOf('[');
int indexOfCloseBracket = frag.lastIndexOf(']');
int numInLastProperty =
getNumberInFrag(frag, indexOfDot, indexOfOpenBracket, indexOfCloseBracket);
String lastPropertyName =
getPropertyNameInFrag(
frag,
numInLastProperty,
indexOfDot,
indexOfOpenBracket); // get last property name on path for case 1
DataObject lastDataObject;
if (-1 < lastSlashIndex) {
Object lastObject =
get(path.substring(0, lastSlashIndex), caller); // get last dataobject on path
// If trying to access a list element from a null list, this object will be
// an instance of ListWrapper, not DataObject, but the error message is the same
// as if it was a null DataObject
if (lastObject == null || lastObject instanceof ListWrapper) {
throw SDOException.cannotPerformOperationOnProperty(lastPropertyName, path);
}
lastDataObject = (SDODataObject) lastObject;
} else {
lastDataObject = caller;
}
Property lastProperty =
lastDataObject.getInstanceProperty(lastPropertyName); // get property of this dataobject
switch (_case) {
case SET:
if (lastProperty == null) {
lastProperty =
((SDODataObject) lastDataObject).defineOpenContentProperty(lastPropertyName, value);
}
if (lastProperty != null) {
set(lastProperty, lastDataObject, numInLastProperty, value, convertValue);
}
return false;
case ISSET:
if (lastProperty == null) {
return false;
}
return isSet(lastProperty, lastDataObject);
case UNSET:
if (lastProperty == null) {
return false;
}
unSet(lastProperty, lastDataObject, numInLastProperty);
return false;
default:
return false;
}
}
/**
* INTERNAL: Make a copy of all settings on the original sequence onto the copy sequence while
* using a cross-reference doMap that relates the original DataObject key to the copy DataObject
* key. This function is used during deep copy and changeSummary copy.
*
* @param origSequence
* @param copySequence
* @param doMap
*/
private void replicateAndRereferenceSequenceCopyPrivate(
SDOSequence origSequence,
SDOSequence copySequence,
DataObject dataObject,
DataObject copy,
Map doMap,
SDOChangeSummary cs) {
if (cs != null && cs.isDeleted(dataObject)) {
origSequence = cs.getOldSequence(dataObject);
}
SDOProperty seqProperty = null;
try {
List settings = origSequence.getSettings();
for (int index = 0, size = origSequence.size(); index < size; index++) {
Setting nextSetting = (Setting) settings.get(index);
seqProperty = origSequence.getProperty(nextSetting);
if ((null == seqProperty) || seqProperty.getType().isDataType()) {
Setting copySetting = nextSetting.copy(copy);
copySequence.getSettings().add(copySetting);
copySequence.addValueToSettings(copySetting);
} else {
Object copySeqValue = null;
Object origSeqValue = origSequence.getValue(index);
if (cs != null) {
Object orig = cs.getReverseDeletedMap().get(origSeqValue);
if (orig != null) {
origSeqValue = orig;
}
}
if (origSeqValue instanceof XMLRoot) {
origSeqValue = ((XMLRoot) origSeqValue).getObject();
}
// lookup copy if not null, if null then the copySeqValue will be null in the reduced
// scope assignment above
if (null != origSeqValue) {
copySeqValue = doMap.get(origSeqValue);
} else {
// as a secondary verification to the assignment above - make sure the copy is null as
// well
copySeqValue =
null; // this assignment is however redundant in our reduced scope assignment above
}
// now we have the new value
Setting copySetting = nextSetting.copy(copy, copySeqValue);
copySequence.getSettings().add(copySetting);
copySequence.addValueToSettings(copySetting);
}
/**
* Move assignment inside the loop to minimize scope and to initialize the variable to null
* to handle the case where the original is null and no lookup is performed. Do not move the
* scope of this variable outside the for loop or we will end up with the previous
* iterations' value set for a complex object that is unset(null). see #6026714
*/
}
} catch (ClassCastException cce) { // catch any failure of a DataObject cast above
throw SDOException.foundSimpleValueForNonDataTypeProperty(seqProperty.getName());
}
}