You are viewing a plain text version of this content. The canonical link for it is here.
Posted to yoko-commits@incubator.apache.org by dm...@apache.org on 2006/08/21 14:35:17 UTC
svn commit: r433254 [1/2] - in /incubator/yoko/trunk/bindings/src:
main/java/org/apache/yoko/bindings/corba/
main/java/org/apache/yoko/bindings/corba/extensions/
main/java/org/apache/yoko/bindings/corba/types/
test/java/org/apache/yoko/bindings/corba/ ...
Author: dmiddlem
Date: Mon Aug 21 07:35:15 2006
New Revision: 433254
URL: http://svn.apache.org/viewvc?rev=433254&view=rev
Log:
Adding support for Union types in the binding. (YOKO-82)
(required refactoring of object handling so those changes are also included)
Added:
incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaExceptionHelper.java
incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/types/
incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/types/CorbaArrayHandler.java
incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/types/CorbaEnumHandler.java
incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/types/CorbaExceptionHandler.java
incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/types/CorbaFixedHandler.java
incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/types/CorbaObjectHandler.java
incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/types/CorbaPrimitiveHandler.java
incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/types/CorbaSequenceHandler.java
incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/types/CorbaStructHandler.java
incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/types/CorbaUnionHandler.java
incubator/yoko/trunk/bindings/src/test/java/org/apache/yoko/bindings/corba/types/
incubator/yoko/trunk/bindings/src/test/java/org/apache/yoko/bindings/corba/types/CorbaObjectHandlerTest.java
Removed:
incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaExceptionHandler.java
incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaObjectHolder.java
incubator/yoko/trunk/bindings/src/test/java/org/apache/yoko/bindings/corba/CorbaObjectHolderTest.java
Modified:
incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaBindingImpl.java
incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaClientBinding.java
incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaDSIServant.java
incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaMessage.java
incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaObjectReader.java
incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaObjectWriter.java
incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaStreamable.java
incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaUtils.java
incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/extensions/CorbaTypesExtensionHelper.java
incubator/yoko/trunk/bindings/src/test/java/org/apache/yoko/bindings/corba/CorbaBindingImplTest.java
incubator/yoko/trunk/bindings/src/test/java/org/apache/yoko/bindings/corba/CorbaMessageTest.java
incubator/yoko/trunk/bindings/src/test/java/org/apache/yoko/bindings/corba/CorbaObjectReaderTest.java
incubator/yoko/trunk/bindings/src/test/java/org/apache/yoko/bindings/corba/CorbaObjectWriterTest.java
incubator/yoko/trunk/bindings/src/test/java/org/apache/yoko/bindings/corba/CorbaStreamableTest.java
Modified: incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaBindingImpl.java
URL: http://svn.apache.org/viewvc/incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaBindingImpl.java?rev=433254&r1=433253&r2=433254&view=diff
==============================================================================
--- incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaBindingImpl.java (original)
+++ incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaBindingImpl.java Mon Aug 21 07:35:15 2006
@@ -51,18 +51,28 @@
import javax.xml.ws.handler.MessageContext;
import org.apache.schemas.yoko.bindings.corba.Array;
+import org.apache.schemas.yoko.bindings.corba.CaseType;
import org.apache.schemas.yoko.bindings.corba.Enum;
import org.apache.schemas.yoko.bindings.corba.Exception;
import org.apache.schemas.yoko.bindings.corba.Fixed;
import org.apache.schemas.yoko.bindings.corba.MemberType;
import org.apache.schemas.yoko.bindings.corba.ModeType;
-import org.apache.schemas.yoko.bindings.corba.NamedType;
import org.apache.schemas.yoko.bindings.corba.OperationType;
import org.apache.schemas.yoko.bindings.corba.ParamType;
import org.apache.schemas.yoko.bindings.corba.RaisesType;
import org.apache.schemas.yoko.bindings.corba.Sequence;
import org.apache.schemas.yoko.bindings.corba.Struct;
import org.apache.schemas.yoko.bindings.corba.Union;
+import org.apache.schemas.yoko.bindings.corba.Unionbranch;
+import org.apache.yoko.bindings.corba.types.CorbaArrayHandler;
+import org.apache.yoko.bindings.corba.types.CorbaEnumHandler;
+import org.apache.yoko.bindings.corba.types.CorbaExceptionHandler;
+import org.apache.yoko.bindings.corba.types.CorbaFixedHandler;
+import org.apache.yoko.bindings.corba.types.CorbaObjectHandler;
+import org.apache.yoko.bindings.corba.types.CorbaPrimitiveHandler;
+import org.apache.yoko.bindings.corba.types.CorbaSequenceHandler;
+import org.apache.yoko.bindings.corba.types.CorbaStructHandler;
+import org.apache.yoko.bindings.corba.types.CorbaUnionHandler;
import org.apache.yoko.wsdl.CorbaTypeImpl;
import org.objectweb.celtix.Bus;
@@ -116,44 +126,17 @@
Map wsdlImports = wsdlDef.getImports();
Collection importValues = wsdlImports.values();
for (Iterator importIterator = importValues.iterator(); importIterator.hasNext();) {
- List<Import> impList = (List<Import>)importIterator.next();
+ List impList = (List)importIterator.next();
for (Iterator it = impList.iterator(); it.hasNext();) {
Import imp = (Import)it.next();
Definition impDef = imp.getDefinition();
CorbaUtils.getTypeMapFromDefinition(typeMaps, impDef);
}
}
-
- // This has been moved to the CorbaUtils class but kept here for reference for
- // the time being.
-/*
- List extElements = wsdlDef.getExtensibilityElements();
-
- for (int i = 0; i < extElements.size(); ++i) {
- Object e = extElements.get(i);
- if (e instanceof TypeMappingType) {
- TypeMappingType tmType = (TypeMappingType) e;
- CorbaTypeMap map = new CorbaTypeMap(tmType.getTargetNamespace());
- map.setPrefix(wsdlDef.getPrefix(tmType.getTargetNamespace()));
- LOG.info("Found typemap in WSDL (Namespace: "
- + tmType.getTargetNamespace()
- + ", Prefix: "
- + wsdlDef.getPrefix(tmType.getTargetNamespace()));
-
- List types = tmType.getStructOrExceptionOrUnion();
- LOG.info("Found " + types.size() + " types defined in the typemap");
- for (int j = 0; j < types.size(); ++j) {
- CorbaTypeImpl corbaType = (CorbaTypeImpl)types.get(j);
- map.addType(corbaType.getName(), corbaType);
- LOG.info("Adding type " + corbaType.getName());
- }
- typeMaps.add(map);
- }
- }
-*/
} catch (java.lang.Exception ex) {
// Proceed without the type maps.
- LOG.info("Received exception [" + ex + "] while reading typemaps. Proceeding anyway.");
+ LOG.log(Level.INFO,
+ "Received exception [" + ex + "] while reading typemaps. Proceeding anyway.");
}
}
@@ -214,15 +197,16 @@
ByteArrayInputStream inStream = new ByteArrayInputStream(outStream.toByteArray());
XMLEventReader evtReader = inputFactory.createXMLEventReader(inStream);
- CorbaObjectHolder obj = readCorbaObject(evtReader,
- opElement.getReturn().getIdltype(),
- false);
+ CorbaObjectHandler obj = readObjectFromStax(evtReader,
+ opElement.getReturn().getIdltype(),
+ false);
CorbaStreamable streamable = new CorbaStreamable(obj, callback.getWebResultQName());
corbaCtx.getMessage().setStreamableReturn(streamable);
} else if (isInputMessage && callback.getWebResult() != null) {
QName retName = callback.getWebResultQName();
QName retIdlType = opElement.getReturn().getIdltype();
- CorbaObjectHolder obj = createCorbaObjectHolder(retIdlType, retName);
+ CorbaObjectHandler obj = CorbaUtils.createTypeHandler(orb, retName, retIdlType, typeMaps);
+ //CorbaObjectHandler obj = createCorbaObjectHandler(retIdlType, retName);
CorbaStreamable streamable = new CorbaStreamable(obj, retName);
corbaCtx.getMessage().setStreamableReturn(streamable);
}
@@ -254,10 +238,16 @@
XMLEventWriter evtWriter = outputFactory.createXMLEventWriter(outStream);
writer.write(partValue, elName, evtWriter);
+ byte[] temp = outStream.toByteArray();
+ for (int j = 0; j < temp.length; ++j) {
+ System.out.print((char)temp[j]);
+ }
+ System.out.println();
+
ByteArrayInputStream inStream = new ByteArrayInputStream(outStream.toByteArray());
XMLEventReader evtReader = inputFactory.createXMLEventReader(inStream);
QName idlType = paramTypes.get(i).getIdltype();
- CorbaObjectHolder obj;
+ CorbaObjectHandler obj;
boolean skipRead = false;
if (isServer) {
if (param.mode() == WebParam.Mode.IN) {
@@ -267,11 +257,9 @@
skipRead = true;
}
if (skipRead) {
- obj = createCorbaObjectHolder(idlType, elName);
+ obj = CorbaUtils.createTypeHandler(orb, elName, idlType, typeMaps);
} else {
- obj = readCorbaObject(evtReader,
- idlType,
- false);
+ obj = readObjectFromStax(evtReader, idlType, false);
}
CorbaStreamable streamable = new CorbaStreamable(obj, elName);
ModeType paramMode = paramTypes.get(i).getMode();
@@ -286,12 +274,6 @@
}
}
- private CorbaObjectHolder createCorbaObjectHolder(QName idlType, QName elName) {
- NamedType typeDef = CorbaUtils.getCorbaType(idlType, typeMaps);
- TypeCode tc = CorbaUtils.getTypeCode(orb, idlType, typeMaps);
- return new CorbaObjectHolder(elName, idlType, tc, typeDef);
- }
-
public void marshalFault(ObjectMessageContext objContext,
MessageContext mc,
DataBindingCallback callback) {
@@ -326,7 +308,7 @@
Method faultInfoMethod = except.getClass().getMethod("getFaultInfo");
Object faultInfo = faultInfoMethod.invoke(except);
WebFault wfAnnotation = except.getClass().getAnnotation(WebFault.class);
- QName elName = new QName(wfAnnotation.targetNamespace(), wfAnnotation.name());
+ QName elName = new QName(wfAnnotation.targetNamespace(), except.getClass().getSimpleName());
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
XMLEventWriter evtWriter = outputFactory.createXMLEventWriter(outStream);
@@ -343,13 +325,14 @@
}
}
if (exIdlType == null) {
- LOG.info("Could not find the exception in the raises list. Must be a system exception.");
+ LOG.log(Level.INFO,
+ "Could not find the exception in the raises list. Must be a system exception.");
// This could be a system exception?
} else {
- LOG.info("Found exception in the raises list. Marshalling.");
+ LOG.log(Level.INFO, "Found exception in the raises list. Marshalling.");
ByteArrayInputStream inStream = new ByteArrayInputStream(outStream.toByteArray());
XMLEventReader evtReader = inputFactory.createXMLEventReader(inStream);
- CorbaObjectHolder obj = readCorbaObject(evtReader, exIdlType, false);
+ CorbaObjectHandler obj = readObjectFromStax(evtReader, exIdlType, false);
CorbaStreamable streamable = new CorbaStreamable(obj, elName);
corbaCtx.getMessage().setStreamableException(streamable);
}
@@ -396,7 +379,7 @@
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
XMLEventWriter evtWriter = outputFactory.createXMLEventWriter(outStream);
- writeCorbaObject(streamables[i].getObject(), evtWriter, null);
+ writeObjectToStax(streamables[i].getObject(), evtWriter, XMLEventFactory.newInstance());
evtWriter.flush();
ByteArrayInputStream inStream = new ByteArrayInputStream(outStream.toByteArray());
@@ -417,7 +400,8 @@
if (!isInputMessage && callback.getWebResult() != null) {
ByteArrayOutputStream outStream = new ByteArrayOutputStream();
XMLEventWriter evtWriter = outputFactory.createXMLEventWriter(outStream);
- writeCorbaObject(corbaCtx.getMessage().getStreamableReturn().getObject(), evtWriter, null);
+ writeObjectToStax(corbaCtx.getMessage().getStreamableReturn().getObject(),
+ evtWriter, XMLEventFactory.newInstance());
evtWriter.flush();
ByteArrayInputStream inStream = new ByteArrayInputStream(outStream.toByteArray());
@@ -442,7 +426,7 @@
CorbaMessage message = corbaCtx.getMessage();
CorbaStreamable streamableEx = message.getStreamableException();
- CorbaObjectHolder exObject = streamableEx.getObject();
+ CorbaObjectHandler exObject = streamableEx.getObject();
String name = exObject.getName().getLocalPart();
Class exWrapperCls = null;
@@ -464,7 +448,7 @@
Class<?> exCls = faultInfoMethod.getReturnType();
Object yokoEx = exCls.newInstance();
- CorbaExceptionHandler.unmarshalCorbaException(exObject, yokoEx);
+ CorbaExceptionHelper.unmarshalCorbaException((CorbaExceptionHandler)exObject, yokoEx);
Constructor exWrapperCtr = exWrapperCls.getConstructor(String.class, exCls);
Object exWrapper = exWrapperCtr.newInstance("", yokoEx);
@@ -504,9 +488,9 @@
// TODO - provide implementation.
}
- public CorbaObjectHolder readCorbaObject(XMLEventReader reader, QName idlType, boolean isNested)
+ public CorbaObjectHandler readObjectFromStax(XMLEventReader reader, QName idlType, boolean isNested)
throws CorbaBindingException {
- CorbaObjectHolder obj = null;
+ CorbaObjectHandler obj = null;
// Find the first start element in the reader. This should be the beginning of our object
try {
if (!isNested) {
@@ -520,39 +504,37 @@
TypeCode tc = CorbaUtils.getTypeCode(orb, idlType, typeMaps);
if (CorbaUtils.isPrimitiveIdlType(idlType)) {
- obj = readPrimitiveCorbaObject(reader, idlType, tc);
+ LOG.log(Level.INFO, "Reading primitive type from XML reader");
+ obj = readPrimitiveFromStax(reader, idlType, tc);
} else {
- // TODO: Move the switch statement from the readComplex and make each complex type have its
- // own read, to get around the checkstyle rules
- //obj = readComplexCorbaObject(reader, idlType, tc);
-
switch(tc.kind().value()) {
case TCKind._tk_array:
- LOG.info("Reading array type from XML reader");
- obj = readArrayCorbaObject(reader, idlType, tc);
+ LOG.log(Level.INFO, "Reading array type from XML reader");
+ obj = readArrayFromStax(reader, idlType, tc);
break;
case TCKind._tk_enum:
- LOG.info("Reading enumeration type from XML reader");
- obj = readEnumCorbaObject(reader, idlType, tc);
+ LOG.log(Level.INFO, "Reading enumeration type from XML reader");
+ obj = readEnumFromStax(reader, idlType, tc);
break;
case TCKind._tk_except:
- LOG.info("Reading exception type from XML reader");
- obj = readExceptionCorbaObject(reader, idlType, tc);
+ LOG.log(Level.INFO, "Reading exception type from XML reader");
+ obj = readExceptionFromStax(reader, idlType, tc);
+ break;
+ case TCKind._tk_fixed:
+ LOG.log(Level.INFO, "Reading fixed type from XML reader");
+ obj = readFixedFromStax(reader, idlType, tc);
break;
case TCKind._tk_sequence:
- LOG.info("Reading sequence type from XML reader");
- obj = readSequenceCorbaObject(reader, idlType, tc);
+ LOG.log(Level.INFO, "Reading sequence type from XML reader");
+ obj = readSequenceFromStax(reader, idlType, tc);
break;
case TCKind._tk_struct:
- LOG.info("Reading struct type from XML reader");
- obj = readStructCorbaObject(reader, idlType, tc);
+ LOG.log(Level.INFO, "Reading struct type from XML reader");
+ obj = readStructFromStax(reader, idlType, tc);
break;
case TCKind._tk_union:
- LOG.info("Reading union type from XML reader");
- obj = readUnionCorbaObject(reader, idlType, tc);
- break;
- case TCKind._tk_fixed:
- obj = readFixedCorbaObject(reader, idlType, tc);
+ LOG.log(Level.INFO, "Reading union type from XML reader");
+ obj = readUnionFromStax(reader, idlType, tc);
break;
default:
throw new CorbaBindingException("Unsupported complex type");
@@ -561,230 +543,341 @@
return obj;
}
+
+ public void writeObjectToStax(CorbaObjectHandler obj, XMLEventWriter writer, XMLEventFactory factory) {
+ try {
+ StartElement startEl = factory.createStartElement(obj.getName(), null, null);
+ writer.add(startEl);
- public CorbaObjectHolder readPrimitiveCorbaObject(XMLEventReader reader, QName idlType, TypeCode tc)
+ TypeCode tc = obj.getTypeCode();
+ if (CorbaUtils.isPrimitiveIdlType(obj.getIdlType())) {
+ LOG.log(Level.INFO, "Writing primitive type to XML writer");
+ writePrimitiveToStax(obj, writer, factory);
+ } else {
+ switch(tc.kind().value()) {
+ case TCKind._tk_array:
+ LOG.log(Level.INFO, "Writing array type to XML writer");
+ writeArrayToStax(obj, writer, factory);
+ break;
+ case TCKind._tk_enum:
+ LOG.log(Level.INFO, "Writing enum type to XML writer");
+ writeEnumToStax(obj, writer, factory);
+ break;
+ case TCKind._tk_except:
+ LOG.log(Level.INFO, "Writing exception type to XML writer");
+ writeExceptionToStax(obj, writer, factory);
+ break;
+ case TCKind._tk_fixed:
+ LOG.log(Level.INFO, "Writing fixed type to XML writer");
+ writeFixedToStax(obj, writer, factory);
+ break;
+ case TCKind._tk_sequence:
+ LOG.log(Level.INFO, "Writing sequence type to XML writer");
+ writeSequenceToStax(obj, writer, factory);
+ break;
+ case TCKind._tk_struct:
+ LOG.log(Level.INFO, "Writing struct type to XML writer");
+ writeStructToStax(obj, writer, factory);
+ break;
+ case TCKind._tk_union:
+ LOG.log(Level.INFO, "Writing union type to XML writer");
+ writeUnionToStax(obj, writer, factory);
+ break;
+ default:
+ throw new CorbaBindingException("Unsupported complex type");
+ }
+ }
+
+ EndElement endEl = factory.createEndElement(obj.getName(), null);
+ writer.add(endEl);
+ } catch (XMLStreamException ex) {
+ LOG.log(Level.SEVERE, "STAX exception while writing to STAX event writer: " + ex.toString());
+ throw new CorbaBindingException("writeObjectToStax STAX exception", ex);
+ } catch (java.lang.Exception ex) {
+ LOG.log(Level.SEVERE, "Non-STAX exception while writing to STAX event writer: " + ex.toString());
+ throw new CorbaBindingException("writeObjectToStax exception", ex);
+ }
+ }
+
+ public CorbaObjectHandler readPrimitiveFromStax(XMLEventReader reader, QName idlType, TypeCode tc)
throws CorbaBindingException {
- CorbaObjectHolder obj = null;
+ CorbaPrimitiveHandler obj = null;
try {
- LOG.info("Reading primitive type from XML reader");
-
StartElement startEl = reader.nextEvent().asStartElement();
Characters charEl = reader.nextEvent().asCharacters();
- // need to consume an end element to prepare the reader for another event if this
- // primitive is part of a complex type.
reader.nextEvent().asEndElement();
- obj = new CorbaObjectHolder(startEl.getName(), idlType, tc, null);
- obj.setObjectValueFromData(charEl.getData());
+ obj = new CorbaPrimitiveHandler(startEl.getName(), idlType, tc, null);
+ obj.setValueFromData(charEl.getData());
} catch (java.lang.Exception ex) {
- LOG.severe("Error: Object not correctly defined in the XML reader");
+ LOG.log(Level.SEVERE, "Error: Object not correctly defined in the XML reader");
throw new CorbaBindingException("Invalid XML event read", ex);
}
return obj;
}
- public CorbaObjectHolder readArrayCorbaObject(XMLEventReader reader, QName idlType, TypeCode tc)
+ public void writePrimitiveToStax(CorbaObjectHandler obj, XMLEventWriter writer, XMLEventFactory factory)
+ throws XMLStreamException {
+ CorbaPrimitiveHandler primitiveHandler = (CorbaPrimitiveHandler)obj;
+ Characters charEvt = factory.createCharacters(primitiveHandler.getValueData());
+ writer.add(charEvt);
+ }
+
+ public CorbaObjectHandler readArrayFromStax(XMLEventReader reader, QName idlType, TypeCode tc)
throws CorbaBindingException {
- CorbaObjectHolder obj = null;
+ CorbaArrayHandler obj = null;
CorbaTypeImpl typeDefinition = CorbaUtils.getCorbaType(idlType, typeMaps);
try {
Array arrayType = (Array)typeDefinition;
StartElement arrayStartEl = reader.nextEvent().asStartElement();
- obj = new CorbaObjectHolder(arrayStartEl.getName(), idlType, tc, arrayType);
+ obj = new CorbaArrayHandler(arrayStartEl.getName(), idlType, tc, arrayType);
for (int i = 0; i < arrayType.getBound(); ++i) {
- CorbaObjectHolder member = readCorbaObject(reader, arrayType.getElemtype(), true);
- obj.addNestedObject(member);
+ CorbaObjectHandler element = readObjectFromStax(reader, arrayType.getElemtype(), true);
+ obj.addElement(element);
}
reader.nextEvent().asEndElement();
} catch (java.lang.Exception ex) {
- LOG.severe("Received exception while reading object of type " + idlType);
+ LOG.log(Level.SEVERE, "Received exception while reading object of type " + idlType);
throw new CorbaBindingException("Error while reading array corba type", ex);
}
return obj;
}
- public CorbaObjectHolder readEnumCorbaObject(XMLEventReader reader, QName idlType, TypeCode tc)
+ public void writeArrayToStax(CorbaObjectHandler obj, XMLEventWriter writer, XMLEventFactory factory)
+ throws XMLStreamException {
+ CorbaArrayHandler arrayHandler = (CorbaArrayHandler)obj;
+ List<CorbaObjectHandler> elements = arrayHandler.getElements();
+ for (Iterator<CorbaObjectHandler> elementsIter = elements.iterator(); elementsIter.hasNext();) {
+ writeObjectToStax(elementsIter.next(), writer, factory);
+ }
+ }
+
+ public CorbaObjectHandler readEnumFromStax(XMLEventReader reader, QName idlType, TypeCode tc)
throws CorbaBindingException {
- CorbaObjectHolder obj = null;
+ CorbaEnumHandler obj = null;
CorbaTypeImpl typeDefinition = CorbaUtils.getCorbaType(idlType, typeMaps);
try {
Enum enumType = (Enum)typeDefinition;
StartElement enumStartEl = reader.nextEvent().asStartElement();
- obj = new CorbaObjectHolder(enumStartEl.getName(), idlType, tc, enumType);
+ obj = new CorbaEnumHandler(enumStartEl.getName(), idlType, tc, enumType);
Characters enumCharEl = reader.nextEvent().asCharacters();
- obj.setObjectValueFromData(enumCharEl.getData());
+ obj.setValue(enumCharEl.getData());
reader.nextEvent().asEndElement();
} catch (java.lang.Exception ex) {
- LOG.severe("Received exception while reading object of type " + idlType);
+ LOG.log(Level.SEVERE, "Received exception while reading object of type " + idlType);
throw new CorbaBindingException("Error while reading enum corba type", ex);
}
return obj;
}
+
+ public void writeEnumToStax(CorbaObjectHandler obj, XMLEventWriter writer, XMLEventFactory factory)
+ throws XMLStreamException {
+ CorbaEnumHandler enumHandler = (CorbaEnumHandler)obj;
+ Characters charEvt = factory.createCharacters(enumHandler.getValue());
+ writer.add(charEvt);
+ }
- public CorbaObjectHolder readExceptionCorbaObject(XMLEventReader reader, QName idlType, TypeCode tc)
+ public CorbaObjectHandler readExceptionFromStax(XMLEventReader reader, QName idlType, TypeCode tc)
throws CorbaBindingException {
- CorbaObjectHolder obj = null;
+ CorbaExceptionHandler obj = null;
CorbaTypeImpl typeDefinition = CorbaUtils.getCorbaType(idlType, typeMaps);
try {
Exception exType = (Exception)typeDefinition;
StartElement exStartEl = reader.nextEvent().asStartElement();
- obj = new CorbaObjectHolder(exStartEl.getName(), idlType, tc, exType);
+ obj = new CorbaExceptionHandler(exStartEl.getName(), idlType, tc, exType);
List<MemberType> exMembers = exType.getMember();
for (int i = 0; i < exMembers.size(); ++i) {
- CorbaObjectHolder member = readCorbaObject(reader, exMembers.get(i).getIdltype(), true);
- obj.addNestedObject(member);
+ CorbaObjectHandler member = readObjectFromStax(reader, exMembers.get(i).getIdltype(), true);
+ obj.addMember(member);
}
reader.nextEvent().asEndElement();
} catch (java.lang.Exception ex) {
- LOG.severe("Received exception while reading object of type " + idlType);
+ LOG.log(Level.SEVERE, "Received exception while reading object of type " + idlType);
throw new CorbaBindingException("Error while reading exception corba type", ex);
}
return obj;
}
- public CorbaObjectHolder readSequenceCorbaObject(XMLEventReader reader, QName idlType, TypeCode tc)
+ public void writeExceptionToStax(CorbaObjectHandler obj, XMLEventWriter writer, XMLEventFactory factory)
+ throws XMLStreamException {
+ CorbaExceptionHandler exObj = (CorbaExceptionHandler)obj;
+ List<CorbaObjectHandler> elements = exObj.getMembers();
+ for (Iterator<CorbaObjectHandler> elementsIter = elements.iterator(); elementsIter.hasNext();) {
+ writeObjectToStax(elementsIter.next(), writer, factory);
+ }
+ }
+
+ public CorbaObjectHandler readSequenceFromStax(XMLEventReader reader, QName idlType, TypeCode tc)
throws CorbaBindingException {
- CorbaObjectHolder obj = null;
+ CorbaSequenceHandler obj = null;
CorbaTypeImpl typeDefinition = CorbaUtils.getCorbaType(idlType, typeMaps);
try {
Sequence seqType = (Sequence)typeDefinition;
StartElement seqStartEl = reader.nextEvent().asStartElement();
- obj = new CorbaObjectHolder(seqStartEl.getName(), idlType, tc, seqType);
+ obj = new CorbaSequenceHandler(seqStartEl.getName(), idlType, tc, seqType);
long bound = seqType.getBound();
if (bound == 0) {
- LOG.info("Unbounded sequence found");
+ LOG.log(Level.INFO, "Unbounded sequence found");
while (reader.peek().getEventType() == XMLStreamConstants.START_ELEMENT) {
- CorbaObjectHolder element = readCorbaObject(reader, seqType.getElemtype(), true);
- obj.addNestedObject(element);
+ CorbaObjectHandler element = readObjectFromStax(reader, seqType.getElemtype(), true);
+ obj.addElement(element);
}
} else {
- LOG.info("Bounded sequence found");
+ LOG.log(Level.INFO, "Bounded sequence found");
for (long i = 0; i < bound; ++i) {
- CorbaObjectHolder element = readCorbaObject(reader, seqType.getElemtype(), true);
- obj.addNestedObject(element);
+ CorbaObjectHandler element = readObjectFromStax(reader, seqType.getElemtype(), true);
+ obj.addElement(element);
}
}
reader.nextEvent().asEndElement();
} catch (java.lang.Exception ex) {
- LOG.severe("Received exception while reading object of type " + idlType);
+ LOG.log(Level.SEVERE, "Received exception while reading object of type " + idlType);
throw new CorbaBindingException("Error while reading sequence corba type", ex);
}
return obj;
}
- public CorbaObjectHolder readStructCorbaObject(XMLEventReader reader, QName idlType, TypeCode tc)
+ public void writeSequenceToStax(CorbaObjectHandler obj, XMLEventWriter writer, XMLEventFactory factory)
+ throws XMLStreamException {
+ CorbaSequenceHandler seqHandler = (CorbaSequenceHandler)obj;
+ List<CorbaObjectHandler> elements = seqHandler.getElements();
+ for (Iterator<CorbaObjectHandler> elementsIter = elements.iterator(); elementsIter.hasNext();) {
+ writeObjectToStax(elementsIter.next(), writer, factory);
+ }
+ }
+
+ public CorbaObjectHandler readStructFromStax(XMLEventReader reader, QName idlType, TypeCode tc)
throws CorbaBindingException {
- CorbaObjectHolder obj = null;
+ CorbaStructHandler obj = null;
CorbaTypeImpl typeDefinition = CorbaUtils.getCorbaType(idlType, typeMaps);
try {
Struct structType = (Struct)typeDefinition;
StartElement structStartEl = reader.nextEvent().asStartElement();
- obj = new CorbaObjectHolder(structStartEl.getName(), idlType, tc, structType);
+ obj = new CorbaStructHandler(structStartEl.getName(), idlType, tc, structType);
List<MemberType> structMembers = structType.getMember();
for (int i = 0; i < structMembers.size(); ++i) {
- CorbaObjectHolder member = readCorbaObject(reader,
- structMembers.get(i).getIdltype(),
- true);
- obj.addNestedObject(member);
+ CorbaObjectHandler member = readObjectFromStax(reader,
+ structMembers.get(i).getIdltype(),
+ true);
+ obj.addMember(member);
}
reader.nextEvent().asEndElement();
} catch (java.lang.Exception ex) {
- LOG.severe("Received exception while reading object of type " + idlType);
+ LOG.log(Level.SEVERE, "Received exception while reading object of type " + idlType);
throw new CorbaBindingException("Error while reading struct corba type", ex);
}
return obj;
}
- public CorbaObjectHolder readUnionCorbaObject(XMLEventReader reader, QName idlType, TypeCode tc)
+ public void writeStructToStax(CorbaObjectHandler obj, XMLEventWriter writer, XMLEventFactory factory)
+ throws XMLStreamException {
+ CorbaStructHandler structHandler = (CorbaStructHandler)obj;
+ List<CorbaObjectHandler> elements = structHandler.getMembers();
+ for (Iterator<CorbaObjectHandler> elementsIter = elements.iterator(); elementsIter.hasNext();) {
+ writeObjectToStax(elementsIter.next(), writer, factory);
+ }
+ }
+
+
+ public CorbaObjectHandler readUnionFromStax(XMLEventReader reader, QName idlType, TypeCode tc)
throws CorbaBindingException {
- CorbaObjectHolder obj = null;
+ CorbaUnionHandler obj = null;
CorbaTypeImpl typeDefinition = CorbaUtils.getCorbaType(idlType, typeMaps);
try {
Union unionType = (Union)typeDefinition;
StartElement unionStartEl = reader.nextEvent().asStartElement();
- obj = new CorbaObjectHolder(unionStartEl.getName(), idlType, tc, unionType);
-
- // TODO: Read the information about the union branches...
-
+ obj = new CorbaUnionHandler(unionStartEl.getName(), idlType, tc, unionType);
+
+ // Build the entire union with all branches, etc.
+ // Then read info from the XML Event Reader
+ StartElement branchElement = reader.peek().asStartElement();
+ String branchName = branchElement.getName().getLocalPart();
+ List<Unionbranch> branches = unionType.getUnionbranch();
+ for (Iterator<Unionbranch> branchesIter = branches.iterator(); branchesIter.hasNext();) {
+ Unionbranch branch = branchesIter.next();
+ CorbaObjectHandler branchObj = null;
+ if (branch.getName().equals(branchName)) {
+ branchObj = readObjectFromStax(reader, branch.getIdltype(), true);
+
+ // We also need to set the discriminator since this is the branch with the actual
+ // union value
+ CorbaObjectHandler discObj = CorbaUtils.createTypeHandler(orb,
+ new QName("discriminator"),
+ unionType.getDiscriminator(),
+ typeMaps);
+ List<CaseType> branchCases = branch.getCase();
+ String discValue = null;
+ if (branchCases.size() != 0) {
+ // This represents a union case. Set the discriminator based on the first
+ // label value associated with the branch (since we don't have this information)
+ // from the Stax representation of the Celtix object).
+ CaseType caseLabel = branchCases.get(0);
+ discValue = caseLabel.getLabel();
+ } else {
+ // This represents the default case. Since Celtix does not provide a discriminator
+ // value, we'll create one.
+ discValue = obj.createDefaultDiscriminatorLabel();
+ }
+ obj.setDiscriminator(discObj);
+ obj.setDiscriminatorValueFromData(discValue);
+ obj.setValue(branchName, branchObj);
+ } else {
+ // Create an object holder with no value
+ branchObj = CorbaUtils.createTypeHandler(orb, new QName(branch.getName()),
+ branch.getIdltype(), typeMaps);
+ }
+ obj.addCase(branchObj);
+ }
reader.nextEvent().asEndElement();
} catch (java.lang.Exception ex) {
- LOG.severe("Received exception while reading object of type " + idlType);
+ LOG.log(Level.SEVERE, "Received exception while reading object of type " + idlType);
throw new CorbaBindingException("Error while reading union corba type", ex);
}
return obj;
}
- public CorbaObjectHolder readFixedCorbaObject(XMLEventReader reader, QName idlType, TypeCode tc)
+ public void writeUnionToStax(CorbaObjectHandler obj, XMLEventWriter writer, XMLEventFactory factory)
+ throws XMLStreamException {
+ CorbaUnionHandler unionHandler = (CorbaUnionHandler)obj;
+ CorbaObjectHandler unionValue = unionHandler.getValue();
+ writeObjectToStax(unionValue, writer, factory);
+ }
+
+ public CorbaObjectHandler readFixedFromStax(XMLEventReader reader, QName idlType, TypeCode tc)
throws CorbaBindingException {
- CorbaObjectHolder obj = null;
+ CorbaFixedHandler obj = null;
CorbaTypeImpl typeDefinition = CorbaUtils.getCorbaType(idlType, typeMaps);
try {
Fixed fixedType = (Fixed)typeDefinition;
StartElement fixedStartEl = reader.nextEvent().asStartElement();
- obj = new CorbaObjectHolder(fixedStartEl.getName(), idlType, tc, fixedType);
+ obj = new CorbaFixedHandler(fixedStartEl.getName(), idlType, tc, fixedType);
Characters fixedCharEl = reader.nextEvent().asCharacters();
- obj.setObjectValueFromData(fixedCharEl.getData());
+ obj.setValueFromData(fixedCharEl.getData());
} catch (java.lang.Exception ex) {
- LOG.severe("Received exception while reading object of type " + idlType);
+ LOG.log(Level.SEVERE, "Received exception while reading object of type " + idlType);
throw new CorbaBindingException("Error while reading fixed corba type", ex);
}
return obj;
}
-
- public void writeCorbaObject(CorbaObjectHolder obj, XMLEventWriter writer, XMLEventFactory factory) {
- try {
- // If the factory is null, then this should be the beginning of the
- // object. Create an event factory
- // and the appropriate start and end document events. The end
- // document event will be used as a marker
- // later to indicate when we have found the end of the object data.
- // TODO: REVISIT. This is no longer needed since we don't apply
- // start and end document elements.
- if (factory == null) {
- factory = XMLEventFactory.newInstance();
- }
-
- StartElement startEl = factory.createStartElement(obj.getName(), null, null);
- writer.add(startEl);
-
- // There are a few special cases we have to watch out for. These can
- // not simply write character data to the event writer. Instead, they need
- // to structure the data in the form of additional XML events and
- // character data.
- NamedType objType = obj.getTypeDefinition();
- if (objType instanceof Struct
- || objType instanceof Exception
- || objType instanceof Union
- || objType instanceof Array
- || objType instanceof Sequence) {
- LOG.info("Writing a complex type : " + obj.getIdlType());
- List<CorbaObjectHolder> members = obj.getNestedObjects();
- for (int i = 0; i < members.size(); ++i) {
- writeCorbaObject(members.get(i), writer, factory);
- }
- } else {
- Characters charEvt = factory.createCharacters(obj.getValueData());
- writer.add(charEvt);
- }
-
- EndElement endEl = factory.createEndElement(obj.getName(), null);
- writer.add(endEl);
- } catch (java.lang.Exception ex) {
- throw new CorbaBindingException("writeCorbaObject exception", ex);
- }
+
+ public void writeFixedToStax(CorbaObjectHandler obj, XMLEventWriter writer, XMLEventFactory factory)
+ throws XMLStreamException {
+ CorbaFixedHandler fixedHandler = (CorbaFixedHandler)obj;
+ Characters charEvt = factory.createCharacters(fixedHandler.getValueData());
+ writer.add(charEvt);
}
-}
+}
\ No newline at end of file
Modified: incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaClientBinding.java
URL: http://svn.apache.org/viewvc/incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaClientBinding.java?rev=433254&r1=433253&r2=433254&view=diff
==============================================================================
--- incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaClientBinding.java (original)
+++ incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaClientBinding.java Mon Aug 21 07:35:15 2006
@@ -36,9 +36,10 @@
import org.apache.schemas.yoko.bindings.corba.AddressType;
import org.apache.schemas.yoko.bindings.corba.Exception;
import org.apache.schemas.yoko.bindings.corba.MemberType;
-import org.apache.schemas.yoko.bindings.corba.NamedType;
import org.apache.schemas.yoko.bindings.corba.OperationType;
import org.apache.schemas.yoko.bindings.corba.RaisesType;
+import org.apache.yoko.bindings.corba.types.CorbaExceptionHandler;
+import org.apache.yoko.bindings.corba.types.CorbaObjectHandler;
import org.objectweb.celtix.Bus;
import org.objectweb.celtix.bindings.AbstractBindingBase;
@@ -346,22 +347,16 @@
}
TypeCode tc = CorbaUtils.getTypeCode(orb, exIdlType, typeMaps);
- // TODO: What should the name of the object holder be?
- CorbaObjectHolder obj = new CorbaObjectHolder(new QName(ex.getName()), exIdlType, tc, ex);
+ // TODO: Revisit - What should the name of the object holder be?
+ CorbaExceptionHandler obj = new CorbaExceptionHandler(new QName(ex.getName()), exIdlType, tc, ex);
List<MemberType> exMembers = ex.getMember();
for (Iterator i = exMembers.iterator(); i.hasNext();) {
MemberType member = (MemberType)i.next();
QName memberName = new QName(member.getName());
QName memberType = member.getIdltype();
- TypeCode memberTC = CorbaUtils.getTypeCode(orb, memberType, typeMaps);
- NamedType memberTypeDef = null;
- if (!CorbaUtils.isPrimitiveIdlType(memberType)) {
- memberTypeDef = CorbaUtils.getCorbaType(memberType, typeMaps);
- }
-
- CorbaObjectHolder memberObj =
- new CorbaObjectHolder(memberName, memberType, memberTC, memberTypeDef);
- obj.addNestedObject(memberObj);
+ CorbaObjectHandler memberObj =
+ CorbaUtils.createTypeHandler(orb, memberName, memberType, typeMaps);
+ obj.addMember(memberObj);
}
CorbaStreamable exStreamable = new CorbaStreamable(obj, new QName("exception"));
Modified: incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaDSIServant.java
URL: http://svn.apache.org/viewvc/incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaDSIServant.java?rev=433254&r1=433253&r2=433254&view=diff
==============================================================================
--- incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaDSIServant.java (original)
+++ incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaDSIServant.java Mon Aug 21 07:35:15 2006
@@ -20,6 +20,7 @@
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
+import java.util.Iterator;
import java.util.List;
import javax.xml.namespace.QName;
@@ -32,12 +33,21 @@
//import org.apache.schemas.yoko.bindings.corba.Fixed;
import org.apache.schemas.yoko.bindings.corba.MemberType;
import org.apache.schemas.yoko.bindings.corba.ModeType;
-import org.apache.schemas.yoko.bindings.corba.NamedType;
import org.apache.schemas.yoko.bindings.corba.OperationType;
import org.apache.schemas.yoko.bindings.corba.ParamType;
import org.apache.schemas.yoko.bindings.corba.Sequence;
import org.apache.schemas.yoko.bindings.corba.Struct;
-// import org.apache.schemas.yoko.bindings.corba.Union;
+import org.apache.schemas.yoko.bindings.corba.Union;
+import org.apache.schemas.yoko.bindings.corba.Unionbranch;
+import org.apache.yoko.bindings.corba.types.CorbaArrayHandler;
+//import org.apache.yoko.bindings.corba.types.CorbaEnumHandler;
+import org.apache.yoko.bindings.corba.types.CorbaExceptionHandler;
+//import org.apache.yoko.bindings.corba.types.CorbaFixedHandler;
+import org.apache.yoko.bindings.corba.types.CorbaObjectHandler;
+//import org.apache.yoko.bindings.corba.types.CorbaPrimitiveHandler;
+import org.apache.yoko.bindings.corba.types.CorbaSequenceHandler;
+import org.apache.yoko.bindings.corba.types.CorbaStructHandler;
+import org.apache.yoko.bindings.corba.types.CorbaUnionHandler;
import org.objectweb.celtix.bindings.DataBindingCallback;
import org.objectweb.celtix.bindings.ServerBindingEndpointCallback;
@@ -51,7 +61,6 @@
import org.omg.CORBA.ORB;
import org.omg.CORBA.ServerRequest;
import org.omg.CORBA.TCKind;
-import org.omg.CORBA.TypeCode;
import org.omg.PortableServer.DynamicImplementation;
import org.omg.PortableServer.POA;
@@ -178,7 +187,9 @@
QName paramIdlType = pType.getIdltype();
ModeType paramMode = pType.getMode();
- CorbaObjectHolder obj = createCorbaObjectHolder(paramName, paramIdlType, typeMaps);
+ //CorbaObjectHolder obj = createCorbaObjectHolder(paramName, paramIdlType, typeMaps);
+ CorbaObjectHandler obj = initializeObjectHandler(paramName, paramIdlType, typeMaps);
+ //CorbaObjectHandler obj = CorbaUtils.createTypeHandler(orb, paramName, paramIdlType, typeMaps);
streamables[i] = new CorbaStreamable(obj, paramName);
if (paramMode.value().equals("in")) {
@@ -223,92 +234,96 @@
return interfaces.toArray(new String[interfaces.size()]);
}
- public CorbaObjectHolder createCorbaObjectHolder(QName name,
- QName idlType,
- List<CorbaTypeMap> typeMaps) {
- CorbaObjectHolder obj = null;
- TypeCode tc = CorbaUtils.getTypeCode(orb, idlType, typeMaps);
-
+ public CorbaObjectHandler initializeObjectHandler(QName name, QName idlType,
+ List<CorbaTypeMap> typeMaps) {
+ CorbaObjectHandler obj =
+ CorbaUtils.createTypeHandler(orb, name, idlType, typeMaps);
+
if (!CorbaUtils.isPrimitiveIdlType(idlType)) {
- NamedType typeDef = CorbaUtils.getCorbaType(idlType, typeMaps);
-
- if (typeDef == null) {
- throw new CorbaBindingException("Unable to locate type definition");
- }
-
- obj = new CorbaObjectHolder(name, idlType, tc, typeDef);
-
- TCKind typeKind = tc.kind();
- switch (typeKind.value()) {
+ switch (obj.getTypeCode().kind().value()) {
case TCKind._tk_array:
- Array arrayType = (Array)typeDef;
+ Array arrayType = (Array)obj.getType();
QName arrayElementType = arrayType.getElemtype();
for (int i = 0; i < arrayType.getBound(); ++i) {
// TODO: Revisit. Is this the correct namespace to use?
QName elementName = new QName(name.getNamespaceURI(), "item");
- CorbaObjectHolder elementObj =
- createCorbaObjectHolder(elementName, arrayElementType, typeMaps);
- obj.addNestedObject(elementObj);
+ CorbaObjectHandler elementObj =
+ initializeObjectHandler(elementName, arrayElementType, typeMaps);
+ ((CorbaArrayHandler)obj).addElement(elementObj);
}
break;
case TCKind._tk_except:
- Exception exceptType = (Exception)typeDef;
+ Exception exceptType = (Exception)obj.getType();
List<MemberType> exceptMembers = exceptType.getMember();
for (int i = 0; i < exceptMembers.size(); ++i) {
MemberType member = exceptMembers.get(i);
QName memberName = new QName(name.getNamespaceURI(), member.getName());
QName memberType = member.getIdltype();
- CorbaObjectHolder memberObj = createCorbaObjectHolder(memberName, memberType, typeMaps);
- obj.addNestedObject(memberObj);
+ CorbaObjectHandler memberObj =
+ initializeObjectHandler(memberName, memberType, typeMaps);
+ ((CorbaExceptionHandler)obj).addMember(memberObj);
}
break;
case TCKind._tk_sequence:
- Sequence seqType = (Sequence)typeDef;
+ Sequence seqType = (Sequence)obj.getType();
QName seqElementType = seqType.getElemtype();
if (seqType.getBound() == 0) {
// This is an unbounded sequence. Store a 'template' object that we can use to create
// new objects as needed
QName elementName = new QName(name.getNamespaceURI(), "item");
- CorbaObjectHolder elementObj =
- createCorbaObjectHolder(elementName, seqElementType, typeMaps);
- obj.setObjectValue(elementObj);
+ CorbaObjectHandler elementObj =
+ initializeObjectHandler(elementName, seqElementType, typeMaps);
+ ((CorbaSequenceHandler)obj).setTemplateElement(elementObj);
}
for (int i = 0; i < seqType.getBound(); ++i) {
// TODO: Revisit. Is this the correct namespace to use?
QName elementName = new QName(name.getNamespaceURI(), "item");
- CorbaObjectHolder elementObj =
- createCorbaObjectHolder(elementName, seqElementType, typeMaps);
- obj.addNestedObject(elementObj);
+ CorbaObjectHandler elementObj =
+ initializeObjectHandler(elementName, seqElementType, typeMaps);
+ ((CorbaSequenceHandler)obj).addElement(elementObj);
}
break;
case TCKind._tk_struct:
- Struct structType = (Struct)typeDef;
+ Struct structType = (Struct)obj.getType();
List<MemberType> structMembers = structType.getMember();
for (int i = 0; i < structMembers.size(); ++i) {
MemberType member = structMembers.get(i);
QName memberName = new QName(name.getNamespaceURI(), member.getName());
QName memberType = member.getIdltype();
- CorbaObjectHolder memberObj = createCorbaObjectHolder(memberName, memberType, typeMaps);
- obj.addNestedObject(memberObj);
+ CorbaObjectHandler memberObj =
+ initializeObjectHandler(memberName, memberType, typeMaps);
+ ((CorbaStructHandler)obj).addMember(memberObj);
}
break;
case TCKind._tk_union:
- // Union unionType = (Union)typeDef;
- // TODO: provide implementation
+ Union unionType = (Union)obj.getType();
+ // First handle the discriminator
+ CorbaObjectHandler discObj = initializeObjectHandler(new QName("discriminator"),
+ unionType.getDiscriminator(),
+ typeMaps);
+ ((CorbaUnionHandler)obj).setDiscriminator(discObj);
+
+ // Now handle all of the branches
+ List<Unionbranch> unionBranches = unionType.getUnionbranch();
+ for (Iterator<Unionbranch> iter = unionBranches.iterator(); iter.hasNext();) {
+ Unionbranch branch = iter.next();
+ QName branchName = new QName(name.getNamespaceURI(), branch.getName());
+ QName branchIdlType = branch.getIdltype();
+ CorbaObjectHandler branchObj =
+ initializeObjectHandler(branchName, branchIdlType, typeMaps);
+ ((CorbaUnionHandler)obj).addCase(branchObj);
+ }
break;
- //case TCKind._tk_fixed:
- // Fixed fixedType = (Fixed)typeDef;
+// case TCKind._tk_fixed:
+// // The initial construction of the Object should be sufficient.
+// break;
default:
// TODO: Should we raise an exception or log?
}
-
- } else {
- obj = new CorbaObjectHolder(name, idlType, tc, null);
}
-
return obj;
}
Added: incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaExceptionHelper.java
URL: http://svn.apache.org/viewvc/incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaExceptionHelper.java?rev=433254&view=auto
==============================================================================
--- incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaExceptionHelper.java (added)
+++ incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaExceptionHelper.java Mon Aug 21 07:35:15 2006
@@ -0,0 +1,148 @@
+package org.apache.yoko.bindings.corba;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.math.BigInteger;
+import java.util.Iterator;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+//import org.apache.schemas.yoko.bindings.corba.Exception;
+import org.apache.yoko.bindings.corba.types.CorbaExceptionHandler;
+import org.apache.yoko.bindings.corba.types.CorbaFixedHandler;
+import org.apache.yoko.bindings.corba.types.CorbaObjectHandler;
+import org.apache.yoko.bindings.corba.types.CorbaPrimitiveHandler;
+
+import org.objectweb.celtix.common.logging.LogUtils;
+
+import org.omg.CORBA.TCKind;
+
+// This class exists to allow for the conversion of a Corba UserException into an
+// exception that a Yoko client/server can use. The big issue with this conversion
+// occurs when going from a Corba UserException to a Yoko exception. Currently, the
+// data readers/writers that we use to marshal and unmarshal regular data will
+// not support the marshalling/unmarshalling of exceptions when we use XML Events.
+// This class allows us to unmarshal the data correctly into an appropriate Yoko
+// exception object.
+
+public class CorbaExceptionHelper {
+
+ private static final Logger LOG = LogUtils.getL7dLogger(CorbaExceptionHelper.class);
+
+ public static void unmarshalCorbaException(CorbaExceptionHandler corbaEx, Object yokoEx)
+ throws CorbaBindingException {
+ try {
+ LOG.log(Level.INFO, "Preparing to unmarshal a CORBA exception");
+
+// Exception ex = (Exception)corbaEx.getType();
+ List<CorbaObjectHandler> exMembers = corbaEx.getMembers();
+
+ for (Iterator i = exMembers.iterator(); i.hasNext();) {
+ CorbaObjectHandler member = (CorbaObjectHandler)i.next();
+ String memberName = member.getName().getLocalPart();
+ LOG.log(Level.INFO, "Setting field " + memberName);
+
+ Field field = yokoEx.getClass().getDeclaredField(memberName);
+ Method setMethod = getFieldSetMethod(memberName, yokoEx.getClass(), field);
+ setExceptionFieldValue(member, field, setMethod, yokoEx);
+ }
+ } catch (java.lang.Exception ex) {
+ LOG.log(Level.SEVERE, "Error during CORBA unmarshal exception: " + ex.getMessage());
+ throw new CorbaBindingException("Unable to unmarshal CORBA exception: " + ex.getMessage(), ex);
+ }
+ }
+
+ private static void setExceptionFieldValue(CorbaObjectHandler obj, Field field,
+ Method setMethod, Object objInstance)
+ throws CorbaBindingException {
+ // There are special cases where the wrapper for the primitive type doesn't match the
+ // type used by the wsdl2java tool. Make accomodations for these. Otherwise, just
+ // invoke the setMethod with the object stored in the holder. REVISIT: we may want
+ // to change the way the binding handles the data internally to make this step
+ // unnecessary.
+ try {
+ switch (obj.getTypeCode().kind().value()) {
+ case TCKind._tk_boolean:
+ Object boolValue = ((CorbaPrimitiveHandler)obj).getValue();
+ setMethod.invoke(objInstance, boolValue);
+ break;
+ case TCKind._tk_char:
+ byte charValue = (byte)((Character)((CorbaPrimitiveHandler)obj).getValue()).charValue();
+ setMethod.invoke(objInstance, Byte.valueOf(charValue));
+ break;
+ case TCKind._tk_wchar:
+ String wcharValue = ((Character)((CorbaPrimitiveHandler)obj).getValue()).toString();
+ setMethod.invoke(objInstance, wcharValue);
+ break;
+ case TCKind._tk_octet:
+ short octetValue = Short.valueOf((Byte)((CorbaPrimitiveHandler)obj).getValue()).shortValue();
+ setMethod.invoke(objInstance, octetValue);
+ //setMethod.invoke(objInstance, Short.valueOf((Byte)obj.getValue()).shortValue());
+ break;
+ case TCKind._tk_short:
+ case TCKind._tk_ushort:
+ Object shortValue = ((CorbaPrimitiveHandler)obj).getValue();
+ setMethod.invoke(objInstance, shortValue);
+ break;
+ case TCKind._tk_long:
+ int longValue = ((Long)((CorbaPrimitiveHandler)obj).getValue()).intValue();
+ setMethod.invoke(objInstance, Integer.valueOf(longValue));
+ break;
+ case TCKind._tk_ulong:
+ case TCKind._tk_longlong:
+ long ulongValue = ((BigInteger)((CorbaPrimitiveHandler)obj).getValue()).longValue();
+ setMethod.invoke(objInstance, Long.valueOf(ulongValue));
+ break;
+ case TCKind._tk_ulonglong:
+ Object ulonglongValue = ((CorbaPrimitiveHandler)obj).getValue();
+ setMethod.invoke(objInstance, ulonglongValue);
+ break;
+ case TCKind._tk_float:
+ Object floatValue = ((CorbaPrimitiveHandler)obj).getValue();
+ setMethod.invoke(objInstance, floatValue);
+ break;
+ case TCKind._tk_double:
+ Object doubleValue = ((CorbaPrimitiveHandler)obj).getValue();
+ setMethod.invoke(objInstance, doubleValue);
+ break;
+ case TCKind._tk_string:
+ case TCKind._tk_wstring:
+ Object stringValue = ((CorbaPrimitiveHandler)obj).getValue();
+ setMethod.invoke(objInstance, stringValue);
+ break;
+ case TCKind._tk_fixed:
+ CorbaFixedHandler fixedHandler = (CorbaFixedHandler)obj;
+ setMethod.invoke(objInstance, fixedHandler.getValue());
+ break;
+ //case TCKind._tk_enum:
+ default:
+ setMethod.invoke(objInstance, createExceptionField(obj, field.getClass()));
+ break;
+ }
+ } catch (java.lang.Exception ex) {
+ throw new CorbaBindingException("Unable to set the exception field "
+ + obj.getName().getLocalPart(), ex);
+ }
+ }
+
+ private static Object createExceptionField(CorbaObjectHandler obj, Class cls)
+ throws CorbaBindingException {
+ // This method will allow for the creation of nested complex types within the exception.
+ // TODO: Provide implementation
+ throw new CorbaBindingException("Non-primitive exception fields not implemented yet.");
+ }
+
+ private static Method getFieldSetMethod(String fieldName, Class cls, Field field)
+ throws CorbaBindingException {
+ Method setMethod = null;
+ String methodName = "set" + (char)(fieldName.charAt(0) - 'a' + 'A') + fieldName.substring(1);
+ try {
+ setMethod = cls.getMethod(methodName, field.getType());
+ } catch (java.lang.Exception ex) {
+ throw new CorbaBindingException("Unable to locate the 'set' method " + methodName, ex);
+ }
+
+ return setMethod;
+ }
+}
Modified: incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaMessage.java
URL: http://svn.apache.org/viewvc/incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaMessage.java?rev=433254&r1=433253&r2=433254&view=diff
==============================================================================
--- incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaMessage.java (original)
+++ incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaMessage.java Mon Aug 21 07:35:15 2006
@@ -21,6 +21,8 @@
import java.util.ArrayList;
import java.util.List;
+import org.apache.yoko.bindings.corba.types.CorbaObjectHandler;
+
public class CorbaMessage {
private String operation;
@@ -83,7 +85,7 @@
}
}
- public void setStreamableArgumentValue(CorbaObjectHolder data, int idx) {
+ public void setStreamableArgumentValue(CorbaObjectHandler data, int idx) {
if (idx >= arguments.size()) {
throw new CorbaBindingException("setStreamableArgumentValue: Index out of range");
}
@@ -91,7 +93,7 @@
arguments.get(idx).setObject(data);
}
- public void setStreamableArgumentValues(CorbaObjectHolder[] data) {
+ public void setStreamableArgumentValues(CorbaObjectHandler[] data) {
for (int i = 0; i < data.length; ++i) {
arguments.get(i).setObject(data[i]);
}
@@ -101,7 +103,7 @@
returnParam = data;
}
- public void setStreamableReturnValue(CorbaObjectHolder data) {
+ public void setStreamableReturnValue(CorbaObjectHandler data) {
// TODO: Handle case of the return parameter has not yet been initialized.
returnParam.setObject(data);
}
@@ -110,7 +112,7 @@
except = ex;
}
- public void setStreamableExceptionValue(CorbaObjectHolder exData) {
+ public void setStreamableExceptionValue(CorbaObjectHandler exData) {
// TODO: Handle case of the return parameter has not yet been initialized.
except.setObject(exData);
}
Modified: incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaObjectReader.java
URL: http://svn.apache.org/viewvc/incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaObjectReader.java?rev=433254&r1=433253&r2=433254&view=diff
==============================================================================
--- incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaObjectReader.java (original)
+++ incubator/yoko/trunk/bindings/src/main/java/org/apache/yoko/bindings/corba/CorbaObjectReader.java Mon Aug 21 07:35:15 2006
@@ -19,13 +19,28 @@
package org.apache.yoko.bindings.corba;
import java.math.BigInteger;
+import java.util.Iterator;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
+//import javax.xml.namespace.QName;
+
+import org.apache.schemas.yoko.bindings.corba.CaseType;
import org.apache.schemas.yoko.bindings.corba.Enum;
import org.apache.schemas.yoko.bindings.corba.Enumerator;
import org.apache.schemas.yoko.bindings.corba.Fixed;
+import org.apache.schemas.yoko.bindings.corba.Union;
+import org.apache.schemas.yoko.bindings.corba.Unionbranch;
+import org.apache.yoko.bindings.corba.types.CorbaArrayHandler;
+import org.apache.yoko.bindings.corba.types.CorbaEnumHandler;
+import org.apache.yoko.bindings.corba.types.CorbaExceptionHandler;
+import org.apache.yoko.bindings.corba.types.CorbaFixedHandler;
+import org.apache.yoko.bindings.corba.types.CorbaObjectHandler;
+import org.apache.yoko.bindings.corba.types.CorbaPrimitiveHandler;
+import org.apache.yoko.bindings.corba.types.CorbaSequenceHandler;
+import org.apache.yoko.bindings.corba.types.CorbaStructHandler;
+import org.apache.yoko.bindings.corba.types.CorbaUnionHandler;
import org.objectweb.celtix.common.logging.LogUtils;
@@ -42,55 +57,51 @@
stream = inStream;
}
- public void read(CorbaObjectHolder obj) throws CorbaBindingException {
- switch (obj.getType().kind().value()) {
+ public void read(CorbaObjectHandler obj) throws CorbaBindingException {
+ switch (obj.getTypeCode().kind().value()) {
case TCKind._tk_boolean:
- obj.setObjectValue(this.readBoolean());
+ ((CorbaPrimitiveHandler)obj).setValue(this.readBoolean());
break;
case TCKind._tk_char:
Character charValue = this.readChar();
-// byte charByteValue = (byte) charValue.charValue();
-// obj.setObjectValue(new Byte(charByteValue));
- obj.setObjectValue(charValue);
+ ((CorbaPrimitiveHandler)obj).setValue(charValue);
break;
case TCKind._tk_wchar:
- obj.setObjectValue(this.readWChar());
+ ((CorbaPrimitiveHandler)obj).setValue(this.readWChar());
break;
case TCKind._tk_octet:
Byte octetValue = this.readOctet();
-// short octetShortValue = octetValue.shortValue();
-// obj.setObjectValue(new Short(octetShortValue));
- obj.setObjectValue(octetValue);
+ ((CorbaPrimitiveHandler)obj).setValue(octetValue);
break;
case TCKind._tk_short:
- obj.setObjectValue(this.readShort());
+ ((CorbaPrimitiveHandler)obj).setValue(this.readShort());
break;
case TCKind._tk_ushort:
- obj.setObjectValue(this.readUShort());
+ ((CorbaPrimitiveHandler)obj).setValue(this.readUShort());
break;
case TCKind._tk_long:
- obj.setObjectValue(this.readLong());
+ ((CorbaPrimitiveHandler)obj).setValue(this.readLong());
break;
case TCKind._tk_ulong:
- obj.setObjectValue(this.readULong());
+ ((CorbaPrimitiveHandler)obj).setValue(this.readULong());
break;
case TCKind._tk_longlong:
- obj.setObjectValue(this.readLongLong());
+ ((CorbaPrimitiveHandler)obj).setValue(this.readLongLong());
break;
case TCKind._tk_ulonglong:
- obj.setObjectValue(this.readULongLong());
+ ((CorbaPrimitiveHandler)obj).setValue(this.readULongLong());
break;
case TCKind._tk_float:
- obj.setObjectValue(this.readFloat());
+ ((CorbaPrimitiveHandler)obj).setValue(this.readFloat());
break;
case TCKind._tk_double:
- obj.setObjectValue(this.readDouble());
+ ((CorbaPrimitiveHandler)obj).setValue(this.readDouble());
break;
case TCKind._tk_string:
- obj.setObjectValue(this.readString());
+ ((CorbaPrimitiveHandler)obj).setValue(this.readString());
break;
case TCKind._tk_wstring:
- obj.setObjectValue(this.readWString());
+ ((CorbaPrimitiveHandler)obj).setValue(this.readWString());
break;
// Now for the complex types
@@ -112,6 +123,9 @@
case TCKind._tk_fixed:
this.readFixed(obj);
break;
+ case TCKind._tk_union:
+ this.readUnion(obj);
+ break;
default:
// TODO: Provide Implementation. Do we throw an exception.
}
@@ -278,93 +292,120 @@
}
// -- complex types --
- public void readConstant(CorbaObjectHolder obj) throws CorbaBindingException {
- // TODO: provide implementation - does this one make sense for the
- // binding
- throw new CorbaBindingException("CorbaObjectReader: readConstant not yet implemented");
- }
-
- public void readEnum(CorbaObjectHolder obj) throws CorbaBindingException {
+ public void readEnum(CorbaObjectHandler obj) throws CorbaBindingException {
int enumIndex = stream.read_long();
- Enum enumType = (Enum) obj.getTypeDefinition();
+ Enum enumType = (Enum) obj.getType();
List<Enumerator> enumerators = enumType.getEnumerator();
- obj.setObjectValueFromData(enumerators.get(enumIndex).getValue());
- }
-
- public String readEnumLabel() throws CorbaBindingException {
- // TODO: provide implementation
- throw new CorbaBindingException("CorbaObjectReader: readEnumLabel not yet implemented");
+ CorbaEnumHandler enumObj = (CorbaEnumHandler)obj;
+ enumObj.setValue(enumerators.get(enumIndex).getValue());
}
- public void readStruct(CorbaObjectHolder obj) throws CorbaBindingException {
- List<CorbaObjectHolder> structMembers = obj.getNestedObjects();
+ public void readStruct(CorbaObjectHandler obj) throws CorbaBindingException {
+ CorbaStructHandler structObj = (CorbaStructHandler)obj;
+ List<CorbaObjectHandler> structMembers = structObj.getMembers();
for (int i = 0; i < structMembers.size(); ++i) {
this.read(structMembers.get(i));
}
}
- public void readException(CorbaObjectHolder obj) throws CorbaBindingException {
- // Exceptions are very similar to a struct, except that they also have a repository ID which gets
- // propgated as a string. This will be stored in the object holders value field
- List<CorbaObjectHolder> exceptElements = obj.getNestedObjects();
+ public void readException(CorbaObjectHandler obj) throws CorbaBindingException {
+ CorbaExceptionHandler exceptObj = (CorbaExceptionHandler)obj;
+ List<CorbaObjectHandler> exceptElements = exceptObj.getMembers();
String exceptId = stream.read_string();
- obj.setObjectValueFromData(exceptId);
+ exceptObj.setId(exceptId);
for (int i = 0; i < exceptElements.size(); ++i) {
this.read(exceptElements.get(i));
}
}
- public void readFixed(CorbaObjectHolder obj) throws CorbaBindingException {
- // TODO: Update so we don't have to use toString here.
- Fixed fixedType = (Fixed)obj.getTypeDefinition();
+ public void readFixed(CorbaObjectHandler obj) throws CorbaBindingException {
+ Fixed fixedType = (Fixed)obj.getType();
long scale = fixedType.getScale();
java.math.BigDecimal fixedValue = stream.read_fixed().movePointLeft((int)scale);
- obj.setObjectValueFromData(fixedValue.toString());
- }
-
- public void readUnion(CorbaObjectHolder obj) throws CorbaBindingException {
- // TODO: provide implementation
- throw new CorbaBindingException("CorbaObjectReader: readUnion not yet implemented");
+ CorbaFixedHandler fixedObj = (CorbaFixedHandler)obj;
+ fixedObj.setValue(fixedValue);
}
- public void readTypeDef(CorbaObjectHolder obj) throws CorbaBindingException {
- // TODO: provide implementation - does this one make sense for the
- // binding
- throw new CorbaBindingException("CorbaObjectReader: readTypeDef not yet implemented");
+ public void readUnion(CorbaObjectHandler obj) throws CorbaBindingException {
+ CorbaUnionHandler unionHandler = (CorbaUnionHandler)obj;
+ CorbaObjectHandler discriminator = unionHandler.getDiscriminator();
+
+ this.read(discriminator);
+
+ String discLabel = null;
+ if (discriminator.getTypeCodeKind().value() == TCKind._tk_enum) {
+ discLabel = ((CorbaEnumHandler)discriminator).getValue();
+ } else {
+ discLabel = ((CorbaPrimitiveHandler)discriminator).getValueData();
+ }
+
+ // Now find the label in the union to get the right case
+ Union unionType = (Union)unionHandler.getType();
+ List<Unionbranch> branches = unionType.getUnionbranch();
+ Unionbranch defaultBranch = null;
+ boolean caseFound = false;
+ for (Iterator<Unionbranch> branchIter = branches.iterator(); branchIter.hasNext();) {
+ Unionbranch branch = branchIter.next();
+ if (branch.isSetDefault() && branch.isDefault()) {
+ defaultBranch = branch;
+ }
+ List<CaseType> cases = branch.getCase();
+ for (Iterator<CaseType> caseIter = cases.iterator(); caseIter.hasNext();) {
+ CaseType c = caseIter.next();
+ if (c.getLabel().equals(discLabel)) {
+ CorbaObjectHandler branchObj = unionHandler.getBranchByName(branch.getName());
+ this.read(branchObj);
+ unionHandler.setValue(branch.getName(), branchObj);
+ caseFound = true;
+ break;
+ }
+ }
+ if (caseFound) {
+ break;
+ }
+ }
+
+ // If we never find a case that matches the value of the discriminiator, then we must have
+ // found the default case.
+ if (!caseFound && defaultBranch != null) {
+ CorbaObjectHandler branchObj = unionHandler.getBranchByName(defaultBranch.getName());
+ this.read(branchObj);
+ unionHandler.setValue(defaultBranch.getName(), branchObj);
+ }
+
+// throw new CorbaBindingException("CorbaObjectReader: readUnion not yet implemented");
}
- public void readArray(CorbaObjectHolder obj) throws CorbaBindingException {
- List<CorbaObjectHolder> arrayElements = obj.getNestedObjects();
+ public void readArray(CorbaObjectHandler obj) throws CorbaBindingException {
+ CorbaArrayHandler arrayObj = (CorbaArrayHandler)obj;
+ List<CorbaObjectHandler> arrayElements = arrayObj.getElements();
for (int i = 0; i < arrayElements.size(); ++i) {
this.read(arrayElements.get(i));
}
}
- public void readSequence(CorbaObjectHolder obj)
- throws CorbaBindingException {
- List<CorbaObjectHolder> seqElements = obj.getNestedObjects();
+ public void readSequence(CorbaObjectHandler obj) throws CorbaBindingException {
+ CorbaSequenceHandler sequenceObj = (CorbaSequenceHandler)obj;
+ List<CorbaObjectHandler> seqElements = sequenceObj.getElements();
int length = stream.read_ulong();
if (seqElements.size() == 0) {
- // No predefined elements means an unbounded sequence. We need to use the object stored in the
- // ObjectHolders value as a template to build a new nested object. We have to do it this way
- // because we have no way of knowing in advance how big the sequence is going to be when we
- // pre-build the object.
- CorbaObjectHolder template = (CorbaObjectHolder)obj.getValue();
+ // No predefined elements means an unbounded sequence. Use the template element
+ // to construct each object that is in the input stream.
+ CorbaObjectHandler template = sequenceObj.getTemplateElement();
for (int i = 0; i < length; ++i) {
- CorbaObjectHolder nestedObj = new CorbaObjectHolder(template.getName(),
- template.getIdlType(),
- template.getType(),
- template.getTypeDefinition());
- this.read(nestedObj);
- obj.addNestedObject(nestedObj);
+ // TODO: May need to do something better here since the copy will make changes
+ // to both elements
+ CorbaObjectHandler seqElement = template;
+ this.read(seqElement);
+ sequenceObj.addElement(seqElement);
}
} else {
@@ -373,10 +414,5 @@
this.read(seqElements.get(i));
}
}
- }
-
- public boolean isEnum() {
- // TODO: Provide complete implementation
- return false;
}
}