| /* |
| * 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. |
| */ |
| |
| // !!! This include file must be first thing in file !!! |
| #include "../platforms/PlatformAutoSense.hpp" |
| |
| #include <stdarg.h> |
| #include <string> |
| |
| #include <iostream> |
| |
| #include <axis/ElementMissingException.hpp> |
| #include <axis/RedundantElementException.hpp> |
| #include <axis/UnknownElementException.hpp> |
| |
| #include <axis/Axis.hpp> |
| #include <axis/AxisException.hpp> |
| #include <axis/AxisUserAPI.hpp> |
| |
| #include <axis/Axis.h> |
| #include <axis/GDefine.h> |
| #include <axis/AxisUserAPI.h> |
| #include <axis/TypeMapping.h> |
| |
| #include "../common/AxisTrace.h" |
| |
| AXIS_CPP_NAMESPACE_USE |
| |
| extern "C" { |
| |
| static AXIS_EXCEPTION_HANDLER_FUNCT global_exceptionHandler = NULL; |
| |
| STORAGE_CLASS_INFO |
| int axiscAxisInitialize(AxiscBool bIsServer) |
| { |
| int rc = AXISC_SUCCESS; |
| |
| try |
| { |
| Axis::initialize(0==bIsServer); |
| } |
| catch ( AxisException& e ) |
| { |
| axiscAxisInvokeExceptionHandler(e.getExceptionCode(), e.what(), NULL, NULL); |
| rc = AXISC_FAIL; |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| rc = AXISC_FAIL; |
| } |
| |
| return rc; |
| } |
| |
| STORAGE_CLASS_INFO |
| int axiscAxisTerminate() |
| { |
| int rc = AXISC_SUCCESS; |
| |
| try |
| { |
| Axis::terminate(); |
| } |
| catch ( AxisException& e ) |
| { |
| axiscAxisInvokeExceptionHandler(e.getExceptionCode(), e.what(), NULL, NULL); |
| rc = AXISC_FAIL; |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| rc = AXISC_FAIL; |
| } |
| |
| return rc; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| int axiscAxisDelete(void * pValue, |
| AXISC_XSDTYPE type) |
| { |
| int rc = AXISC_SUCCESS; |
| |
| try |
| { |
| if (pValue == NULL) |
| return rc; |
| |
| // There are some types we cannot pass to C++ engine |
| switch (type) |
| { |
| case XSDC_DURATION: |
| case XSDC_DATETIME: |
| case XSDC_TIME: |
| case XSDC_DATE: |
| case XSDC_GYEARMONTH: |
| case XSDC_GYEAR: |
| case XSDC_GMONTHDAY: |
| case XSDC_GDAY: |
| case XSDC_GMONTH: |
| case XSDC_STRING: |
| case XSDC_NORMALIZEDSTRING: |
| case XSDC_TOKEN: |
| case XSDC_LANGUAGE: |
| case XSDC_NAME: |
| case XSDC_NCNAME: |
| case XSDC_ID: |
| case XSDC_IDREF: |
| case XSDC_IDREFS: |
| case XSDC_ENTITY: |
| case XSDC_ENTITIES: |
| case XSDC_NMTOKEN: |
| case XSDC_NMTOKENS: |
| case XSDC_BOOLEAN: |
| case XSDC_FLOAT: |
| case XSDC_DECIMAL: |
| case XSDC_NONPOSITIVEINTEGER: |
| case XSDC_NEGATIVEINTEGER: |
| case XSDC_INTEGER: |
| case XSDC_LONG: |
| case XSDC_INT: |
| case XSDC_SHORT: |
| case XSDC_BYTE: |
| case XSDC_NONNEGATIVEINTEGER: |
| case XSDC_UNSIGNEDLONG: |
| case XSDC_UNSIGNEDINT: |
| case XSDC_UNSIGNEDSHORT: |
| case XSDC_UNSIGNEDBYTE: |
| case XSDC_POSITIVEINTEGER: |
| case XSDC_DOUBLE: |
| case XSDC_ANYURI: |
| case XSDC_QNAME: |
| case XSDC_NOTATION: |
| case C_USER_TYPE: |
| case C_ATTACHMENT: |
| case XSDC_UNKNOWN: |
| case XSDC_ANYTYPE: |
| { |
| Axis::AxisDelete(pValue, (XSDTYPE) type); |
| break; |
| } |
| case XSDC_ARRAY: |
| { |
| Axisc_Array *array = (Axisc_Array*)pValue; |
| |
| // Delete array elements via recursion |
| if (array->m_Array) |
| { |
| for (int i=0; i<array->m_Size; ++i) |
| if (array->m_Array[i]) |
| axiscAxisDelete(array->m_Array[i], array->m_Type); |
| delete [] array->m_Array; |
| } |
| |
| // Delete array |
| delete array; |
| break; |
| } |
| case XSDC_BASE64BINARY: |
| { |
| xsdc__base64Binary* b64 = (xsdc__base64Binary*) pValue; |
| if (b64->__ptr) |
| delete [] b64->__ptr; |
| delete b64; |
| break; |
| } |
| case XSDC_HEXBINARY: |
| { |
| xsdc__hexBinary* hb = (xsdc__hexBinary*) pValue; |
| if (hb->__ptr) |
| delete [] hb->__ptr; |
| delete hb; |
| break; |
| } |
| case XSDC_ANY: |
| { |
| AxiscAnyType *anytype = (AxiscAnyType *)pValue; |
| if (anytype->_size > 0 && anytype->_array) |
| { |
| for (int i=0; i<anytype->_size; i++) |
| if (anytype->_array[i]) |
| delete [] anytype->_array[i]; |
| |
| delete [] anytype->_array; |
| } |
| delete anytype; |
| break; |
| } |
| |
| default: |
| ; |
| } |
| } |
| catch ( AxisException& e ) |
| { |
| axiscAxisInvokeExceptionHandler(e.getExceptionCode(), e.what(), NULL, NULL); |
| rc = AXISC_FAIL; |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| rc = AXISC_FAIL; |
| } |
| |
| return rc; |
| } |
| |
| |
| AXISC_STORAGE_CLASS_INFO |
| void *axiscAxisNew(AXISC_XSDTYPE type, int size) |
| { |
| void *retVal=NULL; |
| |
| try |
| { |
| switch (type) |
| { |
| case XSDC_DURATION: |
| { |
| retVal = new xsd__duration(); |
| break; |
| } |
| case XSDC_DATETIME: |
| { |
| retVal = new xsd__dateTime(); |
| break; |
| } |
| case XSDC_TIME: |
| { |
| retVal = new xsd__time(); |
| break; |
| } |
| case XSDC_DATE: |
| { |
| retVal = new xsd__date(); |
| break; |
| } |
| case XSDC_GYEARMONTH: |
| { |
| retVal = new xsd__gYearMonth(); |
| break; |
| } |
| case XSDC_GYEAR: |
| { |
| retVal = new xsd__gYear(); |
| break; |
| } |
| case XSDC_GMONTHDAY: |
| { |
| retVal = new xsd__gMonthDay(); |
| break; |
| } |
| case XSDC_GDAY: |
| { |
| retVal = new xsd__gDay(); |
| break; |
| } |
| case XSDC_GMONTH: |
| { |
| retVal = new xsd__gMonth(); |
| break; |
| } |
| case XSDC_STRING: |
| case XSDC_NORMALIZEDSTRING: |
| case XSDC_TOKEN: |
| case XSDC_LANGUAGE: |
| case XSDC_NAME: |
| case XSDC_NCNAME: |
| case XSDC_ID: |
| case XSDC_IDREF: |
| case XSDC_IDREFS: |
| case XSDC_ENTITY: |
| case XSDC_ENTITIES: |
| case XSDC_NMTOKEN: |
| case XSDC_NMTOKENS: |
| case XSDC_ANYURI: |
| case XSDC_QNAME: |
| case XSDC_NOTATION: |
| case XSDC_ANYTYPE: |
| { |
| retVal = new char[size+1]; |
| break; |
| } |
| case XSDC_BOOLEAN: |
| { |
| retVal = new xsd__boolean(); |
| break; |
| } |
| case XSDC_BASE64BINARY: |
| { |
| xsdc__base64Binary *b64bin = new xsdc__base64Binary(); |
| b64bin->__size=size; |
| if (size > 0) |
| b64bin->__ptr = new xsdc__unsignedByte[size+1]; |
| else |
| b64bin->__ptr=NULL; |
| retVal = b64bin; |
| break; |
| } |
| case XSDC_HEXBINARY: |
| { |
| xsdc__hexBinary *hexbin = new xsdc__hexBinary(); |
| hexbin->__size=size; |
| if (size > 0) |
| hexbin->__ptr = new xsdc__unsignedByte[size+1]; |
| else |
| hexbin->__ptr=NULL; |
| retVal = hexbin; |
| break; |
| } |
| case XSDC_FLOAT: |
| { |
| retVal = new xsd__float(); |
| break; |
| } |
| case XSDC_DECIMAL: |
| { |
| retVal = new xsd__decimal(); |
| break; |
| } |
| case XSDC_INTEGER: |
| { |
| retVal = new xsd__integer(); |
| break; |
| } |
| case XSDC_NONPOSITIVEINTEGER: |
| { |
| retVal = new xsd__nonPositiveInteger(); |
| break; |
| } |
| case XSDC_NEGATIVEINTEGER: |
| { |
| retVal = new xsd__negativeInteger(); |
| break; |
| } |
| case XSDC_LONG: |
| { |
| retVal = new xsd__long(); |
| break; |
| } |
| case XSDC_INT: |
| { |
| retVal = new xsd__int(); |
| break; |
| } |
| case XSDC_SHORT: |
| { |
| retVal = new xsd__short(); |
| break; |
| } |
| case XSDC_BYTE: |
| { |
| retVal = new xsd__byte(); |
| break; |
| } |
| case XSDC_NONNEGATIVEINTEGER: |
| { |
| retVal = new xsd__nonNegativeInteger(); |
| break; |
| } |
| case XSDC_UNSIGNEDLONG: |
| { |
| retVal = new xsd__unsignedLong(); |
| break; |
| } |
| case XSDC_UNSIGNEDINT: |
| { |
| retVal = new xsd__unsignedInt(); |
| break; |
| } |
| case XSDC_UNSIGNEDSHORT: |
| { |
| retVal = new xsd__unsignedShort(); |
| break; |
| } |
| case XSDC_UNSIGNEDBYTE: |
| { |
| retVal = new xsd__unsignedByte(); |
| break; |
| } |
| case XSDC_POSITIVEINTEGER: |
| { |
| retVal = new xsd__positiveInteger(); |
| break; |
| } |
| case XSDC_DOUBLE: |
| { |
| retVal = new xsd__double(); |
| break; |
| } |
| case XSDC_ARRAY: |
| { |
| Axisc_Array * array = new Axisc_Array(); |
| array->m_Array = NULL; |
| array->m_Size = 0; |
| array->m_Type = XSDC_UNKNOWN; |
| retVal = array; |
| break; |
| } |
| case XSDC_ANY: |
| { |
| AxiscAnyType * anytype= new AxiscAnyType(); |
| anytype->_array = NULL; |
| anytype->_size = 0; |
| retVal = anytype; |
| break; |
| } |
| case C_USER_TYPE: |
| case XSDC_UNKNOWN: |
| case C_ATTACHMENT: |
| default: |
| break; |
| } |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return retVal; |
| } |
| |
| |
| AXISC_STORAGE_CLASS_INFO |
| int axiscAxisDeleteCArray(void ** pValue) |
| { |
| delete [] pValue; |
| } |
| |
| |
| AXISC_STORAGE_CLASS_INFO |
| void ** axiscAxisNewCArray(int size) |
| { |
| if (size > 0) |
| return new void *[size]; |
| else |
| return (void **)NULL; |
| } |
| |
| |
| |
| AXISC_STORAGE_CLASS_INFO |
| void axiscAxisRegisterExceptionHandler( AXIS_EXCEPTION_HANDLER_FUNCT fp ) |
| { |
| global_exceptionHandler = fp; |
| } |
| |
| |
| AXISC_STORAGE_CLASS_INFO |
| void axiscAxisInvokeExceptionHandler(int errorCode, |
| const char *errorString, |
| AXISCHANDLE pSoapFault, |
| void *faultDetail) |
| { |
| if (global_exceptionHandler) |
| global_exceptionHandler(errorCode, errorString, pSoapFault, faultDetail); |
| else |
| std::cerr << "AXIS EXCEPTION: (" << errorCode << ") " << errorString << std::endl; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| void axiscAxisGenerateElementMissingException(const char *s) |
| { |
| throw ElementMissingException(s); |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| void axiscAxisGenerateRedundantElementException(const char *s) |
| { |
| throw RedundantElementException(s); |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| void axiscAxisGenerateUnknownElementException(const char *s) |
| { |
| throw UnknownElementException(s); |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| int axiscAxisStartTrace(const char* logFilePath, const char *logFilter) |
| { |
| return Axis::startTrace(logFilePath, logFilter); |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| void axiscAxisStopTrace() |
| { |
| Axis::stopTrace(); |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| void axiscAxisWriteTrace(AXISC_TRACE_TYPE type, const char* functionName, const char * fmt, ...) |
| { |
| // If logging is not enabled, just return. |
| if (!AxisTrace::isLoggingEnabled() || !AxisTrace::isStubLoggingEnabled()) |
| return; |
| |
| // Construct final formatter |
| std::string myfmt; |
| std::string blank = " "; |
| |
| char *traceType = TRACE_TYPE_DEBUG; |
| if (type == AXISC_TRACE_TYPE_ENTRY) |
| traceType = TRACE_TYPE_ENTRY; |
| else if (type == AXISC_TRACE_TYPE_EXIT) |
| traceType = TRACE_TYPE_EXIT; |
| else if (type == AXISC_TRACE_TYPE_EXCEPTION) |
| traceType = TRACE_TYPE_EXCEPT; |
| |
| if (NULL == fmt) |
| fmt = ""; |
| myfmt += TRACE_COMPONENT_STUB + blank; |
| myfmt += traceType + blank; |
| myfmt += functionName; |
| myfmt += "(): "; |
| myfmt += fmt; |
| |
| va_list vargs; |
| va_start(vargs,fmt); |
| AxisTrace::writeTrace(myfmt.c_str(), vargs); |
| va_end(vargs); |
| } |
| |
| } |
