/* -*- C++ -*- */ | |
/* | |
* Copyright 2006-2006 The Apache Software Foundation. | |
// (c) Copyright IBM Corp. 2006, 2006 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. | |
* | |
*/ | |
// !!! This include file must be first thing in file !!! | |
#include "../platforms/PlatformAutoSense.hpp" | |
#include <axis/Axis.h> | |
#include "AxisObjectConverter.hpp" | |
#include "../common/AxisTrace.h" | |
AXIS_CPP_NAMESPACE_START | |
AxiscAnyType * | |
AxisObjectConverter::cppAnyTypeToC(AnyType *objAnyType, | |
AxiscAnyType *cAnyType, | |
bool deleteObj) | |
{ | |
// If nothing to transform, return | |
if (objAnyType == NULL) | |
return cAnyType; | |
// Allocate cAnyType and initialize | |
if (cAnyType == NULL) | |
cAnyType = (AxiscAnyType *)axiscAxisNew(XSDC_ANY, 0); | |
cAnyType->_size = objAnyType->_size; | |
// If we are going to delete the object, simply copy the array pointer | |
// to c structure. | |
if (deleteObj) | |
{ | |
cAnyType->_array = objAnyType->_array; | |
objAnyType->_array = NULL; | |
objAnyType->_size = 0; | |
} | |
else | |
{ | |
int len; | |
if (cAnyType->_size > 0) | |
{ | |
cAnyType->_array = new AXISC_XML_String [cAnyType->_size]; | |
for (int i=0; i<cAnyType->_size; ++i) | |
{ | |
if ( objAnyType->_array[i] == NULL) | |
{ | |
cAnyType->_array[i] = NULL; | |
continue; | |
} | |
len = strlen(objAnyType->_array[i]) + 1; | |
cAnyType->_array[i] = new char[len]; | |
strcpy(cAnyType->_array[i], objAnyType->_array[i]); | |
} | |
} | |
} | |
// Delete c++ object before returning c object | |
if (deleteObj) | |
delete objAnyType; | |
return cAnyType; | |
} | |
Axisc_Array * | |
AxisObjectConverter::cppArrayToC(Axis_Array *objArray, | |
Axisc_Array *cArray, | |
bool deleteObj) | |
{ | |
// If nothing to transform, return | |
if (objArray == NULL) | |
return cArray; | |
// Allocate cbinding array and initialize | |
if (cArray == NULL) | |
cArray = (Axisc_Array *)axiscAxisNew(XSDC_ARRAY, 0); | |
// Get object array stuff | |
XSDTYPE m_Type; | |
int m_Size; | |
void ** m_Array = objArray->get(m_Size, m_Type); | |
cArray->m_Size = m_Size; | |
cArray->m_Type = (AXISC_XSDTYPE)m_Type; | |
// Now generate the array | |
if (m_Array != NULL && m_Size > 0) | |
{ | |
cArray->m_Array = new void*[m_Size]; | |
for (int count = 0 ; count < m_Size ; count++) | |
{ | |
if ( m_Array[count] == NULL) | |
{ | |
cArray->m_Array[count] = NULL; | |
continue; | |
} | |
switch (m_Type) | |
{ | |
case XSD_STRING: | |
{ | |
((xsd__string*) cArray->m_Array)[count] = new char[strlen(((xsd__string*) m_Array)[count])+1]; | |
strcpy(((xsd__string*) cArray->m_Array)[count], ((xsd__string*) m_Array)[count]); | |
break; | |
} | |
case XSD_FLOAT: | |
{ | |
((xsd__float**) cArray->m_Array)[count] = new xsd__float(); | |
*((xsd__float**)cArray->m_Array)[count] = *((xsd__float**) m_Array)[count]; | |
break; | |
} | |
case XSD_DECIMAL: | |
{ | |
((xsd__decimal**) cArray->m_Array)[count] = new xsd__decimal(); | |
*((xsd__decimal**)cArray->m_Array)[count] = *((xsd__decimal**) m_Array)[count]; | |
break; | |
} | |
case XSD_INTEGER: | |
{ | |
((xsd__integer**) cArray->m_Array)[count] = new xsd__integer(); | |
*((xsd__integer**)cArray->m_Array)[count] = *((xsd__integer**) m_Array)[count]; | |
break; | |
} | |
case XSD_NONPOSITIVEINTEGER: | |
{ | |
((xsd__nonPositiveInteger**) cArray->m_Array)[count] = new xsd__nonPositiveInteger(); | |
*((xsd__nonPositiveInteger**)cArray->m_Array)[count] = *((xsd__nonPositiveInteger**) m_Array)[count]; | |
break; | |
} | |
case XSD_NEGATIVEINTEGER: | |
{ | |
((xsd__negativeInteger**) cArray->m_Array)[count] = new xsd__negativeInteger(); | |
*((xsd__negativeInteger**)cArray->m_Array)[count] = *((xsd__negativeInteger**) m_Array)[count]; | |
break; | |
} | |
case XSD_LONG: | |
{ | |
((xsd__long**) cArray->m_Array)[count] = new xsd__long(); | |
*((xsd__long**)cArray->m_Array)[count] = *((xsd__long**) m_Array)[count]; | |
break; | |
} | |
case XSD_INT: | |
{ | |
((xsd__int**) cArray->m_Array)[count] = new xsd__int(); | |
*((xsd__int**)cArray->m_Array)[count] = *((xsd__int**) m_Array)[count]; | |
break; | |
} | |
case XSD_SHORT: | |
{ | |
((xsd__short**) cArray->m_Array)[count] = new xsd__short(); | |
*((xsd__short**)cArray->m_Array)[count] = *((xsd__short**) m_Array)[count]; | |
break; | |
} | |
case XSD_BYTE: | |
{ | |
((xsd__byte**) cArray->m_Array)[count] = new xsd__byte(); | |
*((xsd__byte**)cArray->m_Array)[count] = *((xsd__byte**) m_Array)[count]; | |
break; | |
} | |
case XSD_NONNEGATIVEINTEGER: | |
{ | |
((xsd__nonNegativeInteger**) cArray->m_Array)[count] = new xsd__nonNegativeInteger(); | |
*((xsd__nonNegativeInteger**)cArray->m_Array)[count] = *((xsd__nonNegativeInteger**) m_Array)[count]; | |
break; | |
} | |
case XSD_UNSIGNEDLONG: | |
{ | |
((xsd__unsignedLong**) cArray->m_Array)[count] = new xsd__unsignedLong(); | |
*((xsd__unsignedLong**)cArray->m_Array)[count] = *((xsd__unsignedLong**) m_Array)[count]; | |
break; | |
} | |
case XSD_UNSIGNEDINT: | |
{ | |
((xsd__unsignedInt**) cArray->m_Array)[count] = new xsd__unsignedInt(); | |
*((xsd__unsignedInt**)cArray->m_Array)[count] = *((xsd__unsignedInt**) m_Array)[count]; | |
break; | |
} | |
case XSD_UNSIGNEDSHORT: | |
{ | |
((xsd__unsignedShort**) cArray->m_Array)[count] = new xsd__unsignedShort(); | |
*((xsd__unsignedShort**)cArray->m_Array)[count] = *((xsd__unsignedShort**) m_Array)[count]; | |
break; | |
} | |
case XSD_UNSIGNEDBYTE: | |
{ | |
((xsd__unsignedByte**) cArray->m_Array)[count] = new xsd__unsignedByte(); | |
*((xsd__unsignedByte**)cArray->m_Array)[count] = *((xsd__unsignedByte**) m_Array)[count]; | |
break; | |
} | |
case XSD_POSITIVEINTEGER: | |
{ | |
((xsd__positiveInteger**) cArray->m_Array)[count] = new xsd__positiveInteger(); | |
*((xsd__positiveInteger**)cArray->m_Array)[count] = *((xsd__positiveInteger**) m_Array)[count]; | |
break; | |
} | |
case XSD_DOUBLE: | |
{ | |
((xsd__double**) cArray->m_Array)[count] = new xsd__double(); | |
*((xsd__double**)cArray->m_Array)[count] = *((xsd__double**) m_Array)[count]; | |
break; | |
} | |
case XSD_DURATION: | |
{ | |
((xsd__duration**) cArray->m_Array)[count] = new xsd__duration(); | |
*((xsd__duration**)cArray->m_Array)[count] = *((xsd__duration**) m_Array)[count]; | |
break; | |
} | |
case XSD_DATETIME: | |
{ | |
((xsd__dateTime**) cArray->m_Array)[count] = new xsd__dateTime(); | |
*((xsd__dateTime**)cArray->m_Array)[count] = *((xsd__dateTime**) m_Array)[count]; | |
break; | |
} | |
case XSD_TIME: | |
{ | |
((xsd__time**) cArray->m_Array)[count] = new xsd__time(); | |
*((xsd__time**)cArray->m_Array)[count] = *((xsd__time**) m_Array)[count]; | |
break; | |
} | |
case XSD_DATE: | |
{ | |
((xsd__date**) cArray->m_Array)[count] = new xsd__date(); | |
*((xsd__date**)cArray->m_Array)[count] = *((xsd__date**) m_Array)[count]; | |
break; | |
} | |
case XSD_GYEARMONTH: | |
{ | |
((xsd__gYearMonth**) cArray->m_Array)[count] = new xsd__gYearMonth(); | |
*((xsd__gYearMonth**)cArray->m_Array)[count] = *((xsd__gYearMonth**) m_Array)[count]; | |
break; | |
} | |
case XSD_GYEAR: | |
{ | |
((xsd__gYear**) cArray->m_Array)[count] = new xsd__gYear(); | |
*((xsd__gYear**)cArray->m_Array)[count] = *((xsd__gYear**) m_Array)[count]; | |
break; | |
} | |
case XSD_GMONTHDAY: | |
{ | |
((xsd__gMonthDay**) cArray->m_Array)[count] = new xsd__gMonthDay(); | |
*((xsd__gMonthDay**)cArray->m_Array)[count] = *((xsd__gMonthDay**) m_Array)[count]; | |
break; | |
} | |
case XSD_GDAY: | |
{ | |
((xsd__gDay**) cArray->m_Array)[count] = new xsd__gDay(); | |
*((xsd__gDay**)cArray->m_Array)[count] = *((xsd__gDay**) m_Array)[count]; | |
break; | |
} | |
case XSD_GMONTH: | |
{ | |
((xsd__gMonth**) cArray->m_Array)[count] = new xsd__gMonth(); | |
*((xsd__gMonth**)cArray->m_Array)[count] = *((xsd__gMonth**) m_Array)[count]; | |
break; | |
} | |
case XSD_NORMALIZEDSTRING: | |
{ | |
((xsd__normalizedString*) cArray->m_Array)[count] = new char[strlen(((xsd__normalizedString*) m_Array)[count])+1]; | |
strcpy(((xsd__normalizedString*) cArray->m_Array)[count], ((xsd__normalizedString*) m_Array)[count]); | |
break; | |
} | |
case XSD_TOKEN: | |
{ | |
((xsd__token*) cArray->m_Array)[count] = new char[strlen(((xsd__token*) m_Array)[count])+1]; | |
strcpy(((xsd__token*) cArray->m_Array)[count], ((xsd__token*) m_Array)[count]); | |
break; | |
} | |
case XSD_LANGUAGE: | |
{ | |
((xsd__language*) cArray->m_Array)[count] = new char[strlen(((xsd__language*) m_Array)[count])+1]; | |
strcpy(((xsd__language*) cArray->m_Array)[count], ((xsd__language*) m_Array)[count]); | |
break; | |
} | |
case XSD_NAME: | |
{ | |
((xsd__Name*) cArray->m_Array)[count] = new char[strlen(((xsd__Name*) m_Array)[count])+1]; | |
strcpy(((xsd__Name*) cArray->m_Array)[count], ((xsd__Name*) m_Array)[count]); | |
break; | |
} | |
case XSD_NCNAME: | |
{ | |
((xsd__NCName*) cArray->m_Array)[count] = new char[strlen(((xsd__NCName*) m_Array)[count])+1]; | |
strcpy(((xsd__NCName*) cArray->m_Array)[count], ((xsd__NCName*) m_Array)[count]); | |
break; | |
} | |
case XSD_ID: | |
{ | |
((xsd__ID*) cArray->m_Array)[count] = new char[strlen(((xsd__ID*) m_Array)[count])+1]; | |
strcpy(((xsd__ID*) cArray->m_Array)[count], ((xsd__ID*) m_Array)[count]); | |
break; | |
} | |
case XSD_IDREF: | |
{ | |
((xsd__IDREF*) cArray->m_Array)[count] = new char[strlen(((xsd__IDREF*) m_Array)[count])+1]; | |
strcpy(((xsd__IDREF*) cArray->m_Array)[count], ((xsd__IDREF*) m_Array)[count]); | |
break; | |
} | |
case XSD_IDREFS: | |
{ | |
((xsd__IDREFS*) cArray->m_Array)[count] = new char[strlen(((xsd__IDREFS*) m_Array)[count])+1]; | |
strcpy(((xsd__IDREFS*) cArray->m_Array)[count], ((xsd__IDREFS*) m_Array)[count]); | |
break; | |
} | |
case XSD_ENTITY: | |
{ | |
((xsd__ENTITY*) cArray->m_Array)[count] = new char[strlen(((xsd__ENTITY*) m_Array)[count])+1]; | |
strcpy(((xsd__ENTITY*) cArray->m_Array)[count], ((xsd__ENTITY*) m_Array)[count]); | |
break; | |
} | |
case XSD_ENTITIES: | |
{ | |
((xsd__ENTITIES*) cArray->m_Array)[count] = new char[strlen(((xsd__ENTITIES*) m_Array)[count])+1]; | |
strcpy(((xsd__ENTITIES*) cArray->m_Array)[count], ((xsd__ENTITIES*) m_Array)[count]); | |
break; | |
} | |
case XSD_NMTOKEN: | |
{ | |
((xsd__NMTOKEN*) cArray->m_Array)[count] = new char[strlen(((xsd__NMTOKEN*) m_Array)[count])+1]; | |
strcpy(((xsd__NMTOKEN*) cArray->m_Array)[count], ((xsd__NMTOKEN*) m_Array)[count]); | |
break; | |
} | |
case XSD_NMTOKENS: | |
{ | |
((xsd__NMTOKENS*) cArray->m_Array)[count] = new char[strlen(((xsd__NMTOKENS*) m_Array)[count])+1]; | |
strcpy(((xsd__NMTOKENS*) cArray->m_Array)[count], ((xsd__NMTOKENS*) m_Array)[count]); | |
break; | |
} | |
case XSD_BOOLEAN: | |
{ | |
((xsd__boolean**) cArray->m_Array)[count] = new xsd__boolean(); | |
*((xsd__boolean**)cArray->m_Array)[count] = *((xsd__boolean**) m_Array)[count]; | |
break; | |
} | |
case XSD_BASE64BINARY: | |
{ | |
cArray->m_Array[count] = cppBase64BinaryToC((xsd__base64Binary *)m_Array[count], NULL, false); | |
break; | |
} | |
case XSD_HEXBINARY: | |
{ | |
cArray->m_Array[count] = cppHexBinaryToC((xsd__hexBinary *)m_Array[count], NULL, false); | |
break; | |
} | |
case XSD_ANYURI: | |
{ | |
((xsd__anyURI*) cArray->m_Array)[count] = new char[strlen(((xsd__anyURI*) m_Array)[count])+1]; | |
strcpy(((xsd__anyURI*) cArray->m_Array)[count], ((xsd__anyURI*) m_Array)[count]); | |
break; | |
} | |
case XSD_QNAME: | |
{ | |
((xsd__QName*) cArray->m_Array)[count] = new char[strlen(((xsd__QName*) m_Array)[count])+1]; | |
strcpy(((xsd__QName*) cArray->m_Array)[count], ((xsd__QName*) m_Array)[count]); | |
break; | |
} | |
case XSD_NOTATION: | |
{ | |
((xsd__NOTATION*) cArray->m_Array)[count] = new char[strlen(((xsd__NOTATION*) m_Array)[count])+1]; | |
strcpy(((xsd__NOTATION*) cArray->m_Array)[count], ((xsd__NOTATION*) m_Array)[count]); | |
break; | |
} | |
case XSD_ARRAY: | |
{ | |
// TODO | |
cArray->m_Array[count] = m_Array[count]; | |
break; | |
} | |
case USER_TYPE: | |
{ | |
// TODO | |
cArray->m_Array[count] = m_Array[count]; | |
break; | |
} | |
case XSD_ANYTYPE: | |
{ | |
((xsd__anyType*) cArray->m_Array)[count] = new char[strlen(((xsd__anyType*) m_Array)[count])+1]; | |
strcpy(((xsd__anyType*) cArray->m_Array)[count], ((xsd__anyType*) m_Array)[count]); | |
break; | |
} | |
case XSD_UNKNOWN: | |
case XSD_ANY: | |
case ATTACHMENT: | |
default: | |
break; | |
} // end switch | |
} // end for loop | |
} | |
// delete c++ object array if requested to do so before returning | |
if (deleteObj) | |
delete objArray; | |
return cArray; | |
} | |
xsdc__base64Binary * | |
AxisObjectConverter::cppBase64BinaryToC(xsd__base64Binary *objBase64Bin, | |
xsdc__base64Binary *cBase64Bin, | |
bool deleteObj) | |
{ | |
// Nothing to transform, return. | |
if (!objBase64Bin) | |
return (xsdc__base64Binary *)NULL; | |
// Get info from c++ Object | |
int base64BinaryDataSize; | |
xsd__unsignedByte *base64BinaryData = objBase64Bin->get(base64BinaryDataSize); | |
// Create c-style equivalent object | |
xsdc__base64Binary * pObjC = (xsdc__base64Binary *)axiscAxisNew(XSDC_BASE64BINARY, base64BinaryDataSize); | |
// populate c-style object with data from c++ object | |
if (base64BinaryDataSize > 0) | |
{ | |
memcpy(pObjC->__ptr, base64BinaryData, base64BinaryDataSize); | |
pObjC->__ptr[base64BinaryDataSize] = '\0'; | |
} | |
// Delete c++ object before returning c object | |
if (deleteObj) | |
delete objBase64Bin; | |
return pObjC; | |
} | |
xsdc__hexBinary * | |
AxisObjectConverter::cppHexBinaryToC(xsd__hexBinary *objHexBin, | |
xsdc__hexBinary *cHexBin, | |
bool deleteObj) | |
{ | |
// If nothing to transform, return. | |
if (!objHexBin) | |
return (xsdc__hexBinary *)NULL; | |
// Get info from c++ Object | |
int hexDataSize; | |
xsd__unsignedByte *hexData = objHexBin->get(hexDataSize); | |
// Create c-style equivalent object | |
xsdc__hexBinary * pObjC = (xsdc__hexBinary *)axiscAxisNew(XSDC_HEXBINARY, hexDataSize); | |
// populate c-style object with data from c++ object | |
if (hexDataSize > 0) | |
{ | |
memcpy(pObjC->__ptr, hexData, hexDataSize); | |
pObjC->__ptr[hexDataSize] = '\0'; | |
} | |
// Delete c++ object before returning c object | |
if (deleteObj) | |
delete objHexBin; | |
return pObjC; | |
} | |
AXIS_CPP_NAMESPACE_END |