You are viewing a plain text version of this content. The canonical link for it is here.
Posted to java-dev@axis.apache.org by di...@apache.org on 2005/11/07 18:37:08 UTC
svn commit: r331554 [2/2] - in /webservices/axis/trunk/c: include/axis/
include/axis/client/ src/common/ src/soap/
src/wsdl/org/apache/axis/wsdl/wsdl2ws/c/
src/wsdl/org/apache/axis/wsdl/wsdl2ws/c/literal/
src/wsdl/org/apache/axis/wsdl/wsdl2ws/cpp/ src/...
Modified: webservices/axis/trunk/c/src/common/AxisUserAPI.cpp
URL: http://svn.apache.org/viewcvs/webservices/axis/trunk/c/src/common/AxisUserAPI.cpp?rev=331554&r1=331553&r2=331554&view=diff
==============================================================================
--- webservices/axis/trunk/c/src/common/AxisUserAPI.cpp (original)
+++ webservices/axis/trunk/c/src/common/AxisUserAPI.cpp Mon Nov 7 09:36:47 2005
@@ -18,6 +18,7 @@
*/
#include <axis/AxisUserAPI.hpp>
+#include <axis/AxisUserAPIArrays.hpp>
AXIS_CPP_NAMESPACE_START
@@ -57,6 +58,1664 @@
}
AnyType::~AnyType() {
+}
+
+Axis_Array::Axis_Array()
+{
+ m_Array = NULL;
+ m_Size = 0;
+ m_Type = XSD_UNKNOWN;
+}
+
+Axis_Array::Axis_Array(Axis_Array & original)
+{
+ m_Array = NULL;
+ m_Size = 0;
+ m_Type = XSD_UNKNOWN;
+ clone(original);
+}
+
+void Axis_Array::clone(Axis_Array & original)
+{
+ set(original.m_Array, original.m_Size, original.m_Type);
+}
+
+void Axis_Array::set(void* array, int size, XSDTYPE type)
+{
+ clear();
+ m_Size = size;
+ m_Type = type;
+
+ if (size == 0)
+ {
+ m_Array = NULL;
+ }
+ else
+ {
+ m_Array = new void*[m_Size]();
+
+ for (int count = 0 ; count < m_Size ; count++)
+ {
+ if (((void**) array)[count] == NULL)
+ {
+ ((void**) m_Array)[count] = NULL;
+ }
+ else
+ {
+ switch (m_Type)
+ {
+ case XSD_DURATION:
+ {
+ ((xsd__duration**) m_Array)[count] = new xsd__duration();
+ *((xsd__duration**)m_Array)[count] = *((xsd__duration**) array)[count];
+ break;
+ }
+ case XSD_DATETIME:
+ {
+ ((xsd__dateTime**) m_Array)[count] = new xsd__dateTime();
+ *((xsd__dateTime**)m_Array)[count] = *((xsd__dateTime**) array)[count];
+ break;
+ }
+ case XSD_TIME:
+ {
+ ((xsd__time**) m_Array)[count] = new xsd__time();
+ *((xsd__time**)m_Array)[count] = *((xsd__time**) array)[count];
+ break;
+ }
+ case XSD_DATE:
+ {
+ ((xsd__date**) m_Array)[count] = new xsd__date();
+ *((xsd__date**)m_Array)[count] = *((xsd__date**) array)[count];
+ break;
+ }
+ case XSD_GYEARMONTH:
+ {
+ ((xsd__gYearMonth**) m_Array)[count] = new xsd__gYearMonth();
+ *((xsd__gYearMonth**)m_Array)[count] = *((xsd__gYearMonth**) array)[count];
+ break;
+ }
+ case XSD_GYEAR:
+ {
+ ((xsd__gYear**) m_Array)[count] = new xsd__gYear();
+ *((xsd__gYear**)m_Array)[count] = *((xsd__gYear**) array)[count];
+ break;
+ }
+ case XSD_GMONTHDAY:
+ {
+ ((xsd__gMonthDay**) m_Array)[count] = new xsd__gMonthDay();
+ *((xsd__gMonthDay**)m_Array)[count] = *((xsd__gMonthDay**) array)[count];
+ break;
+ }
+ case XSD_GDAY:
+ {
+ ((xsd__gDay**) m_Array)[count] = new xsd__gDay();
+ *((xsd__gDay**)m_Array)[count] = *((xsd__gDay**) array)[count];
+ break;
+ }
+ case XSD_GMONTH:
+ {
+ ((xsd__gMonth**) m_Array)[count] = new xsd__gMonth();
+ *((xsd__gMonth**)m_Array)[count] = *((xsd__gMonth**) array)[count];
+ break;
+ }
+ case XSD_STRING:
+ {
+ ((xsd__string*) m_Array)[count] = new char[strlen(((xsd__string*) array)[count])+1]();
+ strcpy(((xsd__string*) m_Array)[count], ((xsd__string*) array)[count]);
+ break;
+ }
+ case XSD_NORMALIZEDSTRING:
+ {
+ ((xsd__normalizedString*) m_Array)[count] = new char[strlen(((xsd__normalizedString*) array)[count])+1]();
+ strcpy(((xsd__normalizedString*) m_Array)[count], ((xsd__normalizedString*) array)[count]);
+ break;
+ }
+ case XSD_TOKEN:
+ {
+ ((xsd__token*) m_Array)[count] = new char[strlen(((xsd__token*) array)[count])+1]();
+ strcpy(((xsd__token*) m_Array)[count], ((xsd__token*) array)[count]);
+ break;
+ }
+ case XSD_LANGUAGE:
+ {
+ ((xsd__language*) m_Array)[count] = new char[strlen(((xsd__language*) array)[count])+1]();
+ strcpy(((xsd__language*) m_Array)[count], ((xsd__language*) array)[count]);
+ break;
+ }
+ case XSD_NAME:
+ {
+ ((xsd__Name*) m_Array)[count] = new char[strlen(((xsd__Name*) array)[count])+1]();
+ strcpy(((xsd__Name*) m_Array)[count], ((xsd__Name*) array)[count]);
+ break;
+ }
+ case XSD_NCNAME:
+ {
+ ((xsd__NCName*) m_Array)[count] = new char[strlen(((xsd__NCName*) array)[count])+1]();
+ strcpy(((xsd__NCName*) m_Array)[count], ((xsd__NCName*) array)[count]);
+ break;
+ }
+ case XSD_ID:
+ {
+ ((xsd__ID*) m_Array)[count] = new char[strlen(((xsd__ID*) array)[count])+1]();
+ strcpy(((xsd__ID*) m_Array)[count], ((xsd__ID*) array)[count]);
+ break;
+ }
+ case XSD_IDREF:
+ {
+ ((xsd__IDREF*) m_Array)[count] = new char[strlen(((xsd__IDREF*) array)[count])+1]();
+ strcpy(((xsd__IDREF*) m_Array)[count], ((xsd__IDREF*) array)[count]);
+ break;
+ }
+ case XSD_IDREFS:
+ {
+ ((xsd__IDREFS*) m_Array)[count] = new char[strlen(((xsd__IDREFS*) array)[count])+1]();
+ strcpy(((xsd__IDREFS*) m_Array)[count], ((xsd__IDREFS*) array)[count]);
+ break;
+ }
+ case XSD_ENTITY:
+ {
+ ((xsd__ENTITY*) m_Array)[count] = new char[strlen(((xsd__ENTITY*) array)[count])+1]();
+ strcpy(((xsd__ENTITY*) m_Array)[count], ((xsd__ENTITY*) array)[count]);
+ break;
+ }
+ case XSD_ENTITIES:
+ {
+ ((xsd__ENTITIES*) m_Array)[count] = new char[strlen(((xsd__ENTITIES*) array)[count])+1]();
+ strcpy(((xsd__ENTITIES*) m_Array)[count], ((xsd__ENTITIES*) array)[count]);
+ break;
+ }
+ case XSD_NMTOKEN:
+ {
+ ((xsd__NMTOKEN*) m_Array)[count] = new char[strlen(((xsd__NMTOKEN*) array)[count])+1]();
+ strcpy(((xsd__NMTOKEN*) m_Array)[count], ((xsd__NMTOKEN*) array)[count]);
+ break;
+ }
+ case XSD_NMTOKENS:
+ {
+ ((xsd__NMTOKENS*) m_Array)[count] = new char[strlen(((xsd__NMTOKENS*) array)[count])+1]();
+ strcpy(((xsd__NMTOKENS*) m_Array)[count], ((xsd__NMTOKENS*) array)[count]);
+ break;
+ }
+ case XSD_BOOLEAN:
+ {
+ ((xsd__boolean**) m_Array)[count] = new xsd__boolean();
+ *((xsd__boolean**)m_Array)[count] = *((xsd__boolean**) array)[count];
+ break;
+ }
+ case XSD_BASE64BINARY:
+ {
+ xsd__base64Binary* pCloneTemp = new xsd__base64Binary();
+ xsd__base64Binary* pOriginalTemp = ((xsd__base64Binary**) array)[count];
+
+ pCloneTemp->__size = pOriginalTemp->__size;
+ pCloneTemp->__ptr = new unsigned char[pCloneTemp->__size];
+ memcpy( pCloneTemp->__ptr, pOriginalTemp->__ptr, pCloneTemp->__size);
+ ((xsd__base64Binary**) m_Array)[count] = pCloneTemp;
+ break;
+ }
+ case XSD_HEXBINARY:
+ {
+ xsd__hexBinary* pCloneTemp = new xsd__hexBinary();
+ xsd__hexBinary* pOriginalTemp = ((xsd__hexBinary**) array)[count];
+
+ pCloneTemp->__size = pOriginalTemp->__size;
+ pCloneTemp->__ptr = new unsigned char[pCloneTemp->__size];
+ memcpy( pCloneTemp->__ptr, pOriginalTemp->__ptr, pCloneTemp->__size);
+ ((xsd__hexBinary**) m_Array)[count] = pCloneTemp;
+ break;
+ }
+ case XSD_FLOAT:
+ {
+ ((xsd__float**) m_Array)[count] = new xsd__float();
+ *((xsd__float**)m_Array)[count] = *((xsd__float**) array)[count];
+ break;
+ }
+ case XSD_DECIMAL:
+ {
+ ((xsd__decimal**) m_Array)[count] = new xsd__decimal();
+ *((xsd__decimal**)m_Array)[count] = *((xsd__decimal**) array)[count];
+ break;
+ }
+ case XSD_INTEGER:
+ {
+ ((xsd__integer**) m_Array)[count] = new xsd__integer();
+ *((xsd__integer**)m_Array)[count] = *((xsd__integer**) array)[count];
+ break;
+ }
+ case XSD_NONPOSITIVEINTEGER:
+ {
+ ((xsd__nonPositiveInteger**) m_Array)[count] = new xsd__nonPositiveInteger();
+ *((xsd__nonPositiveInteger**)m_Array)[count] = *((xsd__nonPositiveInteger**) array)[count];
+ break;
+ }
+ case XSD_NEGATIVEINTEGER:
+ {
+ ((xsd__negativeInteger**) m_Array)[count] = new xsd__negativeInteger();
+ *((xsd__negativeInteger**)m_Array)[count] = *((xsd__negativeInteger**) array)[count];
+ break;
+ }
+ case XSD_LONG:
+ {
+ ((xsd__long**) m_Array)[count] = new xsd__long();
+ *((xsd__long**)m_Array)[count] = *((xsd__long**) array)[count];
+ break;
+ }
+ case XSD_INT:
+ {
+ ((xsd__int**) m_Array)[count] = new xsd__int();
+ *((xsd__int**)m_Array)[count] = *((xsd__int**) array)[count];
+ break;
+ }
+ case XSD_SHORT:
+ {
+ ((xsd__short**) m_Array)[count] = new xsd__short();
+ *((xsd__short**)m_Array)[count] = *((xsd__short**) array)[count];
+ break;
+ }
+ case XSD_BYTE:
+ {
+ ((xsd__byte**) m_Array)[count] = new xsd__byte();
+ *((xsd__byte**)m_Array)[count] = *((xsd__byte**) array)[count];
+ break;
+ }
+ case XSD_NONNEGATIVEINTEGER:
+ {
+ ((xsd__nonNegativeInteger**) m_Array)[count] = new xsd__nonNegativeInteger();
+ *((xsd__nonNegativeInteger**)m_Array)[count] = *((xsd__nonNegativeInteger**) array)[count];
+ break;
+ }
+ case XSD_UNSIGNEDLONG:
+ {
+ ((xsd__unsignedLong**) m_Array)[count] = new xsd__unsignedLong();
+ *((xsd__unsignedLong**)m_Array)[count] = *((xsd__unsignedLong**) array)[count];
+ break;
+ }
+ case XSD_UNSIGNEDINT:
+ {
+ ((xsd__unsignedInt**) m_Array)[count] = new xsd__unsignedInt();
+ *((xsd__unsignedInt**)m_Array)[count] = *((xsd__unsignedInt**) array)[count];
+ break;
+ }
+ case XSD_UNSIGNEDSHORT:
+ {
+ ((xsd__unsignedShort**) m_Array)[count] = new xsd__unsignedShort();
+ *((xsd__unsignedShort**)m_Array)[count] = *((xsd__unsignedShort**) array)[count];
+ break;
+ }
+ case XSD_UNSIGNEDBYTE:
+ {
+ ((xsd__unsignedByte**) m_Array)[count] = new xsd__unsignedByte();
+ *((xsd__unsignedByte**)m_Array)[count] = *((xsd__unsignedByte**) array)[count];
+ break;
+ }
+ case XSD_POSITIVEINTEGER:
+ {
+ ((xsd__positiveInteger**) m_Array)[count] = new xsd__positiveInteger();
+ *((xsd__positiveInteger**)m_Array)[count] = *((xsd__positiveInteger**) array)[count];
+ break;
+ }
+ case XSD_DOUBLE:
+ {
+ ((xsd__double**) m_Array)[count] = new xsd__double();
+ *((xsd__double**)m_Array)[count] = *((xsd__double**) array)[count];
+ break;
+ }
+ case XSD_ANYURI:
+ {
+ ((xsd__anyURI*) m_Array)[count] = new char[strlen(((xsd__anyURI*) array)[count])+1]();
+ strcpy(((xsd__anyURI*) m_Array)[count], ((xsd__anyURI*) array)[count]);
+ break;
+ }
+ case XSD_QNAME:
+ {
+ ((xsd__QName*) m_Array)[count] = new char[strlen(((xsd__QName*) array)[count])+1]();
+ strcpy(((xsd__QName*) m_Array)[count], ((xsd__QName*) array)[count]);
+ break;
+ }
+ case XSD_NOTATION:
+ {
+ ((xsd__NOTATION*) m_Array)[count] = new char[strlen(((xsd__NOTATION*) array)[count])+1]();
+ strcpy(((xsd__NOTATION*) m_Array)[count], ((xsd__NOTATION*) array)[count]);
+ break;
+ }
+ case XSD_ARRAY:
+ {
+ ((Axis_Array**) m_Array)[count] = new Axis_Array(*((Axis_Array**) array)[count]);
+ }
+ case USER_TYPE:
+ {
+ ((int*) m_Array)[count] = ((int*) array)[count];
+ }
+ case XSD_UNKNOWN:
+ case XSD_ANY:
+ case ATTACHMENT:
+ default:
+ break;
+ }
+ }
+ }
+ }
+}
+
+const void* Axis_Array::get(int& size, XSDTYPE& type) const
+{
+ size = m_Size;
+ type = m_Type;
+ return m_Array;
+}
+
+
+Axis_Array::~Axis_Array()
+{
+ clear();
+}
+
+void Axis_Array::clear()
+{
+ if (m_Array != NULL)
+ {
+ if (m_Size > 0)
+ {
+ for (int count = 0 ; count < m_Size ; count++)
+ {
+ if (((int*) m_Array)[count] != NULL)
+ {
+ switch (m_Type)
+ {
+ case XSD_DURATION:
+ {
+ delete ((xsd__duration**) m_Array)[count];
+ break;
+ }
+ case XSD_DATETIME:
+ {
+ delete ((xsd__dateTime**) m_Array)[count];
+ break;
+ }
+ case XSD_TIME:
+ {
+ delete ((xsd__time**) m_Array)[count];
+ break;
+ }
+ case XSD_DATE:
+ {
+ delete ((xsd__date**) m_Array)[count];
+ break;
+ }
+ case XSD_GYEARMONTH:
+ {
+ delete ((xsd__gYearMonth**) m_Array)[count];
+ break;
+ }
+ case XSD_GYEAR:
+ {
+ delete ((xsd__gYear**) m_Array)[count];
+ break;
+ }
+ case XSD_GMONTHDAY:
+ {
+ delete ((xsd__gMonthDay**) m_Array)[count];
+ break;
+ }
+ case XSD_GDAY:
+ {
+ delete ((xsd__gDay**) m_Array)[count];
+ break;
+ }
+ case XSD_GMONTH:
+ {
+ delete ((xsd__gMonth**) m_Array)[count];
+ break;
+ }
+ case XSD_STRING:
+ {
+ delete []((xsd__string*) m_Array)[count];
+ break;
+ }
+ case XSD_NORMALIZEDSTRING:
+ {
+ delete []((xsd__normalizedString*) m_Array)[count];
+ break;
+ }
+ case XSD_TOKEN:
+ {
+ delete []((xsd__token*) m_Array)[count];
+ break;
+ }
+ case XSD_LANGUAGE:
+ {
+ delete []((xsd__language*) m_Array)[count];
+ break;
+ }
+ case XSD_NAME:
+ {
+ delete []((xsd__Name*) m_Array)[count];
+ break;
+ }
+ case XSD_NCNAME:
+ {
+ delete []((xsd__NCName*) m_Array)[count];
+ break;
+ }
+ case XSD_ID:
+ {
+ delete []((xsd__ID*) m_Array)[count];
+ break;
+ }
+ case XSD_IDREF:
+ {
+ delete []((xsd__IDREF*) m_Array)[count];
+ break;
+ }
+ case XSD_IDREFS:
+ {
+ delete []((xsd__IDREFS*) m_Array)[count];
+ break;
+ }
+ case XSD_ENTITY:
+ {
+ delete []((xsd__ENTITY*) m_Array)[count];
+ break;
+ }
+ case XSD_ENTITIES:
+ {
+ delete []((xsd__ENTITIES*) m_Array)[count];
+ break;
+ }
+ case XSD_NMTOKEN:
+ {
+ delete []((xsd__NMTOKEN*) m_Array)[count];
+ break;
+ }
+ case XSD_NMTOKENS:
+ {
+ delete []((xsd__NMTOKENS*) m_Array)[count];
+ break;
+ }
+ case XSD_BOOLEAN:
+ {
+ delete ((xsd__boolean**) m_Array)[count];
+ break;
+ }
+ case XSD_BASE64BINARY:
+ {
+ delete ((xsd__base64Binary**) m_Array)[count];
+ break;
+ }
+ case XSD_HEXBINARY:
+ {
+ delete ((xsd__hexBinary**) m_Array)[count];
+ break;
+ }
+ case XSD_FLOAT:
+ {
+ delete ((xsd__float**) m_Array)[count];
+ break;
+ }
+ case XSD_DECIMAL:
+ {
+ delete ((xsd__decimal**) m_Array)[count];
+ break;
+ }
+ case XSD_INTEGER:
+ {
+ delete ((xsd__integer**) m_Array)[count];
+ break;
+ }
+ case XSD_NONPOSITIVEINTEGER:
+ {
+ delete ((xsd__nonPositiveInteger**) m_Array)[count];
+ break;
+ }
+ case XSD_NEGATIVEINTEGER:
+ {
+ delete ((xsd__negativeInteger**) m_Array)[count];
+ break;
+ }
+ case XSD_LONG:
+ {
+ delete ((xsd__long**) m_Array)[count];
+ break;
+ }
+ case XSD_INT:
+ {
+ delete ((xsd__int**) m_Array)[count];
+ break;
+ }
+ case XSD_SHORT:
+ {
+ delete ((xsd__short**) m_Array)[count];
+ break;
+ }
+ case XSD_BYTE:
+ {
+ delete ((xsd__byte**) m_Array)[count];
+ break;
+ }
+ case XSD_NONNEGATIVEINTEGER:
+ {
+ delete ((xsd__nonNegativeInteger**) m_Array)[count];
+ break;
+ }
+ case XSD_UNSIGNEDLONG:
+ {
+ delete ((xsd__unsignedLong**) m_Array)[count];
+ break;
+ }
+ case XSD_UNSIGNEDINT:
+ {
+ delete ((xsd__unsignedInt**) m_Array)[count];
+ break;
+ }
+ case XSD_UNSIGNEDSHORT:
+ {
+ delete ((xsd__unsignedShort**) m_Array)[count];
+ break;
+ }
+ case XSD_UNSIGNEDBYTE:
+ {
+ delete ((xsd__unsignedByte**) m_Array)[count];
+ break;
+ }
+ case XSD_POSITIVEINTEGER:
+ {
+ delete ((xsd__positiveInteger**) m_Array)[count];
+ break;
+ }
+ case XSD_DOUBLE:
+ {
+ delete ((xsd__double**) m_Array)[count];
+ break;
+ }
+ case XSD_ANYURI:
+ {
+ delete []((xsd__anyURI*) m_Array)[count];
+ break;
+ }
+ case XSD_QNAME:
+ {
+ delete []((xsd__QName*) m_Array)[count];
+ break;
+ }
+ case XSD_NOTATION:
+ {
+ delete []((xsd__NOTATION*) m_Array)[count];
+ break;
+ }
+ case XSD_ARRAY:
+ {
+ delete ((Axis_Array**) m_Array)[count];
+ break;
+ }
+ case USER_TYPE:
+ case XSD_ANY:
+ case ATTACHMENT:
+ case XSD_UNKNOWN:
+ default:
+ break;
+ }
+ }
+ }
+ m_Size = 0;
+ }
+ delete [] m_Array;
+ m_Array = NULL;
+ }
+}
+
+xsd__duration_Array::xsd__duration_Array()
+{
+ m_Type = XSD_DURATION;
+}
+
+xsd__duration_Array::xsd__duration_Array(xsd__duration_Array & original)
+{
+ if (original.m_Type == XSD_DURATION)
+ {
+ clone(original);
+ }
+}
+
+void xsd__duration_Array::set(xsd__duration** array, int size)
+{
+ Axis_Array::set(array, size, XSD_DURATION);
+}
+
+const xsd__duration** xsd__duration_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__duration**) Axis_Array::get(size, type);
+}
+
+xsd__dateTime_Array::xsd__dateTime_Array()
+{
+ m_Type = XSD_DURATION;
+}
+
+xsd__dateTime_Array::xsd__dateTime_Array(xsd__dateTime_Array & original)
+{
+ if (original.m_Type == XSD_DURATION)
+ {
+ clone(original);
+ }
+}
+
+void xsd__dateTime_Array::set(xsd__dateTime** array, int size)
+{
+ Axis_Array::set(array, size, XSD_DURATION);
+}
+
+const xsd__dateTime** xsd__dateTime_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__dateTime**) Axis_Array::get(size, type);
+}
+
+xsd__time_Array::xsd__time_Array()
+{
+ m_Type = XSD_DURATION;
+}
+
+xsd__time_Array::xsd__time_Array(xsd__time_Array & original)
+{
+ if (original.m_Type == XSD_DURATION)
+ {
+ clone(original);
+ }
+}
+
+void xsd__time_Array::set(xsd__time** array, int size)
+{
+ Axis_Array::set(array, size, XSD_DURATION);
+}
+
+const xsd__time** xsd__time_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__time**) Axis_Array::get(size, type);
+}
+
+xsd__date_Array::xsd__date_Array()
+{
+ m_Type = XSD_DURATION;
+}
+
+xsd__date_Array::xsd__date_Array(xsd__date_Array & original)
+{
+ if (original.m_Type == XSD_DURATION)
+ {
+ clone(original);
+ }
+}
+
+void xsd__date_Array::set(xsd__date** array, int size)
+{
+ Axis_Array::set(array, size, XSD_DURATION);
+}
+
+const xsd__date** xsd__date_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__date**) Axis_Array::get(size, type);
+}
+
+xsd__gYearMonth_Array::xsd__gYearMonth_Array()
+{
+ m_Type = XSD_DURATION;
+}
+
+xsd__gYearMonth_Array::xsd__gYearMonth_Array(xsd__gYearMonth_Array & original)
+{
+ if (original.m_Type == XSD_DURATION)
+ {
+ clone(original);
+ }
+}
+
+void xsd__gYearMonth_Array::set(xsd__gYearMonth** array, int size)
+{
+ Axis_Array::set(array, size, XSD_DURATION);
+}
+
+const xsd__gYearMonth** xsd__gYearMonth_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__gYearMonth**) Axis_Array::get(size, type);
+}
+
+xsd__gYear_Array::xsd__gYear_Array()
+{
+ m_Type = XSD_DURATION;
+}
+
+xsd__gYear_Array::xsd__gYear_Array(xsd__gYear_Array & original)
+{
+ if (original.m_Type == XSD_DURATION)
+ {
+ clone(original);
+ }
+}
+
+void xsd__gYear_Array::set(xsd__gYear** array, int size)
+{
+ Axis_Array::set(array, size, XSD_DURATION);
+}
+
+const xsd__gYear** xsd__gYear_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__gYear**) Axis_Array::get(size, type);
+}
+
+xsd__gMonthDay_Array::xsd__gMonthDay_Array()
+{
+ m_Type = XSD_DURATION;
+}
+
+xsd__gMonthDay_Array::xsd__gMonthDay_Array(xsd__gMonthDay_Array & original)
+{
+ if (original.m_Type == XSD_DURATION)
+ {
+ clone(original);
+ }
+}
+
+void xsd__gMonthDay_Array::set(xsd__gMonthDay** array, int size)
+{
+ Axis_Array::set(array, size, XSD_DURATION);
+}
+
+const xsd__gMonthDay** xsd__gMonthDay_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__gMonthDay**) Axis_Array::get(size, type);
+}
+
+xsd__gMonth_Array::xsd__gMonth_Array()
+{
+ m_Type = XSD_DURATION;
+}
+
+xsd__gMonth_Array::xsd__gMonth_Array(xsd__gMonth_Array & original)
+{
+ if (original.m_Type == XSD_DURATION)
+ {
+ clone(original);
+ }
+}
+void xsd__gMonth_Array::set(xsd__gMonth** array, int size)
+{
+ Axis_Array::set(array, size, XSD_DURATION);
+}
+
+const xsd__gMonth** xsd__gMonth_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__gMonth**) Axis_Array::get(size, type);
+}
+
+xsd__gDay_Array::xsd__gDay_Array()
+{
+ m_Type = XSD_DURATION;
+}
+
+xsd__gDay_Array::xsd__gDay_Array(xsd__gDay_Array & original)
+{
+ if (original.m_Type == XSD_DURATION)
+ {
+ clone(original);
+ }
+}
+
+void xsd__gDay_Array::set(xsd__gDay** array, int size)
+{
+ Axis_Array::set(array, size, XSD_DURATION);
+}
+
+const xsd__gDay** xsd__gDay_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__gDay**) Axis_Array::get(size, type);
+}
+
+xsd__string_Array::xsd__string_Array()
+{
+ m_Type = XSD_STRING;
+}
+
+xsd__string_Array::xsd__string_Array(xsd__string_Array & original)
+{
+ if (original.m_Type == XSD_STRING)
+ {
+ clone(original);
+ }
+}
+
+void xsd__string_Array::set(xsd__string* array, int size)
+{
+ Axis_Array::set(array, size, XSD_STRING);
+}
+
+const xsd__string* xsd__string_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__string*) Axis_Array::get(size, type);
+}
+
+xsd__normalizedString_Array::xsd__normalizedString_Array()
+{
+ m_Type = XSD_NORMALIZEDSTRING;
+}
+
+xsd__normalizedString_Array::xsd__normalizedString_Array(xsd__normalizedString_Array & original)
+{
+ if (original.m_Type == XSD_NORMALIZEDSTRING)
+ {
+ clone(original);
+ }
+}
+
+void xsd__normalizedString_Array::set(xsd__normalizedString* array, int size)
+{
+ Axis_Array::set(array, size, XSD_NORMALIZEDSTRING);
+}
+
+const xsd__normalizedString* xsd__normalizedString_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__normalizedString*) Axis_Array::get(size, type);
+}
+
+xsd__token_Array::xsd__token_Array()
+{
+ m_Type = XSD_TOKEN;
+}
+
+xsd__token_Array::xsd__token_Array(xsd__token_Array & original)
+{
+ if (original.m_Type == XSD_TOKEN)
+ {
+ clone(original);
+ }
+}
+
+void xsd__token_Array::set(xsd__token* array, int size)
+{
+ Axis_Array::set(array, size, XSD_TOKEN);
+}
+
+const xsd__token* xsd__token_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__token*) Axis_Array::get(size, type);
+}
+
+xsd__language_Array::xsd__language_Array()
+{
+ m_Type = XSD_LANGUAGE;
+}
+
+xsd__language_Array::xsd__language_Array(xsd__language_Array & original)
+{
+ if (original.m_Type == XSD_LANGUAGE)
+ {
+ clone(original);
+ }
+}
+
+void xsd__language_Array::set(xsd__language* array, int size)
+{
+ Axis_Array::set(array, size, XSD_LANGUAGE);
+}
+
+const xsd__language* xsd__language_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__language*) Axis_Array::get(size, type);
+}
+
+xsd__Name_Array::xsd__Name_Array()
+{
+ m_Type = XSD_NAME;
+}
+
+xsd__Name_Array::xsd__Name_Array(xsd__Name_Array & original)
+{
+ if (original.m_Type == XSD_NAME)
+ {
+ clone(original);
+ }
+}
+
+void xsd__Name_Array::set(xsd__Name* array, int size)
+{
+ Axis_Array::set(array, size, XSD_NAME);
+}
+
+const xsd__Name* xsd__Name_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__Name*) Axis_Array::get(size, type);
+}
+
+xsd__NCName_Array::xsd__NCName_Array()
+{
+ m_Type = XSD_NCNAME;
+}
+
+xsd__NCName_Array::xsd__NCName_Array(xsd__NCName_Array & original)
+{
+ if (original.m_Type == XSD_NCNAME)
+ {
+ clone(original);
+ }
+}
+
+void xsd__NCName_Array::set(xsd__NCName* array, int size)
+{
+ Axis_Array::set(array, size, XSD_NCNAME);
+}
+
+const xsd__NCName* xsd__NCName_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__NCName*) Axis_Array::get(size, type);
+}
+
+xsd__ID_Array::xsd__ID_Array()
+{
+ m_Type = XSD_ID;
+}
+
+xsd__ID_Array::xsd__ID_Array(xsd__ID_Array & original)
+{
+ if (original.m_Type == XSD_ID)
+ {
+ clone(original);
+ }
+}
+
+void xsd__ID_Array::set(xsd__ID* array, int size)
+{
+ Axis_Array::set(array, size, XSD_ID);
+}
+
+const xsd__ID* xsd__ID_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__ID*) Axis_Array::get(size, type);
+}
+
+xsd__IDREF_Array::xsd__IDREF_Array()
+{
+ m_Type = XSD_IDREF;
+}
+
+xsd__IDREF_Array::xsd__IDREF_Array(xsd__IDREF_Array & original)
+{
+ if (original.m_Type == XSD_IDREF)
+ {
+ clone(original);
+ }
+}
+
+void xsd__IDREF_Array::set(xsd__IDREF* array, int size)
+{
+ Axis_Array::set(array, size, XSD_IDREF);
+}
+
+const xsd__IDREF* xsd__IDREF_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__IDREF*) Axis_Array::get(size, type);
+}
+
+xsd__IDREFS_Array::xsd__IDREFS_Array()
+{
+ m_Type = XSD_IDREFS;
+}
+
+xsd__IDREFS_Array::xsd__IDREFS_Array(xsd__IDREFS_Array & original)
+{
+ if (original.m_Type == XSD_IDREFS)
+ {
+ clone(original);
+ }
+}
+
+void xsd__IDREFS_Array::set(xsd__IDREFS* array, int size)
+{
+ Axis_Array::set(array, size, XSD_IDREFS);
+}
+
+const xsd__IDREFS* xsd__IDREFS_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__IDREFS*) Axis_Array::get(size, type);
+}
+
+xsd__ENTITY_Array::xsd__ENTITY_Array()
+{
+ m_Type = XSD_ENTITY;
+}
+
+xsd__ENTITY_Array::xsd__ENTITY_Array(xsd__ENTITY_Array & original)
+{
+ if (original.m_Type == XSD_ENTITY)
+ {
+ clone(original);
+ }
+}
+
+void xsd__ENTITY_Array::set(xsd__ENTITY* array, int size)
+{
+ Axis_Array::set(array, size, XSD_ENTITY);
+}
+
+const xsd__ENTITY* xsd__ENTITY_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__ENTITY*) Axis_Array::get(size, type);
+}
+
+xsd__ENTITIES_Array::xsd__ENTITIES_Array()
+{
+ m_Type = XSD_ENTITIES;
+}
+
+xsd__ENTITIES_Array::xsd__ENTITIES_Array(xsd__ENTITIES_Array & original)
+{
+ if (original.m_Type == XSD_ENTITIES)
+ {
+ clone(original);
+ }
+}
+
+void xsd__ENTITIES_Array::set(xsd__ENTITIES* array, int size)
+{
+ Axis_Array::set(array, size, XSD_ENTITIES);
+}
+
+const xsd__ENTITIES* xsd__ENTITIES_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__ENTITIES*) Axis_Array::get(size, type);
+}
+
+xsd__NMTOKEN_Array::xsd__NMTOKEN_Array()
+{
+ m_Type = XSD_NMTOKEN;
+}
+
+xsd__NMTOKEN_Array::xsd__NMTOKEN_Array(xsd__NMTOKEN_Array & original)
+{
+ if (original.m_Type == XSD_NMTOKEN)
+ {
+ clone(original);
+ }
+}
+
+void xsd__NMTOKEN_Array::set(xsd__NMTOKEN* array, int size)
+{
+ Axis_Array::set(array, size, XSD_NMTOKEN);
+}
+
+const xsd__NMTOKEN* xsd__NMTOKEN_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__NMTOKEN*) Axis_Array::get(size, type);
+}
+
+xsd__NMTOKENS_Array::xsd__NMTOKENS_Array()
+{
+ m_Type = XSD_NMTOKEN;
+}
+
+xsd__NMTOKENS_Array::xsd__NMTOKENS_Array(xsd__NMTOKENS_Array & original)
+{
+ if (original.m_Type == XSD_NMTOKEN)
+ {
+ clone(original);
+ }
+}
+
+void xsd__NMTOKENS_Array::set(xsd__NMTOKENS* array, int size)
+{
+ Axis_Array::set(array, size, XSD_NMTOKEN);
+}
+
+const xsd__NMTOKENS* xsd__NMTOKENS_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__NMTOKENS*) Axis_Array::get(size, type);
+}
+
+xsd__boolean_Array::xsd__boolean_Array()
+{
+ m_Type = XSD_BOOLEAN;
+}
+
+xsd__boolean_Array::xsd__boolean_Array(xsd__boolean_Array & original)
+{
+ if (original.m_Type == XSD_BOOLEAN)
+ {
+ clone(original);
+ }
+}
+
+void xsd__boolean_Array::set(xsd__boolean** array, int size)
+{
+ Axis_Array::set(array, size, XSD_BOOLEAN);
+}
+
+const xsd__boolean** xsd__boolean_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__boolean**) Axis_Array::get(size, type);
+}
+
+xsd__base64Binary_Array::xsd__base64Binary_Array()
+{
+ m_Type = XSD_BASE64BINARY;
+}
+
+xsd__base64Binary_Array::xsd__base64Binary_Array(xsd__base64Binary_Array & original)
+{
+ if (original.m_Type == XSD_BASE64BINARY)
+ {
+ clone(original);
+ }
+}
+
+void xsd__base64Binary_Array::set(xsd__base64Binary** array, int size)
+{
+ Axis_Array::set(array, size, XSD_BASE64BINARY);
+}
+
+const xsd__base64Binary** xsd__base64Binary_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__base64Binary**) Axis_Array::get(size, type);
+}
+
+xsd__hexBinary_Array::xsd__hexBinary_Array()
+{
+ m_Type = XSD_HEXBINARY;
+}
+
+xsd__hexBinary_Array::xsd__hexBinary_Array(xsd__hexBinary_Array & original)
+{
+ if (original.m_Type == XSD_HEXBINARY)
+ {
+ clone(original);
+ }
+}
+
+void xsd__hexBinary_Array::set(xsd__hexBinary** array, int size)
+{
+ Axis_Array::set(array, size, XSD_HEXBINARY);
+}
+
+const xsd__hexBinary** xsd__hexBinary_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__hexBinary**) Axis_Array::get(size, type);
+}
+
+xsd__float_Array::xsd__float_Array()
+{
+ m_Type = XSD_FLOAT;
+}
+
+xsd__float_Array::xsd__float_Array(xsd__float_Array & original)
+{
+ if (original.m_Type == XSD_FLOAT)
+ {
+ clone(original);
+ }
+}
+
+void xsd__float_Array::set(xsd__float** array, int size)
+{
+ Axis_Array::set(array, size, XSD_FLOAT);
+}
+
+const xsd__float** xsd__float_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__float**) Axis_Array::get(size, type);
+}
+
+xsd__decimal_Array::xsd__decimal_Array()
+{
+ m_Type = XSD_DECIMAL;
+}
+
+xsd__decimal_Array::xsd__decimal_Array(xsd__decimal_Array & original)
+{
+ if (original.m_Type == XSD_DECIMAL)
+ {
+ clone(original);
+ }
+}
+
+void xsd__decimal_Array::set(xsd__decimal** array, int size)
+{
+ Axis_Array::set(array, size, XSD_DECIMAL);
+}
+
+const xsd__decimal** xsd__decimal_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__decimal**) Axis_Array::get(size, type);
+}
+
+xsd__integer_Array::xsd__integer_Array()
+{
+ m_Type = XSD_INTEGER;
+}
+
+xsd__integer_Array::xsd__integer_Array(xsd__integer_Array & original)
+{
+ if (original.m_Type == XSD_INTEGER)
+ {
+ clone(original);
+ }
+}
+
+void xsd__integer_Array::set(xsd__integer** array, int size)
+{
+ Axis_Array::set(array, size, XSD_INTEGER);
+}
+
+const xsd__integer** xsd__integer_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__integer**) Axis_Array::get(size, type);
+}
+
+xsd__nonPositiveInteger_Array::xsd__nonPositiveInteger_Array()
+{
+ m_Type = XSD_NONPOSITIVEINTEGER;
+}
+
+xsd__nonPositiveInteger_Array::xsd__nonPositiveInteger_Array(xsd__nonPositiveInteger_Array & original)
+{
+ if (original.m_Type == XSD_NONPOSITIVEINTEGER)
+ {
+ clone(original);
+ }
+}
+
+void xsd__nonPositiveInteger_Array::set(xsd__nonPositiveInteger** array, int size)
+{
+ Axis_Array::set(array, size, XSD_NONPOSITIVEINTEGER);
+}
+
+const xsd__nonPositiveInteger** xsd__nonPositiveInteger_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__nonPositiveInteger**) Axis_Array::get(size, type);
+}
+
+xsd__negativeInteger_Array::xsd__negativeInteger_Array()
+{
+ m_Type = XSD_NEGATIVEINTEGER;
+}
+
+xsd__negativeInteger_Array::xsd__negativeInteger_Array(xsd__negativeInteger_Array & original)
+{
+ if (original.m_Type == XSD_NEGATIVEINTEGER)
+ {
+ clone(original);
+ }
+}
+
+void xsd__negativeInteger_Array::set(xsd__negativeInteger** array, int size)
+{
+ Axis_Array::set(array, size, XSD_NEGATIVEINTEGER);
+}
+
+const xsd__negativeInteger** xsd__negativeInteger_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__negativeInteger**) Axis_Array::get(size, type);
+}
+
+xsd__long_Array::xsd__long_Array()
+{
+ m_Type = XSD_LONG;
+}
+
+xsd__long_Array::xsd__long_Array(xsd__long_Array & original)
+{
+ if (original.m_Type == XSD_LONG)
+ {
+ clone(original);
+ }
+}
+
+void xsd__long_Array::set(xsd__long** array, int size)
+{
+ Axis_Array::set(array, size, XSD_LONG);
+}
+
+const xsd__long** xsd__long_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__long**) Axis_Array::get(size, type);
+}
+
+xsd__int_Array::xsd__int_Array()
+{
+ m_Type = XSD_INT;
+}
+
+xsd__int_Array::xsd__int_Array(xsd__int_Array & original)
+{
+ if (original.m_Type == XSD_INT)
+ {
+ clone(original);
+ }
+}
+
+void xsd__int_Array::set(xsd__int** array, int size)
+{
+ Axis_Array::set(array, size, XSD_INT);
+}
+
+const xsd__int** xsd__int_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__int**) Axis_Array::get(size, type);
+}
+
+xsd__short_Array::xsd__short_Array()
+{
+ m_Type = XSD_SHORT;
+}
+
+xsd__short_Array::xsd__short_Array(xsd__short_Array & original)
+{
+ if (original.m_Type == XSD_SHORT)
+ {
+ clone(original);
+ }
+}
+
+void xsd__short_Array::set(xsd__short** array, int size)
+{
+ Axis_Array::set(array, size, XSD_SHORT);
+}
+
+const xsd__short** xsd__short_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__short**) Axis_Array::get(size, type);
+}
+
+xsd__byte_Array::xsd__byte_Array()
+{
+ m_Type = XSD_BYTE;
+}
+
+xsd__byte_Array::xsd__byte_Array(xsd__byte_Array & original)
+{
+ if (original.m_Type == XSD_BYTE)
+ {
+ clone(original);
+ }
+}
+
+void xsd__byte_Array::set(xsd__byte** array, int size)
+{
+ Axis_Array::set(array, size, XSD_BYTE);
+}
+
+const xsd__byte** xsd__byte_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__byte**) Axis_Array::get(size, type);
+}
+
+xsd__nonNegativeInteger_Array::xsd__nonNegativeInteger_Array()
+{
+ m_Type = XSD_NONNEGATIVEINTEGER;
+}
+
+xsd__nonNegativeInteger_Array::xsd__nonNegativeInteger_Array(xsd__nonNegativeInteger_Array & original)
+{
+ if (original.m_Type == XSD_NONNEGATIVEINTEGER)
+ {
+ clone(original);
+ }
+}
+
+void xsd__nonNegativeInteger_Array::set(xsd__nonNegativeInteger** array, int size)
+{
+ Axis_Array::set(array, size, XSD_NONNEGATIVEINTEGER);
+}
+
+const xsd__nonNegativeInteger** xsd__nonNegativeInteger_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__nonNegativeInteger**) Axis_Array::get(size, type);
+}
+
+xsd__unsignedLong_Array::xsd__unsignedLong_Array()
+{
+ m_Type = XSD_UNSIGNEDLONG;
+}
+
+xsd__unsignedLong_Array::xsd__unsignedLong_Array(xsd__unsignedLong_Array & original)
+{
+ if (original.m_Type == XSD_UNSIGNEDLONG)
+ {
+ clone(original);
+ }
+}
+
+void xsd__unsignedLong_Array::set(xsd__unsignedLong** array, int size)
+{
+ Axis_Array::set(array, size, XSD_UNSIGNEDLONG);
+}
+
+const xsd__unsignedLong** xsd__unsignedLong_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__unsignedLong**) Axis_Array::get(size, type);
+}
+
+xsd__unsignedInt_Array::xsd__unsignedInt_Array()
+{
+ m_Type = XSD_UNSIGNEDINT;
+}
+
+xsd__unsignedInt_Array::xsd__unsignedInt_Array(xsd__unsignedInt_Array & original)
+{
+ if (original.m_Type == XSD_UNSIGNEDINT)
+ {
+ clone(original);
+ }
+}
+
+void xsd__unsignedInt_Array::set(xsd__unsignedInt** array, int size)
+{
+ Axis_Array::set(array, size, XSD_UNSIGNEDINT);
+}
+
+const xsd__unsignedInt** xsd__unsignedInt_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__unsignedInt**) Axis_Array::get(size, type);
+}
+
+xsd__unsignedShort_Array::xsd__unsignedShort_Array()
+{
+ m_Type = XSD_UNSIGNEDSHORT;
+}
+
+xsd__unsignedShort_Array::xsd__unsignedShort_Array(xsd__unsignedShort_Array & original)
+{
+ if (original.m_Type == XSD_UNSIGNEDSHORT)
+ {
+ clone(original);
+ }
+}
+
+void xsd__unsignedShort_Array::set(xsd__unsignedShort** array, int size)
+{
+ Axis_Array::set(array, size, XSD_UNSIGNEDSHORT);
+}
+
+const xsd__unsignedShort** xsd__unsignedShort_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__unsignedShort**) Axis_Array::get(size, type);
+}
+
+xsd__unsignedByte_Array::xsd__unsignedByte_Array()
+{
+ m_Type = XSD_UNSIGNEDBYTE;
+}
+
+xsd__unsignedByte_Array::xsd__unsignedByte_Array(xsd__unsignedByte_Array & original)
+{
+ if (original.m_Type == XSD_UNSIGNEDBYTE)
+ {
+ clone(original);
+ }
+}
+
+void xsd__unsignedByte_Array::set(xsd__unsignedByte** array, int size)
+{
+ Axis_Array::set(array, size, XSD_UNSIGNEDBYTE);
+}
+
+const xsd__unsignedByte** xsd__unsignedByte_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__unsignedByte**) Axis_Array::get(size, type);
+}
+
+xsd__positiveInteger_Array::xsd__positiveInteger_Array()
+{
+ m_Type = XSD_POSITIVEINTEGER;
+}
+
+xsd__positiveInteger_Array::xsd__positiveInteger_Array(xsd__positiveInteger_Array & original)
+{
+ if (original.m_Type == XSD_POSITIVEINTEGER)
+ {
+ clone(original);
+ }
+}
+
+void xsd__positiveInteger_Array::set(xsd__positiveInteger** array, int size)
+{
+ Axis_Array::set(array, size, XSD_POSITIVEINTEGER);
+}
+
+const xsd__positiveInteger** xsd__positiveInteger_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__positiveInteger**) Axis_Array::get(size, type);
+}
+
+xsd__double_Array::xsd__double_Array()
+{
+ m_Type = XSD_DOUBLE;
+}
+
+xsd__double_Array::xsd__double_Array(xsd__double_Array & original)
+{
+ if (original.m_Type == XSD_DOUBLE)
+ {
+ clone(original);
+ }
+}
+
+void xsd__double_Array::set(xsd__double** array, int size)
+{
+ Axis_Array::set(array, size, XSD_DOUBLE);
+}
+
+const xsd__double** xsd__double_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__double**) Axis_Array::get(size, type);
+}
+
+xsd__anyURI_Array::xsd__anyURI_Array()
+{
+ m_Type = XSD_ANYURI;
+}
+
+xsd__anyURI_Array::xsd__anyURI_Array(xsd__anyURI_Array & original)
+{
+ if (original.m_Type == XSD_ANYURI)
+ {
+ clone(original);
+ }
+}
+
+void xsd__anyURI_Array::set(xsd__anyURI* array, int size)
+{
+ Axis_Array::set(array, size, XSD_ANYURI);
+}
+
+const xsd__anyURI* xsd__anyURI_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__anyURI*) Axis_Array::get(size, type);
+}
+
+xsd__QName_Array::xsd__QName_Array()
+{
+ m_Type = XSD_QNAME;
+}
+
+xsd__QName_Array::xsd__QName_Array(xsd__QName_Array & original)
+{
+ if (original.m_Type == XSD_QNAME)
+ {
+ clone(original);
+ }
+}
+
+void xsd__QName_Array::set(xsd__QName* array, int size)
+{
+ Axis_Array::set(array, size, XSD_QNAME);
+}
+
+const xsd__QName* xsd__QName_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__QName*) Axis_Array::get(size, type);
+}
+
+xsd__NOTATION_Array::xsd__NOTATION_Array()
+{
+ m_Type = XSD_NOTATION;
+}
+
+xsd__NOTATION_Array::xsd__NOTATION_Array(xsd__NOTATION_Array & original)
+{
+ if (original.m_Type == XSD_NOTATION)
+ {
+ clone(original);
+ }
+}
+
+void xsd__NOTATION_Array::set(xsd__NOTATION* array, int size)
+{
+ Axis_Array::set(array, size, XSD_NOTATION);
+}
+
+const xsd__NOTATION* xsd__NOTATION_Array::get(int& size) const
+{
+ XSDTYPE type;
+ return (const xsd__NOTATION*) Axis_Array::get(size, type);
}
AXIS_CPP_NAMESPACE_END
Modified: webservices/axis/trunk/c/src/soap/Namespace.h
URL: http://svn.apache.org/viewcvs/webservices/axis/trunk/c/src/soap/Namespace.h?rev=331554&r1=331553&r2=331554&view=diff
==============================================================================
--- webservices/axis/trunk/c/src/soap/Namespace.h (original)
+++ webservices/axis/trunk/c/src/soap/Namespace.h Mon Nov 7 09:36:47 2005
@@ -30,10 +30,13 @@
#pragma once
#endif // _MSC_VER > 1000
-#include <axis/AxisUserAPI.hpp>
+#include <axis/GDefine.hpp>
#include <axis/INamespace.hpp>
-#include <string>
#include <list>
+#include <string>
+
+
+
AXIS_CPP_NAMESPACE_START
using namespace std;
Modified: webservices/axis/trunk/c/src/soap/SoapDeSerializer.cpp
URL: http://svn.apache.org/viewcvs/webservices/axis/trunk/c/src/soap/SoapDeSerializer.cpp?rev=331554&r1=331553&r2=331554&view=diff
==============================================================================
--- webservices/axis/trunk/c/src/soap/SoapDeSerializer.cpp (original)
+++ webservices/axis/trunk/c/src/soap/SoapDeSerializer.cpp Mon Nov 7 09:36:47 2005
@@ -588,7 +588,7 @@
const AxisChar * pName,
const AxisChar * pNamespace)
{
- Axis_Array Array = { NULL, 0 };
+ Axis_Array Array;
int nIndex = 0;
void *pItem;
int itemsize;
@@ -1046,7 +1046,8 @@
const AxisChar * pName,
const AxisChar * pNamespace)
{
- Axis_Array Array = { NULL, 0 };
+ Axis_Array Array;
+ Array.m_Type = nType;
if (AXIS_SUCCESS != m_nStatus)
{
Modified: webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/c/ArrayParamWriter.java
URL: http://svn.apache.org/viewcvs/webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/c/ArrayParamWriter.java?rev=331554&r1=331553&r2=331554&view=diff
==============================================================================
--- webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/c/ArrayParamWriter.java (original)
+++ webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/c/ArrayParamWriter.java Mon Nov 7 09:36:47 2005
@@ -199,7 +199,7 @@
writer.write(
"\tstruct "
+ attribs[0].getTypeName()
- + "Tag * m_Array;\n\tint m_Size;\n} "
+ + "Tag * m_Array;\n\tint m_Size;\n\tAXISC_XSD_TYPE m_Type;\n} "
+ classname
+ ";\n\n");
}
Modified: webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/c/ClientStubWriter.java
URL: http://svn.apache.org/viewcvs/webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/c/ClientStubWriter.java?rev=331554&r1=331553&r2=331554&view=diff
==============================================================================
--- webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/c/ClientStubWriter.java (original)
+++ webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/c/ClientStubWriter.java Mon Nov 7 09:36:47 2005
@@ -267,7 +267,7 @@
if (returntypeisarray)
{
//for arrays
- writer.write(outparamTypeName + " RetArray = {NULL, 0};\n");
+ writer.write(outparamTypeName + " RetArray = {NULL, 0, XSD_UNKNOWN};\n");
}
else
if (!returntypeissimple)
Modified: webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/c/literal/ArrayParamWriter.java
URL: http://svn.apache.org/viewcvs/webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/c/literal/ArrayParamWriter.java?rev=331554&r1=331553&r2=331554&view=diff
==============================================================================
--- webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/c/literal/ArrayParamWriter.java (original)
+++ webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/c/literal/ArrayParamWriter.java Mon Nov 7 09:36:47 2005
@@ -66,7 +66,7 @@
writer.write(
"\tstruct "
+ attribs[0].getTypeName()
- + "Tag * m_Array;\n\tint m_Size;\n} "
+ + "Tag * m_Array;\n\tint m_Size;\n\tAXISC_XSDTYPE m_Type;\n} "
+ classname
+ ";\n\n");
}
Modified: webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/c/literal/ClientStubWriter.java
URL: http://svn.apache.org/viewcvs/webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/c/literal/ClientStubWriter.java?rev=331554&r1=331553&r2=331554&view=diff
==============================================================================
--- webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/c/literal/ClientStubWriter.java (original)
+++ webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/c/literal/ClientStubWriter.java Mon Nov 7 09:36:47 2005
@@ -246,7 +246,7 @@
if (returntypeisarray)
{
//for arrays
- writer.write(outparamType + " RetArray = {NULL, 0};\n");
+ writer.write(outparamType + " RetArray = {NULL, 0, XSD_UNKNOWN};\n");
}
else
{
Modified: webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/cpp/ArrayParamWriter.java
URL: http://svn.apache.org/viewcvs/webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/cpp/ArrayParamWriter.java?rev=331554&r1=331553&r2=331554&view=diff
==============================================================================
--- webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/cpp/ArrayParamWriter.java (original)
+++ webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/cpp/ArrayParamWriter.java Mon Nov 7 09:36:47 2005
@@ -192,7 +192,7 @@
writer.write(
"\t"
+ attribs[0].getTypeName()
- + stars + " m_Array;\n\tint m_Size;\n} "
+ + stars + " m_Array;\n\tint m_Size;\n\tXSDTYPE m_Type;\n} "
+ classname
+ ";\n\n");
}
Modified: webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/cpp/ClientStubWriter.java
URL: http://svn.apache.org/viewcvs/webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/cpp/ClientStubWriter.java?rev=331554&r1=331553&r2=331554&view=diff
==============================================================================
--- webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/cpp/ClientStubWriter.java (original)
+++ webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/cpp/ClientStubWriter.java Mon Nov 7 09:36:47 2005
@@ -309,7 +309,7 @@
if (returntypeisarray)
{
//for arrays
- writer.write(outparamTypeName + " RetArray = {NULL, 0};\n");
+ writer.write(outparamTypeName + " RetArray;\n");
}
else
{
@@ -618,8 +618,7 @@
+ "m_pCall->getBasicArray("
+ CUtils.getXSDTypeForBasicType(containedType) + ", \""
+ returntype.getParamName() + "\", 0);\n");
- writer
- .write("\t\t\t\tmemcpy(&RetArray,&RetAxisArray,sizeof(Axis_Array));\n\t\t\t}\n");
+ writer.write ("\t\t\t\tRetArray.clone(RetAxisArray);\n\t\t\t}\n");
}
else
{
@@ -633,8 +632,7 @@
+ ", (void*) Axis_GetSize_" + containedType + ", \""
+ returntype.getParamName() + "\", Axis_URI_"
+ containedType + ");\n");
- writer
- .write("\t\t\t\tmemcpy(&RetArray,&RetAxisArray,sizeof(Axis_Array));\n\t\t\t}\n");
+ writer.write ("\t\t\t\tRetArray.clone(RetAxisArray);\n\t\t\t}\n");
}
writer.write("\t\t}\n");
writer.write("\tm_pCall->unInitialize();\n");
Modified: webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/cpp/literal/ClientStubWriter.java
URL: http://svn.apache.org/viewcvs/webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/cpp/literal/ClientStubWriter.java?rev=331554&r1=331553&r2=331554&view=diff
==============================================================================
--- webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/cpp/literal/ClientStubWriter.java (original)
+++ webservices/axis/trunk/c/src/wsdl/org/apache/axis/wsdl/wsdl2ws/cpp/literal/ClientStubWriter.java Mon Nov 7 09:36:47 2005
@@ -380,8 +380,8 @@
writer.write ("\t");
if (returntypeisarray)
{
- //for arrays
- writer.write (outparamType + " RetArray = {NULL, 0};\n");
+ //for arrays
+ writer.write (outparamType + " RetArray;\n");
}
else
{
@@ -954,7 +954,7 @@
+ containedType
+ ");\n");
}
- writer.write ("\t\t\tmemcpy(&RetArray,&RetAxisArray,sizeof(Axis_Array));\n");
+ writer.write ("\t\t\tRetArray.clone(RetAxisArray);\n");
writer.write ("\t\t}\n");
writer.write ("\t}\n");
writer.write ("\tm_pCall->unInitialize();\n");
Added: webservices/axis/trunk/c/tests/auto_build/testcases/client/cpp/ArraysClient.cpp
URL: http://svn.apache.org/viewcvs/webservices/axis/trunk/c/tests/auto_build/testcases/client/cpp/ArraysClient.cpp?rev=331554&view=auto
==============================================================================
--- webservices/axis/trunk/c/tests/auto_build/testcases/client/cpp/ArraysClient.cpp (added)
+++ webservices/axis/trunk/c/tests/auto_build/testcases/client/cpp/ArraysClient.cpp Mon Nov 7 09:36:47 2005
@@ -0,0 +1,323 @@
+// Copyright 2003-2004 The Apache Software Foundation.
+// (c) Copyright IBM Corp. 2004, 2005 All Rights Reserved
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "Arrays.hpp"
+#include <axis/AxisException.hpp>
+#include <ctype.h>
+#include <iostream>
+#include <signal.h>
+
+void sig_handler(int);
+void PrintUsage();
+bool IsNumber(const char* p);
+
+void testAxis_Array();
+void testAxis_ArrayWithNillElements();
+void testAxis_ArrayCopying();
+
+int main(int argc, char* argv[])
+{
+ char endpoint[256];
+ const char* url="http://localhost:80/axis/Arrays";
+
+ signal(SIGILL, sig_handler);
+ signal(SIGABRT, sig_handler);
+ signal(SIGSEGV, sig_handler);
+ //signal(SIGQUIT, sig_handler);
+ //signal(SIGBUS, sig_handler);
+ signal(SIGFPE, sig_handler);
+
+ url = argv[1];
+
+ testAxis_Array();
+ testAxis_ArrayWithNillElements();
+ testAxis_ArrayCopying();
+
+ bool bSuccess = false;
+ int iRetryIterationCount = 3;
+ do
+ {
+ try
+ {
+ sprintf(endpoint, "%s", url);
+ Arrays ws(endpoint);
+
+ int arraySize = 3;
+ xsd__int_Array inputArray;
+ xsd__int** array = new xsd__int*[arraySize]();
+ for (int count = 0 ; count < arraySize ; count++)
+ {
+ array[count] = new xsd__int(count);
+ }
+ inputArray.set(array, arraySize);
+
+ xsd__int_Array outputArray = ws.SimpleArray(inputArray);
+ int outputSize = 0;
+ const xsd__int** output = outputArray.get(outputSize);
+ cout << "Array size = " << outputSize << endl;
+ if (output != NULL)
+ {
+ for (int count = 0 ; count < outputSize ; count++)
+ {
+ if (output[count] != NULL)
+ {
+ cout << *output[count] << endl;
+ }
+ else
+ {
+ cout << "NULL" << endl;
+ }
+ }
+ }
+ else
+ {
+ cout << "NULL array" << endl;
+ }
+
+ bSuccess = 1;
+ }
+ catch(AxisException& e)
+ {
+ bool bSilent = false;
+
+ if( e.getExceptionCode() == CLIENT_TRANSPORT_OPEN_CONNECTION_FAILED)
+ {
+ if( iRetryIterationCount > 0)
+ {
+ bSilent = true;
+ }
+ }
+ else
+ {
+ iRetryIterationCount = 0;
+ }
+
+ if( !bSilent)
+ {
+ cout << "Exception : " << e.what() << endl;
+ }
+ }
+ catch(exception& e)
+ {
+ cout << "Unexpected exception has occured: " << e.what() << endl;
+ }
+ catch(...)
+ {
+ cout << "Unknown exception has occured" << endl;
+ }
+ iRetryIterationCount--;
+ } while( iRetryIterationCount > 0 && !bSuccess);
+ cout<< "---------------------- TEST COMPLETE -----------------------------"<< endl;
+
+ return 0;
+}
+
+void PrintUsage()
+{
+ printf("Usage :\n Calculator <url>\n\n");
+ exit(1);
+}
+
+bool IsNumber(const char* p)
+{
+ for (int x=0; x < strlen(p); x++)
+ {
+ if (!isdigit(p[x])) return false;
+ }
+ return true;
+}
+
+void sig_handler(int sig) {
+ signal(sig, sig_handler);
+ cout << "SIGNAL RECEIVED " << sig << endl;
+ exit(1);
+}
+
+void testAxis_Array()
+{
+ // Unit test the Axis_Array object for simple types (in this case xsd__int)
+ // Initialize Array
+ int unitTestInputSize = 3;
+ xsd__int_Array unitTest_Axis_Array;
+ xsd__int** unitTestActualArray = new xsd__int*[unitTestInputSize]();
+ for (int count = 0 ; count < unitTestInputSize ; count++ )
+ {
+ unitTestActualArray[count] = new xsd__int(count);
+ }
+ unitTest_Axis_Array.set(unitTestActualArray, unitTestInputSize);
+
+ // Verify the correct data is available
+ int size;
+ const xsd__int** unitTestOutputArray = unitTest_Axis_Array.get(size);
+ cout << "Array size = " << size << endl;
+ if (unitTestOutputArray != NULL)
+ {
+ for (int count = 0 ; count < size ; count++)
+ {
+ if (unitTestOutputArray[count] != NULL)
+ {
+ cout << *unitTestOutputArray[count] << endl;
+ }
+ else
+ {
+ cout << "NULL" << endl;
+ }
+ }
+ }
+ else
+ {
+ cout << "NULL array" << endl;
+ }
+
+ // Alter the content of the original array, this should no longer affect the Axis_Array object
+ for (count = 0 ; count < unitTestInputSize ; count++ )
+ {
+ unitTestActualArray[count] = new xsd__int(count * 1000);
+ }
+
+ // Verify the correct data is available, and not the altered content
+ unitTestOutputArray = unitTest_Axis_Array.get(size);
+ cout << "Array size = " << size << endl;
+ if (unitTestOutputArray != NULL)
+ {
+ for (int count = 0 ; count < size ; count++)
+ {
+ if (unitTestOutputArray[count] != NULL)
+ {
+ cout << *unitTestOutputArray[count] << endl;
+ }
+ else
+ {
+ cout << "NULL" << endl;
+ }
+ }
+ }
+ else
+ {
+ cout << "NULL array" << endl;
+ }
+
+ // Delete the original array, this should not affect the Axis_Array
+ for (count = 0 ; count < unitTestInputSize ; count++)
+ {
+ delete unitTestActualArray[count];
+ }
+ delete [] unitTestActualArray;
+
+ // Verify the correct data is still available
+ unitTestOutputArray = unitTest_Axis_Array.get(size);
+ cout << "Array size = " << size << endl;
+ if (unitTestOutputArray != NULL)
+ {
+ for (int count = 0 ; count < size ; count++)
+ {
+ if (unitTestOutputArray[count] != NULL)
+ {
+ cout << *unitTestOutputArray[count] << endl;
+ }
+ else
+ {
+ cout << "NULL" << endl;
+ }
+ }
+ }
+ else
+ {
+ cout << "NULL array" << endl;
+ }
+}
+
+void testAxis_ArrayWithNillElements()
+{
+ // Unit test the Axis_Array object for simple types (in this case xsd__int) with a nil (NULL) element
+ // Initialize Array
+ int unitTestInputSize = 3;
+ xsd__int_Array unitTest_Axis_Array;
+ xsd__int** unitTestActualArray = new xsd__int*[unitTestInputSize]();
+ unitTestActualArray[0] = new xsd__int(12345);
+ unitTestActualArray[1] = NULL;
+ unitTestActualArray[2] = new xsd__int(54321);
+
+ unitTest_Axis_Array.set(unitTestActualArray, unitTestInputSize);
+
+ // Verify the correct data is available
+ int size;
+ const xsd__int** unitTestOutputArray = unitTest_Axis_Array.get(size);
+ cout << "Array size = " << size << endl;
+ if (unitTestOutputArray != NULL)
+ {
+ for (int count = 0 ; count < size ; count++)
+ {
+ if (unitTestOutputArray[count] != NULL)
+ {
+ cout << *unitTestOutputArray[count] << endl;
+ }
+ else
+ {
+ cout << "NULL" << endl;
+ }
+ }
+ }
+ else
+ {
+ cout << "NULL array" << endl;
+ }
+}
+
+void testAxis_ArrayCopying()
+{
+ int unitTestInputSize = 3;
+ xsd__int_Array unitTest_Axis_Array;
+ xsd__int** unitTestActualArray = new xsd__int*[unitTestInputSize]();
+ for (int count = 0 ; count < unitTestInputSize ; count++ )
+ {
+ unitTestActualArray[count] = new xsd__int(count);
+ }
+ unitTest_Axis_Array.set(unitTestActualArray, unitTestInputSize);
+
+ for (count = 0 ; count < unitTestInputSize ; count++ )
+ {
+ *unitTestActualArray[count] = count * 10;
+ }
+ unitTest_Axis_Array.set(unitTestActualArray, unitTestInputSize);
+
+ for (count = 0 ; count < unitTestInputSize ; count++);
+ {
+ delete unitTestActualArray[count];
+ }
+ delete [] unitTestActualArray;
+
+ int outputSize = 0;
+ const xsd__int** outputArray = unitTest_Axis_Array.get(outputSize);
+ cout << "Size is " << outputSize << endl;
+ if (outputArray != NULL)
+ {
+ for (int count = 0 ; count < outputSize ; count++)
+ {
+ if (outputArray[count] != NULL)
+ {
+ cout << *outputArray[count] << endl;
+ }
+ else
+ {
+ cout << "NULL" << endl;
+ }
+ }
+ }
+ else
+ {
+ cout << "NULL" << endl;
+ }
+}
\ No newline at end of file
Modified: webservices/axis/trunk/c/tests/auto_build/testcases/client/cpp/XSD_integerClient.cpp
URL: http://svn.apache.org/viewcvs/webservices/axis/trunk/c/tests/auto_build/testcases/client/cpp/XSD_integerClient.cpp?rev=331554&r1=331553&r2=331554&view=diff
==============================================================================
--- webservices/axis/trunk/c/tests/auto_build/testcases/client/cpp/XSD_integerClient.cpp (original)
+++ webservices/axis/trunk/c/tests/auto_build/testcases/client/cpp/XSD_integerClient.cpp Mon Nov 7 09:36:47 2005
@@ -110,26 +110,45 @@
delete optionalAttributeResult;
*/
- // Test array
- xsd__integer_Array arrayInput;
- arrayInput.m_Array = new xsd__integer*[2];
- xsd__integer * array = new xsd__integer[2];
- arrayInput.m_Size = 2;
- for (int inputIndex=0 ; inputIndex < 2 ; inputIndex++)
+ // Test arrays
+ int arraySize = 2;
+ xsd__integer_Array inputArray;
+ xsd__integer** array = new xsd__integer*[arraySize]();
+ for (int count = 0 ; count < arraySize ; count++)
{
- array[inputIndex] = 123456789;
- arrayInput.m_Array[inputIndex] = &array[inputIndex];
+ array[count] = new xsd__integer(123456789);
}
- xsd__integer_Array arrayResult = ws->asArray(arrayInput);
- cout << "array of " << arrayResult.m_Size << " elements" << endl;
- for (int index = 0; index < arrayResult.m_Size ; index++)
+ inputArray.set(array, arraySize);
+
+ xsd__integer_Array outputArray = ws->asArray(inputArray);
+ int outputSize = 0;
+ const xsd__integer** output = outputArray.get(outputSize);
+ cout << "array of " << outputSize << " elements" << endl;
+ if (output != NULL)
{
- cout << " element[" << index << "]=" << *((xsd__integer*)(arrayResult.m_Array[index])) << endl;
- delete arrayResult.m_Array[index];
+ for (int count = 0 ; count < outputSize ; count++)
+ {
+ cout << " element[" << count << "]=";
+ if (output[count] != NULL)
+ {
+ cout << *output[count] << endl;
+ }
+ else
+ {
+ cout << "NULL" << endl;
+ }
+ }
+ }
+ else
+ {
+ cout << "NULL array" << endl;
+ }
+ // Clear up input array
+ for (int deleteIndex = 0 ; deleteIndex < arraySize ; deleteIndex++ )
+ {
+ delete array[deleteIndex];
}
delete [] array;
- delete [] arrayInput.m_Array;
- delete [] arrayResult.m_Array;
// Test complex type
SimpleComplexType complexTypeInput;
Modified: webservices/axis/trunk/c/tests/auto_build/testcases/client/cpp/XSD_stringClient.cpp
URL: http://svn.apache.org/viewcvs/webservices/axis/trunk/c/tests/auto_build/testcases/client/cpp/XSD_stringClient.cpp?rev=331554&r1=331553&r2=331554&view=diff
==============================================================================
--- webservices/axis/trunk/c/tests/auto_build/testcases/client/cpp/XSD_stringClient.cpp (original)
+++ webservices/axis/trunk/c/tests/auto_build/testcases/client/cpp/XSD_stringClient.cpp Mon Nov 7 09:36:47 2005
@@ -295,39 +295,46 @@
delete optionalAttributeResult;
*/
- // Test array
- xsd__string_Array arrayInput;
- arrayInput.m_Array = new xsd__string[2];
- arrayInput.m_Size = 2;
- for (int inputIndex=0 ; inputIndex < 2 ; inputIndex++)
+ // Test arrays
+ int arraySize = 2;
+ xsd__string_Array inputArray;
+ xsd__string* array = new xsd__string[arraySize]();
+ for (int count = 0 ; count < arraySize ; count++)
{
- input = new char[25];
- strcpy (input, simpleString);
- arrayInput.m_Array[inputIndex] = input;
+ array[count] = new char[25];
+ strcpy (array[count], simpleString);
}
- xsd__string_Array arrayResult = ws->asArray(arrayInput);
- cout << "array of " << arrayResult.m_Size << " elements" << endl;
- for (int index = 0; index < arrayResult.m_Size ; index++)
+ inputArray.set(array, arraySize);
+
+ xsd__string_Array outputArray = ws->asArray(inputArray);
+ int outputSize = 0;
+ const xsd__string* output = outputArray.get(outputSize);
+ cout << "array of " << outputSize << " elements" << endl;
+ if (output != NULL)
{
- if (arrayResult.m_Array[index])
+ for (int count = 0 ; count < outputSize ; count++)
{
- if (*(arrayResult.m_Array[index]))
+ cout << " element[" << count << "]=";
+ if (output[count] != NULL)
{
- cout << " element[" << index << "]=" << arrayResult.m_Array[index] << endl;
+ cout << output[count] << endl;
}
else
{
- cout << " element[" << index << "]=<empty>" << endl;
+ cout << "NULL" << endl;
}
- delete arrayResult.m_Array[index];
- }
- else
- {
- cout << " element[" << index << "]=<nil>" << endl;
}
}
- delete [] arrayInput.m_Array;
- delete [] arrayResult.m_Array;
+ else
+ {
+ cout << "NULL array" << endl;
+ }
+ // Clear up input array
+ for (int deleteIndex = 0 ; deleteIndex < arraySize ; deleteIndex++ )
+ {
+ delete [] array[deleteIndex];
+ }
+ delete [] array;
// Test complex type
input = new char[25];
Added: webservices/axis/trunk/c/tests/auto_build/testcases/output/Arrays.cpp.out
URL: http://svn.apache.org/viewcvs/webservices/axis/trunk/c/tests/auto_build/testcases/output/Arrays.cpp.out?rev=331554&view=auto
==============================================================================
--- webservices/axis/trunk/c/tests/auto_build/testcases/output/Arrays.cpp.out (added)
+++ webservices/axis/trunk/c/tests/auto_build/testcases/output/Arrays.cpp.out Mon Nov 7 09:36:47 2005
@@ -0,0 +1,25 @@
+Array size = 3
+0
+1
+2
+Array size = 3
+0
+1
+2
+Array size = 3
+0
+1
+2
+Array size = 3
+12345
+NULL
+54321
+Size is 3
+0
+10
+20
+Array size = 3
+0
+1
+2
+---------------------- TEST COMPLETE -----------------------------
Added: webservices/axis/trunk/c/tests/auto_build/testcases/output/Arrays_ServerResponse.expected
URL: http://svn.apache.org/viewcvs/webservices/axis/trunk/c/tests/auto_build/testcases/output/Arrays_ServerResponse.expected?rev=331554&view=auto
==============================================================================
--- webservices/axis/trunk/c/tests/auto_build/testcases/output/Arrays_ServerResponse.expected (added)
+++ webservices/axis/trunk/c/tests/auto_build/testcases/output/Arrays_ServerResponse.expected Mon Nov 7 09:36:47 2005
@@ -0,0 +1,11 @@
+HTTP/1.1 200 OK
+Server: WebSphere Application Server/5.1
+Content-Type: text/xml; charset=utf-8
+Content-Language: en-GB
+Transfer-Encoding: chunked
+
+###
+<?xml version="1.0" encoding="utf-8"?>
+<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><soapenv:Header/><soapenv:Body><SimpleArrayResponse xmlns="http://org.apache.axis/Arrays/"><simpleType>0</simpleType><simpleType>1</simpleType><simpleType>2</simpleType></SimpleArrayResponse></soapenv:Body></soapenv:Envelope>
+0
+
Added: webservices/axis/trunk/c/tests/auto_build/testcases/tests/Arrays.xml
URL: http://svn.apache.org/viewcvs/webservices/axis/trunk/c/tests/auto_build/testcases/tests/Arrays.xml?rev=331554&view=auto
==============================================================================
--- webservices/axis/trunk/c/tests/auto_build/testcases/tests/Arrays.xml (added)
+++ webservices/axis/trunk/c/tests/auto_build/testcases/tests/Arrays.xml Mon Nov 7 09:36:47 2005
@@ -0,0 +1,12 @@
+<test>
+ <name>Arrays</name>
+ <description>Test arrays</description>
+ <clientLang>cpp</clientLang>
+ <clientCode>ArraysClient.cpp</clientCode>
+ <wsdl>Arrays.wsdl</wsdl>
+ <expected>
+ <output>Arrays.cpp.out</output>
+ <serverResponse>Arrays_ServerResponse.expected</serverResponse>
+ </expected>
+ <endpoint>http://localhost:80/axis/Arrays</endpoint>
+</test>
Added: webservices/axis/trunk/c/tests/auto_build/testcases/wsdls/Arrays.wsdl
URL: http://svn.apache.org/viewcvs/webservices/axis/trunk/c/tests/auto_build/testcases/wsdls/Arrays.wsdl?rev=331554&view=auto
==============================================================================
--- webservices/axis/trunk/c/tests/auto_build/testcases/wsdls/Arrays.wsdl (added)
+++ webservices/axis/trunk/c/tests/auto_build/testcases/wsdls/Arrays.wsdl Mon Nov 7 09:36:47 2005
@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wsdl:definitions xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
+ xmlns:tns="http://org.apache.axis/Arrays/"
+ xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
+ xmlns:xsd="http://www.w3.org/2001/XMLSchema" name="Arrays"
+ targetNamespace="http://org.apache.axis/Arrays/">
+ <wsdl:types>
+ <xsd:schema targetNamespace="http://org.apache.axis/Arrays/"
+ xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+ <xsd:element name="SimpleArrayResponse">
+ <xsd:complexType>
+ <xsd:sequence>
+ <xsd:element name="simpleType" type="xsd:int"
+ maxOccurs="unbounded" />
+ </xsd:sequence>
+ </xsd:complexType>
+ </xsd:element>
+ <xsd:element name="SimpleArrayRequest">
+ <xsd:complexType>
+ <xsd:sequence>
+ <xsd:element name="simpleType" type="xsd:int"
+ maxOccurs="unbounded" />
+ </xsd:sequence>
+ </xsd:complexType>
+ </xsd:element>
+ </xsd:schema>
+ </wsdl:types>
+ <wsdl:message name="SimpleArrayResponse">
+ <wsdl:part element="tns:SimpleArrayResponse"
+ name="SimpleArrayResponse" />
+ </wsdl:message>
+ <wsdl:message name="SimpleArrayRequest">
+ <wsdl:part element="tns:SimpleArrayRequest"
+ name="SimpleArrayRequest" />
+ </wsdl:message>
+ <wsdl:portType name="Arrays">
+ <wsdl:operation name="SimpleArray">
+ <wsdl:input message="tns:SimpleArrayRequest" />
+ <wsdl:output message="tns:SimpleArrayResponse" />
+ </wsdl:operation>
+ </wsdl:portType>
+ <wsdl:binding name="ArraysSOAP" type="tns:Arrays">
+ <soap:binding style="document"
+ transport="http://schemas.xmlsoap.org/soap/http" />
+ <wsdl:operation name="SimpleArray">
+ <soap:operation
+ soapAction="http://org.apache.axis/Arrays/NewOperation" />
+ <wsdl:input>
+ <soap:body use="literal" />
+ </wsdl:input>
+ <wsdl:output>
+ <soap:body use="literal" />
+ </wsdl:output>
+ </wsdl:operation>
+ </wsdl:binding>
+ <wsdl:service name="Arrays">
+ <wsdl:port binding="tns:ArraysSOAP" name="ArraysSOAP">
+ <soap:address location="http://localhost:80/axis/Arrays" />
+ </wsdl:port>
+ </wsdl:service>
+</wsdl:definitions>