axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From di...@apache.org
Subject 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/...
Date Mon, 07 Nov 2005 17:37:08 GMT
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>



Mime
View raw message