ws-axis-cvs mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nadira...@apache.org
Subject svn commit: r391481 - /webservices/axis/trunk/c/src/common/AxisUserAPI.cpp
Date Wed, 05 Apr 2006 04:04:56 GMT
Author: nadiramra
Date: Tue Apr  4 21:04:55 2006
New Revision: 391481

URL: http://svn.apache.org/viewcvs?rev=391481&view=rev
Log:
Format code so more readable - align braces, etc.

Modified:
    webservices/axis/trunk/c/src/common/AxisUserAPI.cpp

Modified: webservices/axis/trunk/c/src/common/AxisUserAPI.cpp
URL: http://svn.apache.org/viewcvs/webservices/axis/trunk/c/src/common/AxisUserAPI.cpp?rev=391481&r1=391480&r2=391481&view=diff
==============================================================================
--- webservices/axis/trunk/c/src/common/AxisUserAPI.cpp (original)
+++ webservices/axis/trunk/c/src/common/AxisUserAPI.cpp Tue Apr  4 21:04:55 2006
@@ -44,53 +44,50 @@
 
 xsd__base64Binary::xsd__base64Binary(const xsd__base64Binary & original)
 {
-	__ptr = NULL;
-	__size = 0;
-	*this = original;
+    __ptr = NULL;
+    __size = 0;
+    *this = original;
 }
 
 void xsd__base64Binary::set(xsd__unsignedByte * data, int size)
 {
-	if (__ptr != NULL)
-	{
-		delete [] __ptr;
-	}
-	if (size > 0)
-	{
-		__ptr = new xsd__unsignedByte[size + 1];
-		memcpy(__ptr, data, size * sizeof(xsd__unsignedByte));
-		__ptr[size] = '\0';
-	}
-	else
-	{
-		__ptr = NULL;
-	}
-	__size = size;
+    if (__ptr != NULL)
+        delete [] __ptr;
+
+    if (size > 0)
+    {
+        __ptr = new xsd__unsignedByte[size + 1];
+        memcpy(__ptr, data, size * sizeof(xsd__unsignedByte));
+        __ptr[size] = '\0';
+    }
+    else
+        __ptr = NULL;
+
+    __size = size;
 }
 
 xsd__int xsd__base64Binary::getSize() const
 {
-	return __size;
+    return __size;
 }
 
 xsd__unsignedByte * xsd__base64Binary::get(xsd__int & size) const
 {
-	size = __size;
+    size = __size;
     return __ptr;
 }
 
 xsd__base64Binary & xsd__base64Binary::operator=(const xsd__base64Binary & original)
 {
-	this->set(original.__ptr, original.__size);
+    this->set(original.__ptr, original.__size);
     return *this;
 }
 
 xsd__base64Binary::~xsd__base64Binary()
 {
     if (__ptr != NULL)
-    {
         delete [] __ptr;
-    }
+
     __ptr = NULL;
     __size = 0;
 }
@@ -111,19 +108,17 @@
 void xsd__hexBinary::set(xsd__unsignedByte * data, int size)
 {
     if (__ptr != NULL)
-    {
         delete [] __ptr;
-    }
+
     if (size > 0)
     {
         __ptr = new xsd__unsignedByte[size + 1];
         memcpy(__ptr, data, size * sizeof(xsd__unsignedByte));
-		__ptr[size] = '\0';
+        __ptr[size] = '\0';
     }
     else
-    {
         __ptr = NULL;
-    }
+
     __size = size;
 }
 
@@ -147,19 +142,20 @@
 xsd__hexBinary::~xsd__hexBinary()
 {
     if (__ptr != NULL)
-    {
         delete [] __ptr;
-    }
+
     __ptr = NULL;
     __size = 0;
 }
 
-AnyType::AnyType() { 
+AnyType::AnyType() 
+{ 
   _array = 0;
   _size = 0;
 }
 
-AnyType::~AnyType() { 
+AnyType::~AnyType() 
+{ 
 }
 
 Axis_Array::Axis_Array()
@@ -193,308 +189,304 @@
 {
     clear();
     m_Size = size;
+    m_Array = NULL;
     m_Type = type;
     m_belongsToAxisEngine = true;
     
     if (size == 0)
+        return;
+
+    m_Array = new void*[m_Size];
+
+    for (int count = 0 ; count < m_Size ; count++)
     {
-        m_Array = NULL;
-    }
-    else
-    {
-        m_Array = new void*[m_Size];
-    
-        for (int count = 0 ; count < m_Size ; count++)
+        if ( array[count] == NULL)
         {
-            if ( array[count] == NULL)
+            m_Array[count] = NULL;
+            continue;
+        }
+
+        switch (m_Type)
+        {
+            case XSD_DURATION:
             {
-                m_Array[count] = NULL;
+                ((xsd__duration**) m_Array)[count] = new xsd__duration();
+                *((xsd__duration**)m_Array)[count] = *((xsd__duration**) array)[count];
+                break;
             }
-            else
+            case XSD_DATETIME:
             {
-                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**) m_Array)[count] = new xsd__base64Binary();
-						*((xsd__base64Binary**)m_Array)[count] = *((xsd__base64Binary**) array)[count];
-                        break;
-                    }
-                    case XSD_HEXBINARY:
-                    {
-						((xsd__hexBinary**) m_Array)[count] = new xsd__hexBinary();
-						*((xsd__hexBinary**)m_Array)[count] = *((xsd__hexBinary**) array)[count];
-                        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;
-                }
+                ((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**) m_Array)[count] = new xsd__base64Binary();
+                *((xsd__base64Binary**)m_Array)[count] = *((xsd__base64Binary**) array)[count];
+                break;
+            }
+            case XSD_HEXBINARY:
+            {
+                ((xsd__hexBinary**) m_Array)[count] = new xsd__hexBinary();
+                *((xsd__hexBinary**)m_Array)[count] = *((xsd__hexBinary**) array)[count];
+                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;
+        } // end switch
+    } // end for loop
 }
 
 void** Axis_Array::get(int& size, XSDTYPE& type) const
@@ -509,20 +501,16 @@
 {
     void** temp = new void*[m_Size+1];
     for (int count = 0 ; count < m_Size ; count++ )
-    {
         temp[count] = m_Array[count];
-    }
+
     if (m_Array != NULL)
-    {
         delete [] m_Array;
-    }
+
     m_Array = temp;
     m_belongsToAxisEngine = true;
  
     if ( element == NULL)
-    {
         m_Array[m_Size] = NULL;
-    }
     else
     {
         switch (m_Type)
@@ -667,14 +655,14 @@
             }
             case XSD_BASE64BINARY:
             {
-				((xsd__base64Binary**) m_Array)[m_Size] = new xsd__base64Binary();
-				*((xsd__base64Binary**)m_Array)[m_Size] = *(xsd__base64Binary*) element;
+                ((xsd__base64Binary**) m_Array)[m_Size] = new xsd__base64Binary();
+                *((xsd__base64Binary**)m_Array)[m_Size] = *(xsd__base64Binary*) element;
                 break;
             }
             case XSD_HEXBINARY:
             {
-				((xsd__hexBinary**) m_Array)[m_Size] = new xsd__hexBinary();
-				*((xsd__hexBinary**)m_Array)[m_Size] = *(xsd__hexBinary*) element;
+                ((xsd__hexBinary**) m_Array)[m_Size] = new xsd__hexBinary();
+                *((xsd__hexBinary**)m_Array)[m_Size] = *(xsd__hexBinary*) element;
                 break;
             }
             case XSD_FLOAT:
@@ -816,261 +804,261 @@
 
 void Axis_Array::clear()
 { 
-    if (m_Array != NULL)
+    if (m_Array == NULL)
+        return;
+
+    if (m_Size > 0)
     {
-        if (m_Size > 0)
+        for (int count = 0 ; count < m_Size ; count++)
         {
-            for (int count = 0 ; count < m_Size ; count++)
+            if (m_Array[count] != NULL)
             {
-                if (m_Array[count] != NULL)
+                switch (m_Type)
                 {
-                    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:
                     {
-                        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;
+                        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;
-        }
-        if (m_belongsToAxisEngine == true)
-        {
-            delete [] m_Array;
-        }
-        else
-        {   // Warning!!  This could introduce memory leaks if used incorrectly!!!
-            m_Array = NULL;
-            m_belongsToAxisEngine = true;
+            }
         }
+        m_Size = 0;
+    }
+    
+    if (m_belongsToAxisEngine == true)
+        delete [] m_Array;
+    else
+    {   
+    	// Warning!!  This could introduce memory leaks if used incorrectly!!!
+        m_Array = NULL;
+        m_belongsToAxisEngine = true;
     }
 }
 
@@ -1082,9 +1070,7 @@
 xsd__duration_Array::xsd__duration_Array(const xsd__duration_Array & original)
 {
     if (original.m_Type == XSD_DURATION)
-    {
         clone(original);
-    }
 }
 
 xsd__duration_Array::~xsd__duration_Array()
@@ -1094,12 +1080,12 @@
 
 void xsd__duration_Array::set(xsd__duration** array, int size)
 {
-	Axis_Array::set((void**)array, size, XSD_DURATION);
+    Axis_Array::set((void**)array, size, XSD_DURATION);
 }
 
 const xsd__duration** xsd__duration_Array::get(int& size) const
 {
-	XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__duration**) Axis_Array::get(size, type);
 }
 
@@ -1111,9 +1097,7 @@
 xsd__dateTime_Array::xsd__dateTime_Array(const xsd__dateTime_Array & original)
 {
     if (original.m_Type == XSD_DATETIME)
-    {
         clone(original);
-    }
 }
 
 xsd__dateTime_Array::~xsd__dateTime_Array()
@@ -1123,12 +1107,12 @@
 
 void xsd__dateTime_Array::set(xsd__dateTime** array, int size)
 {
-   Axis_Array::set((void**)array, size, XSD_DATETIME);
+    Axis_Array::set((void**)array, size, XSD_DATETIME);
 }
 
 const xsd__dateTime** xsd__dateTime_Array::get(int& size) const
 {
-  XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__dateTime**) Axis_Array::get(size, type);
 }
 
@@ -1140,9 +1124,7 @@
 xsd__time_Array::xsd__time_Array(const xsd__time_Array & original)
 {
     if (original.m_Type == XSD_TIME)
-    {
         clone(original);
-    }
 }
 
 xsd__time_Array::~xsd__time_Array()
@@ -1152,12 +1134,12 @@
 
 void xsd__time_Array::set(xsd__time** array, int size)
 {
-   Axis_Array::set((void**)array, size, XSD_TIME);
+    Axis_Array::set((void**)array, size, XSD_TIME);
 }
 
 const xsd__time** xsd__time_Array::get(int& size) const
 {
-  XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__time**) Axis_Array::get(size, type);
 }
 
@@ -1169,9 +1151,7 @@
 xsd__date_Array::xsd__date_Array(const xsd__date_Array & original)
 {
     if (original.m_Type == XSD_DATE)
-    {
         clone(original);
-    }
 }
 
 xsd__date_Array::~xsd__date_Array()
@@ -1181,12 +1161,12 @@
 
 void xsd__date_Array::set(xsd__date** array, int size)
 {
-   Axis_Array::set((void**)array, size, XSD_DATE);
+    Axis_Array::set((void**)array, size, XSD_DATE);
 }
 
 const xsd__date** xsd__date_Array::get(int& size) const
 {
-  XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__date**) Axis_Array::get(size, type);
 }
 
@@ -1198,9 +1178,7 @@
 xsd__gYearMonth_Array::xsd__gYearMonth_Array(const xsd__gYearMonth_Array & original)
 {
     if (original.m_Type == XSD_GYEARMONTH)
-    {
         clone(original);
-    }
 }
 
 xsd__gYearMonth_Array::~xsd__gYearMonth_Array()
@@ -1210,12 +1188,12 @@
 
 void xsd__gYearMonth_Array::set(xsd__gYearMonth** array, int size)
 {
-   Axis_Array::set((void**)array, size, XSD_GYEARMONTH);
+    Axis_Array::set((void**)array, size, XSD_GYEARMONTH);
 }
 
 const xsd__gYearMonth** xsd__gYearMonth_Array::get(int& size) const
 {
-  XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__gYearMonth**) Axis_Array::get(size, type);
 }
 
@@ -1227,9 +1205,7 @@
 xsd__gYear_Array::xsd__gYear_Array(const xsd__gYear_Array & original)
 {
     if (original.m_Type == XSD_GYEAR)
-    {
         clone(original);
-    }
 }
 
 xsd__gYear_Array::~xsd__gYear_Array()
@@ -1239,12 +1215,12 @@
 
 void xsd__gYear_Array::set(xsd__gYear** array, int size)
 {
-   Axis_Array::set((void**)array, size, XSD_GYEAR);
+    Axis_Array::set((void**)array, size, XSD_GYEAR);
 }
 
 const xsd__gYear** xsd__gYear_Array::get(int& size) const
 {
-  XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__gYear**) Axis_Array::get(size, type);
 }
 
@@ -1256,9 +1232,7 @@
 xsd__gMonthDay_Array::xsd__gMonthDay_Array(const xsd__gMonthDay_Array & original)
 {
     if (original.m_Type == XSD_GMONTHDAY)
-    {
         clone(original);
-    }
 }
 
 xsd__gMonthDay_Array::~xsd__gMonthDay_Array()
@@ -1268,12 +1242,12 @@
 
 void xsd__gMonthDay_Array::set(xsd__gMonthDay** array, int size)
 {
-   Axis_Array::set((void**)array, size, XSD_GMONTHDAY);
+    Axis_Array::set((void**)array, size, XSD_GMONTHDAY);
 }
 
 const xsd__gMonthDay** xsd__gMonthDay_Array::get(int& size) const
 {
-  XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__gMonthDay**) Axis_Array::get(size, type);
 }
 
@@ -1285,9 +1259,7 @@
 xsd__gMonth_Array::xsd__gMonth_Array(const xsd__gMonth_Array & original)
 {
     if (original.m_Type == XSD_GMONTH)
-    {
         clone(original);
-    }
 }
 
 xsd__gMonth_Array::~xsd__gMonth_Array()
@@ -1297,12 +1269,12 @@
 
 void xsd__gMonth_Array::set(xsd__gMonth** array, int size)
 {
-   Axis_Array::set((void**)array, size, XSD_GMONTH);
+    Axis_Array::set((void**)array, size, XSD_GMONTH);
 }
 
 const xsd__gMonth** xsd__gMonth_Array::get(int& size) const
 {
-  XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__gMonth**) Axis_Array::get(size, type);
 }
 
@@ -1314,9 +1286,7 @@
 xsd__gDay_Array::xsd__gDay_Array(const xsd__gDay_Array & original)
 {
     if (original.m_Type == XSD_GDAY)
-    {
         clone(original);
-    }
 }
 
 xsd__gDay_Array::~xsd__gDay_Array()
@@ -1326,12 +1296,12 @@
 
 void xsd__gDay_Array::set(xsd__gDay** array, int size)
 {
-   Axis_Array::set((void**)array, size, XSD_GDAY);
+    Axis_Array::set((void**)array, size, XSD_GDAY);
 }
 
 const xsd__gDay** xsd__gDay_Array::get(int& size) const
 {
-  XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__gDay**) Axis_Array::get(size, type);
 }
 
@@ -1343,9 +1313,7 @@
 xsd__string_Array::xsd__string_Array(const xsd__string_Array & original)
 {
     if (original.m_Type == XSD_STRING)
-    {
         clone(original);
-    }
 }
 
 xsd__string_Array::~xsd__string_Array()
@@ -1355,7 +1323,7 @@
 
 void xsd__string_Array::set(xsd__string* array, int size)
 {
- Axis_Array::set((void**)array, size, XSD_STRING);
+    Axis_Array::set((void**)array, size, XSD_STRING);
 }
 
 const xsd__string* xsd__string_Array::get(int& size) const
@@ -1372,9 +1340,7 @@
 xsd__normalizedString_Array::xsd__normalizedString_Array(const xsd__normalizedString_Array & original)
 {
     if (original.m_Type == XSD_NORMALIZEDSTRING)
-    {
         clone(original);
-    }
 }
 
 xsd__normalizedString_Array::~xsd__normalizedString_Array()
@@ -1384,7 +1350,7 @@
 
 void xsd__normalizedString_Array::set(xsd__normalizedString* array, int size)
 {
- Axis_Array::set((void**)array, size, XSD_NORMALIZEDSTRING);
+    Axis_Array::set((void**)array, size, XSD_NORMALIZEDSTRING);
 }
 
 const xsd__normalizedString* xsd__normalizedString_Array::get(int& size) const
@@ -1401,9 +1367,7 @@
 xsd__token_Array::xsd__token_Array(const xsd__token_Array & original)
 {
     if (original.m_Type == XSD_TOKEN)
-    {
         clone(original);
-    }
 }
 
 xsd__token_Array::~xsd__token_Array()
@@ -1430,9 +1394,7 @@
 xsd__language_Array::xsd__language_Array(const xsd__language_Array & original)
 {
     if (original.m_Type == XSD_LANGUAGE)
-    {
         clone(original);
-    }
 }
 
 xsd__language_Array::~xsd__language_Array()
@@ -1442,7 +1404,7 @@
 
 void xsd__language_Array::set(xsd__language* array, int size)
 {
- Axis_Array::set((void**)array, size, XSD_LANGUAGE);
+    Axis_Array::set((void**)array, size, XSD_LANGUAGE);
 }
 
 const xsd__language* xsd__language_Array::get(int& size) const
@@ -1459,9 +1421,7 @@
 xsd__Name_Array::xsd__Name_Array(const xsd__Name_Array & original)
 {
     if (original.m_Type == XSD_NAME)
-    {
         clone(original);
-    }
 }
 
 xsd__Name_Array::~xsd__Name_Array()
@@ -1488,9 +1448,7 @@
 xsd__NCName_Array::xsd__NCName_Array(const xsd__NCName_Array & original)
 {
     if (original.m_Type == XSD_NCNAME)
-    {
         clone(original);
-    }
 }
 
 xsd__NCName_Array::~xsd__NCName_Array()
@@ -1517,9 +1475,7 @@
 xsd__ID_Array::xsd__ID_Array(const xsd__ID_Array & original)
 {
     if (original.m_Type == XSD_ID)
-    {
         clone(original);
-    }
 }
 
 xsd__ID_Array::~xsd__ID_Array()
@@ -1546,9 +1502,7 @@
 xsd__IDREF_Array::xsd__IDREF_Array(const xsd__IDREF_Array & original)
 {
     if (original.m_Type == XSD_IDREF)
-    {
         clone(original);
-    }
 }
 
 xsd__IDREF_Array::~xsd__IDREF_Array()
@@ -1575,9 +1529,7 @@
 xsd__IDREFS_Array::xsd__IDREFS_Array(const xsd__IDREFS_Array & original)
 {
     if (original.m_Type == XSD_IDREFS)
-    {
         clone(original);
-    }
 }
 
 xsd__IDREFS_Array::~xsd__IDREFS_Array()
@@ -1604,9 +1556,7 @@
 xsd__ENTITY_Array::xsd__ENTITY_Array(const xsd__ENTITY_Array & original)
 {
     if (original.m_Type == XSD_ENTITY)
-    {
         clone(original);
-    }
 }
 
 xsd__ENTITY_Array::~xsd__ENTITY_Array()
@@ -1633,9 +1583,7 @@
 xsd__ENTITIES_Array::xsd__ENTITIES_Array(const xsd__ENTITIES_Array & original)
 {
     if (original.m_Type == XSD_ENTITIES)
-    {
         clone(original);
-    }
 }
 
 xsd__ENTITIES_Array::~xsd__ENTITIES_Array()
@@ -1662,9 +1610,7 @@
 xsd__NMTOKEN_Array::xsd__NMTOKEN_Array(const xsd__NMTOKEN_Array & original)
 {
     if (original.m_Type == XSD_NMTOKEN)
-    {
         clone(original);
-    }
 }
 
 xsd__NMTOKEN_Array::~xsd__NMTOKEN_Array()
@@ -1691,9 +1637,7 @@
 xsd__NMTOKENS_Array::xsd__NMTOKENS_Array(const xsd__NMTOKENS_Array & original)
 {
     if (original.m_Type == XSD_NMTOKEN)
-    {
         clone(original);
-    }
 }
 
 xsd__NMTOKENS_Array::~xsd__NMTOKENS_Array()
@@ -1720,9 +1664,7 @@
 xsd__boolean_Array::xsd__boolean_Array(const xsd__boolean_Array & original)
 {
     if (original.m_Type == XSD_BOOLEAN)
-    {
         clone(original);
-    }
 }
 
 xsd__boolean_Array::~xsd__boolean_Array()
@@ -1732,12 +1674,12 @@
 
 void xsd__boolean_Array::set(xsd__boolean** array, int size)
 {
-	Axis_Array::set((void**)array, size, XSD_BOOLEAN);
+    Axis_Array::set((void**)array, size, XSD_BOOLEAN);
 }
 
 const xsd__boolean** xsd__boolean_Array::get(int& size) const
 {
-	XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__boolean**) Axis_Array::get(size, type);
 }
 
@@ -1749,9 +1691,7 @@
 xsd__base64Binary_Array::xsd__base64Binary_Array(const xsd__base64Binary_Array & original)
 {
     if (original.m_Type == XSD_BASE64BINARY)
-    {
         clone(original);
-    }
 }
 
 xsd__base64Binary_Array::~xsd__base64Binary_Array()
@@ -1761,12 +1701,12 @@
 
 void xsd__base64Binary_Array::set(xsd__base64Binary** array, int size)
 {
-	Axis_Array::set((void**)array, size, XSD_BASE64BINARY);
+    Axis_Array::set((void**)array, size, XSD_BASE64BINARY);
 }
 
 const xsd__base64Binary** xsd__base64Binary_Array::get(int& size) const
 {
-	XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__base64Binary**) Axis_Array::get(size, type);
 }
 
@@ -1778,9 +1718,7 @@
 xsd__hexBinary_Array::xsd__hexBinary_Array(const xsd__hexBinary_Array & original)
 {
     if (original.m_Type == XSD_HEXBINARY)
-    {
         clone(original);
-    }
 }
 
 xsd__hexBinary_Array::~xsd__hexBinary_Array()
@@ -1790,12 +1728,12 @@
 
 void xsd__hexBinary_Array::set(xsd__hexBinary** array, int size)
 {
-	Axis_Array::set((void**)array, size, XSD_HEXBINARY);
+    Axis_Array::set((void**)array, size, XSD_HEXBINARY);
 }
 
 const xsd__hexBinary** xsd__hexBinary_Array::get(int& size) const
 {
-	XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__hexBinary**) Axis_Array::get(size, type);
 }
 
@@ -1807,9 +1745,7 @@
 xsd__float_Array::xsd__float_Array(const xsd__float_Array & original)
 {
     if (original.m_Type == XSD_FLOAT)
-    {
         clone(original);
-    }
 }
 
 xsd__float_Array::~xsd__float_Array()
@@ -1819,12 +1755,12 @@
 
 void xsd__float_Array::set(xsd__float** array, int size)
 {
-	Axis_Array::set((void**)array, size, XSD_FLOAT);
+    Axis_Array::set((void**)array, size, XSD_FLOAT);
 }
 
 const xsd__float** xsd__float_Array::get(int& size) const
 {
-	XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__float**) Axis_Array::get(size, type);
 }
 
@@ -1836,9 +1772,7 @@
 xsd__decimal_Array::xsd__decimal_Array(const xsd__decimal_Array & original)
 {
     if (original.m_Type == XSD_DECIMAL)
-    {
         clone(original);
-    }
 }
 
 xsd__decimal_Array::~xsd__decimal_Array()
@@ -1848,12 +1782,12 @@
 
 void xsd__decimal_Array::set(xsd__decimal** array, int size)
 {
-	Axis_Array::set((void**)array, size, XSD_DECIMAL);
+    Axis_Array::set((void**)array, size, XSD_DECIMAL);
 }
 
 const xsd__decimal** xsd__decimal_Array::get(int& size) const
 {
-	XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__decimal**) Axis_Array::get(size, type);
 }
 
@@ -1865,9 +1799,7 @@
 xsd__integer_Array::xsd__integer_Array(const xsd__integer_Array & original)
 {
     if (original.m_Type == XSD_INTEGER)
-    {
         clone(original);
-    }
 }
 
 xsd__integer_Array::~xsd__integer_Array()
@@ -1877,12 +1809,12 @@
 
 void xsd__integer_Array::set(xsd__integer** array, int size)
 {
-	Axis_Array::set((void**)array, size, XSD_INTEGER);
+    Axis_Array::set((void**)array, size, XSD_INTEGER);
 }
 
 const xsd__integer** xsd__integer_Array::get(int& size) const
 {
-	XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__integer**) Axis_Array::get(size, type);
 }
 
@@ -1894,9 +1826,7 @@
 xsd__nonPositiveInteger_Array::xsd__nonPositiveInteger_Array(const xsd__nonPositiveInteger_Array & original)
 {
     if (original.m_Type == XSD_NONPOSITIVEINTEGER)
-    {
         clone(original);
-    }
 }
 
 xsd__nonPositiveInteger_Array::~xsd__nonPositiveInteger_Array()
@@ -1906,12 +1836,12 @@
 
 void xsd__nonPositiveInteger_Array::set(xsd__nonPositiveInteger** array, int size)
 {
-	Axis_Array::set((void**)array, size, XSD_NONPOSITIVEINTEGER);
+    Axis_Array::set((void**)array, size, XSD_NONPOSITIVEINTEGER);
 }
 
 const xsd__nonPositiveInteger** xsd__nonPositiveInteger_Array::get(int& size) const
 {
-	XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__nonPositiveInteger**) Axis_Array::get(size, type);
 }
 
@@ -1923,9 +1853,7 @@
 xsd__negativeInteger_Array::xsd__negativeInteger_Array(const xsd__negativeInteger_Array & original)
 {
     if (original.m_Type == XSD_NEGATIVEINTEGER)
-    {
         clone(original);
-    }
 }
 
 xsd__negativeInteger_Array::~xsd__negativeInteger_Array()
@@ -1935,12 +1863,12 @@
 
 void xsd__negativeInteger_Array::set(xsd__negativeInteger** array, int size)
 {
-	Axis_Array::set((void**)array, size, XSD_NEGATIVEINTEGER);
+    Axis_Array::set((void**)array, size, XSD_NEGATIVEINTEGER);
 }
 
 const xsd__negativeInteger** xsd__negativeInteger_Array::get(int& size) const
 {
-	XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__negativeInteger**) Axis_Array::get(size, type);
 }
 
@@ -1952,9 +1880,7 @@
 xsd__long_Array::xsd__long_Array(const xsd__long_Array & original)
 {
     if (original.m_Type == XSD_LONG)
-    {
         clone(original);
-    }
 }
 
 xsd__long_Array::~xsd__long_Array()
@@ -1964,12 +1890,12 @@
 
 void xsd__long_Array::set(xsd__long** array, int size)
 {
-	Axis_Array::set((void**)array, size, XSD_LONG);
+    Axis_Array::set((void**)array, size, XSD_LONG);
 }
 
 const xsd__long** xsd__long_Array::get(int& size) const
 {
-	XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__long**) Axis_Array::get(size, type);
 }
 
@@ -1981,9 +1907,7 @@
 xsd__int_Array::xsd__int_Array(const xsd__int_Array & original)
 {
     if (original.m_Type == XSD_INT)
-    {
         clone(original);
-    }
 }
 
 xsd__int_Array::~xsd__int_Array()
@@ -1993,12 +1917,12 @@
 
 void xsd__int_Array::set(xsd__int** array, int size)
 {
-	Axis_Array::set((void**)array, size, XSD_INT);
+    Axis_Array::set((void**)array, size, XSD_INT);
 }
 
 const xsd__int** xsd__int_Array::get(int& size) const
 {
-	XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__int**) Axis_Array::get(size, type);
 }
 
@@ -2010,9 +1934,7 @@
 xsd__short_Array::xsd__short_Array(const xsd__short_Array & original)
 {
     if (original.m_Type == XSD_SHORT)
-    {
         clone(original);
-    }
 }
 
 xsd__short_Array::~xsd__short_Array()
@@ -2022,12 +1944,12 @@
 
 void xsd__short_Array::set(xsd__short** array, int size)
 {
-	Axis_Array::set((void**)array, size, XSD_SHORT);
+    Axis_Array::set((void**)array, size, XSD_SHORT);
 }
 
 const xsd__short** xsd__short_Array::get(int& size) const
 {
-	XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__short**) Axis_Array::get(size, type);
 }
 
@@ -2039,9 +1961,7 @@
 xsd__byte_Array::xsd__byte_Array(const xsd__byte_Array & original)
 {
     if (original.m_Type == XSD_BYTE)
-    {
         clone(original);
-    }
 }
 
 xsd__byte_Array::~xsd__byte_Array()
@@ -2051,12 +1971,12 @@
 
 void xsd__byte_Array::set(xsd__byte** array, int size)
 {
-	Axis_Array::set((void**)array, size, XSD_BYTE);
+    Axis_Array::set((void**)array, size, XSD_BYTE);
 }
 
 const xsd__byte** xsd__byte_Array::get(int& size) const
 {
-	XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__byte**) Axis_Array::get(size, type);
 }
 
@@ -2068,9 +1988,7 @@
 xsd__nonNegativeInteger_Array::xsd__nonNegativeInteger_Array(const xsd__nonNegativeInteger_Array & original)
 {
     if (original.m_Type == XSD_NONNEGATIVEINTEGER)
-    {
         clone(original);
-    }
 }
 
 xsd__nonNegativeInteger_Array::~xsd__nonNegativeInteger_Array()
@@ -2080,12 +1998,12 @@
 
 void xsd__nonNegativeInteger_Array::set(xsd__nonNegativeInteger** array, int size)
 {
-	Axis_Array::set((void**)array, size, XSD_NONNEGATIVEINTEGER);
+    Axis_Array::set((void**)array, size, XSD_NONNEGATIVEINTEGER);
 }
 
 const xsd__nonNegativeInteger** xsd__nonNegativeInteger_Array::get(int& size) const
 {
-	XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__nonNegativeInteger**) Axis_Array::get(size, type);
 }
 
@@ -2097,9 +2015,7 @@
 xsd__unsignedLong_Array::xsd__unsignedLong_Array(const xsd__unsignedLong_Array & original)
 {
     if (original.m_Type == XSD_UNSIGNEDLONG)
-    {
         clone(original);
-    }
 }
 
 xsd__unsignedLong_Array::~xsd__unsignedLong_Array()
@@ -2109,12 +2025,12 @@
 
 void xsd__unsignedLong_Array::set(xsd__unsignedLong** array, int size)
 {
-	Axis_Array::set((void**)array, size, XSD_UNSIGNEDLONG);
+    Axis_Array::set((void**)array, size, XSD_UNSIGNEDLONG);
 }
 
 const xsd__unsignedLong** xsd__unsignedLong_Array::get(int& size) const
 {
-	XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__unsignedLong**) Axis_Array::get(size, type);
 }
 
@@ -2126,9 +2042,7 @@
 xsd__unsignedInt_Array::xsd__unsignedInt_Array(const xsd__unsignedInt_Array & original)
 {
     if (original.m_Type == XSD_UNSIGNEDINT)
-    {
         clone(original);
-    }
 }
 
 xsd__unsignedInt_Array::~xsd__unsignedInt_Array()
@@ -2138,12 +2052,12 @@
 
 void xsd__unsignedInt_Array::set(xsd__unsignedInt** array, int size)
 {
-	Axis_Array::set((void**)array, size, XSD_UNSIGNEDINT);
+    Axis_Array::set((void**)array, size, XSD_UNSIGNEDINT);
 }
 
 const xsd__unsignedInt** xsd__unsignedInt_Array::get(int& size) const
 {
-	XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__unsignedInt**) Axis_Array::get(size, type);
 }
 
@@ -2155,9 +2069,7 @@
 xsd__unsignedShort_Array::xsd__unsignedShort_Array(const xsd__unsignedShort_Array & original)
 {
     if (original.m_Type == XSD_UNSIGNEDSHORT)
-    {
         clone(original);
-    }
 }
 
 xsd__unsignedShort_Array::~xsd__unsignedShort_Array()
@@ -2167,12 +2079,12 @@
 
 void xsd__unsignedShort_Array::set(xsd__unsignedShort** array, int size)
 {
-	Axis_Array::set((void**)array, size, XSD_UNSIGNEDSHORT);
+    Axis_Array::set((void**)array, size, XSD_UNSIGNEDSHORT);
 }
 
 const xsd__unsignedShort** xsd__unsignedShort_Array::get(int& size) const
 {
-	XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__unsignedShort**) Axis_Array::get(size, type);
 }
 
@@ -2184,9 +2096,7 @@
 xsd__unsignedByte_Array::xsd__unsignedByte_Array(const xsd__unsignedByte_Array & original)
 {
     if (original.m_Type == XSD_UNSIGNEDBYTE)
-    {
         clone(original);
-    }
 }
 
 xsd__unsignedByte_Array::~xsd__unsignedByte_Array()
@@ -2196,12 +2106,12 @@
 
 void xsd__unsignedByte_Array::set(xsd__unsignedByte** array, int size)
 {
-	Axis_Array::set((void**)array, size, XSD_UNSIGNEDBYTE);
+    Axis_Array::set((void**)array, size, XSD_UNSIGNEDBYTE);
 }
 
 const xsd__unsignedByte** xsd__unsignedByte_Array::get(int& size) const
 {
-	XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__unsignedByte**) Axis_Array::get(size, type);
 }
 
@@ -2213,9 +2123,7 @@
 xsd__positiveInteger_Array::xsd__positiveInteger_Array(const xsd__positiveInteger_Array & original)
 {
     if (original.m_Type == XSD_POSITIVEINTEGER)
-    {
         clone(original);
-    }
 }
 
 xsd__positiveInteger_Array::~xsd__positiveInteger_Array()
@@ -2225,12 +2133,12 @@
 
 void xsd__positiveInteger_Array::set(xsd__positiveInteger** array, int size)
 {
-	Axis_Array::set((void**)array, size, XSD_POSITIVEINTEGER);
+    Axis_Array::set((void**)array, size, XSD_POSITIVEINTEGER);
 }
 
 const xsd__positiveInteger** xsd__positiveInteger_Array::get(int& size) const
 {
-	XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__positiveInteger**) Axis_Array::get(size, type);
 }
 
@@ -2242,9 +2150,7 @@
 xsd__double_Array::xsd__double_Array(const xsd__double_Array & original)
 {
     if (original.m_Type == XSD_DOUBLE)
-    {
         clone(original);
-    }
 }
 
 xsd__double_Array::~xsd__double_Array()
@@ -2254,12 +2160,12 @@
 
 void xsd__double_Array::set(xsd__double** array, int size)
 {
-	Axis_Array::set((void**)array, size, XSD_DOUBLE);
+    Axis_Array::set((void**)array, size, XSD_DOUBLE);
 }
 
 const xsd__double** xsd__double_Array::get(int& size) const
 {
-	XSDTYPE type;
+    XSDTYPE type;
     return (const xsd__double**) Axis_Array::get(size, type);
 }
 
@@ -2271,9 +2177,7 @@
 xsd__anyURI_Array::xsd__anyURI_Array(const xsd__anyURI_Array & original)
 {
     if (original.m_Type == XSD_ANYURI)
-    {
         clone(original);
-    }
 }
 
 xsd__anyURI_Array::~xsd__anyURI_Array()
@@ -2300,9 +2204,7 @@
 xsd__QName_Array::xsd__QName_Array(const xsd__QName_Array & original)
 {
     if (original.m_Type == XSD_QNAME)
-    {
         clone(original);
-    }
 }
 
 xsd__QName_Array::~xsd__QName_Array()
@@ -2329,9 +2231,7 @@
 xsd__NOTATION_Array::xsd__NOTATION_Array(const xsd__NOTATION_Array & original)
 {
     if (original.m_Type == XSD_NOTATION)
-    {
         clone(original);
-    }
 }
 
 xsd__NOTATION_Array::~xsd__NOTATION_Array()



Mime
View raw message