| /* |
| * 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 <axis/client/Call.hpp> |
| #include <axis/AxisException.hpp> |
| #include <axis/client/Stub.hpp> |
| |
| #include "../AxisObjectConverter.hpp" |
| #include "StubC.h" |
| |
| #include "../../common/AxisTrace.h" |
| |
| #include <axis/Axis.h> |
| #include <axis/GDefine.h> |
| #include <axis/AxisUserAPI.h> |
| #include <axis/SoapEnvVersions.h> |
| #include <axis/TypeMapping.h> |
| #include <axis/WSDDDefines.h> |
| #include <axis/client/Call.h> |
| |
| AXIS_CPP_NAMESPACE_USE |
| |
| extern "C" { |
| |
| static void processException(Call *c, AxisException& e) |
| { |
| void *exceptionHandler = (void *)axiscAxisInvokeExceptionHandler; |
| void *stubExceptionHandler; |
| |
| StubC *s = (StubC *)c->getCStub(); |
| if (s) |
| { |
| if ((stubExceptionHandler = s->getCExceptionHandler()) != NULL) |
| exceptionHandler = stubExceptionHandler; |
| |
| s->doNotPerformClientRequest = true; |
| } |
| |
| c->processSoapFault(&e, exceptionHandler); |
| } |
| |
| |
| AXISC_STORAGE_CLASS_INFO |
| AXISCHANDLE axiscCallCreate() |
| { |
| try |
| { |
| Call *c = new Call(); |
| return (AXISCHANDLE)c; |
| } |
| catch ( AxisException& e ) |
| { |
| axiscAxisInvokeExceptionHandler(e.getExceptionCode(), e.what(), NULL, NULL); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (AXISCHANDLE)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| void axiscCallDestroy(AXISCHANDLE call) |
| { |
| if ((AXISCHANDLE)NULL == call) |
| return; |
| |
| Call *c = (Call*)call; |
| |
| try |
| { |
| delete c; |
| } |
| catch ( AxisException& e ) |
| { |
| axiscAxisInvokeExceptionHandler(e.getExceptionCode(), e.what(), NULL, NULL); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| void axiscCallSetSOAPVersion(AXISCHANDLE call, |
| AXISC_SOAP_VERSION version) |
| { |
| Call *c = (Call*)call; |
| |
| try |
| { |
| c->setSOAPVersion((SOAP_VERSION)version); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| int axiscCallSetTransportProperty(AXISCHANDLE call, |
| AXISC_TRANSPORT_INFORMATION_TYPE type, |
| const char * value) |
| { |
| Call *c = (Call*)call; |
| |
| try |
| { |
| return c->setTransportProperty((AXIS_TRANSPORT_INFORMATION_TYPE)type, value); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return -1; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| const char * axiscCallGetTransportProperty(AXISCHANDLE call, |
| const char *key, |
| AxiscBool response) |
| { |
| Call *c = (Call*)call; |
| |
| try |
| { |
| return c->getTransportProperty(key, (bool)(response !=0 )); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (char *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| void axiscCloseTransportConnection(AXISCHANDLE call) |
| { |
| Call *c = (Call*)call; |
| |
| try |
| { |
| c->closeTransportConnection(); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| int axiscCallSetHandlerProperty(AXISCHANDLE call, |
| AxiscChar * name, |
| void * value, |
| int len) |
| { |
| Call *c = (Call*)call; |
| |
| try |
| { |
| return c->setHandlerProperty(name,value,len); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return -1; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| int axiscCallSetProtocol(AXISCHANDLE call, |
| AXISC_PROTOCOL_TYPE protocol) |
| { |
| Call *c = (Call*)call; |
| |
| try |
| { |
| return c->setProtocol((AXIS_PROTOCOL_TYPE)protocol); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return -1; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| AXISC_PROTOCOL_TYPE axiscCallGetProtocol(AXISCHANDLE call) |
| { |
| Call *c = (Call*)call; |
| |
| try |
| { |
| return (AXISC_PROTOCOL_TYPE)(c->getProtocol()); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (AXISC_PROTOCOL_TYPE)-1; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| int axiscCallUnInitialize(AXISCHANDLE call) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s) |
| s->doNotPerformClientRequest = false; |
| |
| try |
| { |
| return c->unInitialize(); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return -1; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| int axiscCallInitialize(AXISCHANDLE call, |
| AXISC_PROVIDERTYPE nStyle) |
| { |
| Call *c = (Call*)call; |
| |
| try |
| { |
| return c->initialize((PROVIDERTYPE)nStyle); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return -1; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| int axiscCallInvoke(AXISCHANDLE call) |
| { |
| return axiscCallSendAndReceive(call); |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| int axiscCallSendAndReceive(AXISCHANDLE call) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return -1; |
| |
| try |
| { |
| return c->sendAndReceive(); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return -1; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| int axiscCallSend(AXISCHANDLE call) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return -1; |
| |
| try |
| { |
| return c->send(); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return -1; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| void axiscCallAddCmplxParameter(AXISCHANDLE call, |
| void * pObject, |
| void * pSZFunct, |
| void * pDelFunct, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return; |
| |
| try |
| { |
| c->addCmplxParameter(pObject,pSZFunct,pDelFunct,pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| void axiscCallAddCmplxArrayParameter(AXISCHANDLE call, |
| Axisc_Array * pArray, |
| void * pSZFunct, |
| void * pDelFunct, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return; |
| |
| try |
| { |
| // Need to convert C-style array to C++-style array before calling serialization method. |
| Axis_Array objArray; |
| if (pArray) |
| objArray.set((void **)pArray->m_Array, pArray->m_Size, (XSDTYPE)pArray->m_Type); |
| |
| c->addCmplxArrayParameter(&objArray,pSZFunct,pDelFunct,pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| void axiscCallAddBasicArrayParameter(AXISCHANDLE call, |
| Axisc_Array * pArray, |
| AXISC_XSDTYPE nType, |
| const AxiscChar * pName) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return; |
| |
| try |
| { |
| // Need to convert C-style array to C++-style array before calling serialization method. |
| Axis_Array objArray; |
| if (pArray) |
| objArray.set((void **)pArray->m_Array, pArray->m_Size, (XSDTYPE)pArray->m_Type); |
| |
| c->addBasicArrayParameter(&objArray, (XSDTYPE)nType, pName); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| void axiscCallAddParameter(AXISCHANDLE call, |
| void * pValue, |
| const char * pchName, |
| AXISC_XSDTYPE nType) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return; |
| |
| try |
| { |
| c->addParameter(pValue,pchName,(XSDTYPE)nType); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| AXISCHANDLE axiscCallCreateAttribute(AXISCHANDLE call, |
| const AxiscChar * pLocalname, |
| const AxiscChar * pPrefix, |
| const AxiscChar * pValue) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (AXISCHANDLE)NULL; |
| |
| try |
| { |
| return (AXISCHANDLE)(c->createAttribute(pLocalname, pPrefix, pValue)); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (AXISCHANDLE)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| void axiscCallSetOperation(AXISCHANDLE call, |
| const char * pchOperation, |
| const char * pchNamespace) |
| { |
| Call *c = (Call*)call; |
| |
| try |
| { |
| c->setOperation(pchOperation,pchNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| void axiscCallSetOperationUnwrapped(AXISCHANDLE call, |
| const char * pchOperation, |
| const char * pchNamespace) |
| { |
| Call *c = (Call*)call; |
| |
| try |
| { |
| c->setOperation(pchOperation, pchNamespace, false); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| int axiscCallSetEndpointURI(AXISCHANDLE call, |
| const char * pchEndpointURI) |
| { |
| Call *c = (Call*)call; |
| |
| try |
| { |
| return c->setEndpointURI(pchEndpointURI); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return -1; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| AXISCHANDLE axiscCallCreateHeaderBlock(AXISCHANDLE call, |
| AxiscChar * pachLocalName, |
| AxiscChar * pachUri, |
| AxiscChar * pachPrefix) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (AXISCHANDLE)NULL; |
| |
| try |
| { |
| return (AXISCHANDLE)(c->createHeaderBlock(pachLocalName, pachUri, pachPrefix)); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (AXISCHANDLE)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__int * axiscCallGetElementAsInt(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__int *)NULL; |
| |
| try |
| { |
| return c->getElementAsInt(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__int *)NULL; |
| } |
| |
| /* |
| AXISC_STORAGE_CLASS_INFO |
| int axiscCallGetFaultDetail(AXISCHANDLE call, |
| char * * ppcDetail) |
| { |
| |
| |
| Call *c = (Call*)call; |
| |
| try |
| { |
| return c->getFaultDetail(ppcDetail); |
| } |
| catch ( AxisException& e ) |
| { |
| |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| |
| |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return -1; |
| } |
| */ |
| |
| |
| |
| |
| |
| |
| |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__boolean * axiscCallGetElementAsBoolean(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__boolean *)NULL; |
| |
| try |
| { |
| return (xsdc__boolean* )(c->getElementAsBoolean(pName,pNamespace)); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__boolean *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__unsignedInt * axiscCallGetElementAsUnsignedInt(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__unsignedInt *)NULL; |
| |
| try |
| { |
| return c->getElementAsUnsignedInt(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__unsignedInt *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__short * axiscCallGetElementAsShort(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__short *)NULL; |
| |
| try |
| { |
| return c->getElementAsShort(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__short *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__unsignedShort * axiscCallGetElementAsUnsignedShort(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__unsignedShort *)NULL; |
| |
| try |
| { |
| return c->getElementAsUnsignedShort(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__unsignedShort *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__byte * axiscCallGetElementAsByte(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__byte *)NULL; |
| |
| try |
| { |
| return c->getElementAsByte(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__byte *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__unsignedByte * axiscCallGetElementAsUnsignedByte(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__unsignedByte *)NULL; |
| |
| try |
| { |
| return c->getElementAsUnsignedByte(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__unsignedByte *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__long * axiscCallGetElementAsLong(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__long *)NULL; |
| |
| try |
| { |
| return (xsd__long*)(c->getElementAsLong(pName,pNamespace)); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__long *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__integer * axiscCallGetElementAsInteger(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__integer *)NULL; |
| |
| try |
| { |
| return c->getElementAsInteger(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__integer *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__unsignedLong * axiscCallGetElementAsUnsignedLong(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__unsignedLong *)NULL; |
| |
| try |
| { |
| return c->getElementAsUnsignedLong(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__unsignedLong *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__float * axiscCallGetElementAsFloat(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__float *)NULL; |
| |
| try |
| { |
| return c->getElementAsFloat(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__float *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__double * axiscCallGetElementAsDouble(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__double *)NULL; |
| |
| try |
| { |
| return c->getElementAsDouble(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__double *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__decimal * axiscCallGetElementAsDecimal(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__decimal *)NULL; |
| |
| try |
| { |
| return c->getElementAsDecimal(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__decimal *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__string axiscCallGetElementAsString(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__string)NULL; |
| |
| try |
| { |
| return c->getElementAsString(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__string)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__anyURI axiscCallGetElementAsAnyURI(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__anyURI)NULL; |
| |
| try |
| { |
| return c->getElementAsAnyURI(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__anyURI)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__QName axiscCallGetElementAsQName(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__QName)NULL; |
| |
| try |
| { |
| return c->getElementAsQName(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__QName)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__hexBinary * axiscCallGetElementAsHexBinary(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__hexBinary *)NULL; |
| |
| try |
| { |
| xsd__hexBinary * pObjCpp = c->getElementAsHexBinary(pName, pNamespace); |
| |
| return AxisObjectConverter::cppHexBinaryToC(pObjCpp, NULL, true); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__hexBinary *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__base64Binary * axiscCallGetElementAsBase64Binary(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__base64Binary *)NULL; |
| |
| try |
| { |
| xsd__base64Binary * pObjCpp = c->getElementAsBase64Binary(pName, pNamespace); |
| |
| return AxisObjectConverter::cppBase64BinaryToC(pObjCpp, NULL, true); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__base64Binary *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__dateTime * axiscCallGetElementAsDateTime(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__dateTime *)NULL; |
| |
| try |
| { |
| return c->getElementAsDateTime(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__dateTime *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__date * axiscCallGetElementAsDate(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__date *)NULL; |
| |
| try |
| { |
| return c->getElementAsDate(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__date *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__time * axiscCallGetElementAsTime(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__time *)NULL; |
| |
| try |
| { |
| return c->getElementAsTime(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__time *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__duration * axiscCallGetElementAsDuration(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__duration *)NULL; |
| |
| try |
| { |
| return c->getElementAsDuration(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__duration *)NULL; |
| } |
| |
| |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__gYearMonth * axiscCallGetElementAsGYearMonth(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__gYearMonth *)NULL; |
| |
| try |
| { |
| return c->getElementAsGYearMonth(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__gYearMonth *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__gYear * axiscCallGetElementAsGYear(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__gYear *)NULL; |
| |
| try |
| { |
| return c->getElementAsGYear(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__gYear *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__gMonthDay * axiscCallGetElementAsGMonthDay(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__gMonthDay *)NULL; |
| |
| try |
| { |
| return c->getElementAsGMonthDay(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__gMonthDay *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__gDay * axiscCallGetElementAsGDay(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__gDay *)NULL; |
| |
| try |
| { |
| return c->getElementAsGDay(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__gDay *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__gMonth * axiscCallGetElementAsGMonth(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__gMonth *)NULL; |
| |
| try |
| { |
| return c->getElementAsGMonth(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__gMonth *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__nonPositiveInteger * axiscCallGetElementAsNonPositiveInteger(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__nonPositiveInteger *)NULL; |
| |
| try |
| { |
| return c->getElementAsNonPositiveInteger(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__nonPositiveInteger *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__negativeInteger * axiscCallGetElementAsNegativeInteger(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__negativeInteger *)NULL; |
| |
| try |
| { |
| return c->getElementAsNegativeInteger(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__negativeInteger *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__nonNegativeInteger * axiscCallGetElementAsNonNegativeInteger(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__nonNegativeInteger *)NULL; |
| |
| try |
| { |
| return c->getElementAsNonNegativeInteger(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__nonNegativeInteger *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__positiveInteger * axiscCallGetElementAsPositiveInteger(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__positiveInteger *)NULL; |
| |
| try |
| { |
| return c->getElementAsPositiveInteger(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__positiveInteger *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__normalizedString axiscCallGetElementAsNormalizedString(AXISCHANDLE call, const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__normalizedString)NULL; |
| |
| try |
| { |
| return c->getElementAsNormalizedString(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__normalizedString)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__token axiscCallGetElementAsToken(AXISCHANDLE call, const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__token)NULL; |
| |
| try |
| { |
| return c->getElementAsToken(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__token)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__language axiscCallGetElementAsLanguage(AXISCHANDLE call, const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__language)NULL; |
| |
| try |
| { |
| return c->getElementAsLanguage(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__language)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__Name axiscCallGetElementAsName(AXISCHANDLE call, const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__Name)NULL; |
| |
| try |
| { |
| return c->getElementAsName(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__Name)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__NCName axiscCallGetElementAsNCName(AXISCHANDLE call, const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__NCName)NULL; |
| |
| try |
| { |
| return c->getElementAsNCName(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__NCName)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__ID axiscCallGetElementAsID(AXISCHANDLE call, const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__ID)NULL; |
| |
| try |
| { |
| return c->getElementAsID(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__ID)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__IDREF axiscCallGetElementAsIDREF(AXISCHANDLE call, const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__IDREF)NULL; |
| |
| try |
| { |
| return c->getElementAsIDREF(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__IDREF)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__IDREFS axiscCallGetElementAsIDREFS(AXISCHANDLE call, const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__IDREFS)NULL; |
| |
| try |
| { |
| return c->getElementAsIDREFS(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__IDREFS)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__ENTITY axiscCallGetElementAsENTITY(AXISCHANDLE call, const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__ENTITY)NULL; |
| |
| try |
| { |
| return c->getElementAsENTITY(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__ENTITY)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__ENTITIES axiscCallGetElementAsENTITIES(AXISCHANDLE call, const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__ENTITIES)NULL; |
| |
| try |
| { |
| return c->getElementAsENTITIES(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__ENTITIES)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__NMTOKEN axiscCallGetElementAsNMTOKEN(AXISCHANDLE call, const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__NMTOKEN)NULL; |
| |
| try |
| { |
| return c->getElementAsNMTOKEN(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__NMTOKEN)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__NMTOKENS axiscCallGetElementAsNMTOKENS(AXISCHANDLE call, const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__NMTOKENS)NULL; |
| |
| try |
| { |
| return c->getElementAsNMTOKENS(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__NMTOKENS)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__NOTATION axiscCallGetElementAsNOTATION(AXISCHANDLE call, const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__NOTATION)NULL; |
| |
| try |
| { |
| return c->getElementAsNOTATION(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__NOTATION)NULL; |
| } |
| |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__anyType axiscCallGetElementAsAnyType(AXISCHANDLE call, const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__anyType)NULL; |
| |
| try |
| { |
| return c->getElementAsAnyType(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__anyType)NULL; |
| } |
| |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__int * axiscCallGetAttributeAsInt(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__int *)NULL; |
| |
| try |
| { |
| return c->getAttributeAsInt(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__int *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__boolean * axiscCallGetAttributeAsBoolean(AXISCHANDLE call, |
| const AxiscChar * pName, const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__boolean *)NULL; |
| |
| try |
| { |
| return (xsdc__boolean* )(c->getAttributeAsBoolean(pName,pNamespace)); |
| } |
| catch ( AxisException& e ) |
| { |
| |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__boolean *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__unsignedInt * axiscCallGetAttributeAsUnsignedInt(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__unsignedInt *)NULL; |
| |
| try |
| { |
| return c->getAttributeAsUnsignedInt(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__unsignedInt *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__short * axiscCallGetAttributeAsShort(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__short *)NULL; |
| |
| try |
| { |
| return c->getAttributeAsShort(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__short *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__unsignedShort * axiscCallGetAttributeAsUnsignedShort(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__unsignedShort *)NULL; |
| |
| try |
| { |
| return c->getAttributeAsUnsignedShort(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__unsignedShort *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__byte * axiscCallGetAttributeAsByte(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__byte *)NULL; |
| |
| try |
| { |
| return c->getAttributeAsByte(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__byte *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__unsignedByte * axiscCallGetAttributeAsUnsignedByte(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__unsignedByte *)NULL; |
| |
| try |
| { |
| return c->getAttributeAsUnsignedByte(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__unsignedByte *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__long * axiscCallGetAttributeAsLong(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__long *)NULL; |
| |
| try |
| { |
| return c->getAttributeAsLong(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__long *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__integer * axiscCallGetAttributeAsInteger(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__integer *)NULL; |
| |
| try |
| { |
| return c->getAttributeAsInteger(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__integer *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__unsignedLong * axiscCallGetAttributeAsUnsignedLong(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__unsignedLong *)NULL; |
| |
| try |
| { |
| return c->getAttributeAsUnsignedLong(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__unsignedLong *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__float * axiscCallGetAttributeAsFloat(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__float *)NULL; |
| |
| try |
| { |
| return c->getAttributeAsFloat(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__float *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__double * axiscCallGetAttributeAsDouble(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__double *)NULL; |
| |
| try |
| { |
| return c->getAttributeAsDouble(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__double *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__decimal * axiscCallGetAttributeAsDecimal(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__decimal *)NULL; |
| |
| try |
| { |
| return c->getAttributeAsDecimal(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__decimal *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__string axiscCallGetAttributeAsString(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__string)NULL; |
| |
| try |
| { |
| return c->getAttributeAsString(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__string)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__anyURI axiscCallGetAttributeAsAnyURI(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__anyURI)NULL; |
| |
| try |
| { |
| return c->getAttributeAsAnyURI(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__anyURI)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__QName axiscCallGetAttributeAsQName(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__QName)NULL; |
| |
| try |
| { |
| return c->getAttributeAsQName(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__QName)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__hexBinary * axiscCallGetAttributeAsHexBinary(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__hexBinary *)NULL; |
| |
| try |
| { |
| xsd__hexBinary * pObjCpp = c->getAttributeAsHexBinary(pName, pNamespace); |
| |
| return AxisObjectConverter::cppHexBinaryToC(pObjCpp, NULL, true); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__hexBinary *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__base64Binary * axiscCallGetAttributeAsBase64Binary(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__base64Binary *)NULL; |
| |
| try |
| { |
| xsd__base64Binary * pObjCpp = c->getAttributeAsBase64Binary(pName, pNamespace); |
| |
| return AxisObjectConverter::cppBase64BinaryToC(pObjCpp, NULL, true); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__base64Binary *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__dateTime * axiscCallGetAttributeAsDateTime(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__dateTime *)NULL; |
| |
| try |
| { |
| return c->getAttributeAsDateTime(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__dateTime *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__date * axiscCallGetAttributeAsDate(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__date *)NULL; |
| |
| try |
| { |
| return c->getAttributeAsDate(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__date *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__time * axiscCallGetAttributeAsTime(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__time *)NULL; |
| |
| try |
| { |
| return c->getAttributeAsTime(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| return (xsdc__time *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__duration * axiscCallGetAttributeAsDuration(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__duration *)NULL; |
| |
| try |
| { |
| return c->getAttributeAsDuration(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__duration *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__gYearMonth * axiscCallGetAttributeAsGYearMonth(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__gYearMonth *)NULL; |
| |
| try |
| { |
| return c->getAttributeAsGYearMonth(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__gYearMonth *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__gYear * axiscCallGetAttributeAsGYear(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__gYear *)NULL; |
| |
| try |
| { |
| return c->getAttributeAsGYear(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__gYear *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__gMonthDay * axiscCallGetAttributeAsGMonthDay(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__gMonthDay *)NULL; |
| |
| try |
| { |
| return c->getAttributeAsGMonthDay(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__gMonthDay *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__gDay * axiscCallGetAttributeAsGDay(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__gDay *)NULL; |
| |
| try |
| { |
| return c->getAttributeAsGDay(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__gDay *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__gMonth * axiscCallGetAttributeAsGMonth(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__gMonth *)NULL; |
| |
| try |
| { |
| return c->getAttributeAsGMonth(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__gMonth *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__nonPositiveInteger * axiscCallGetAttributeAsNonPositiveInteger(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__nonPositiveInteger *)NULL; |
| |
| try |
| { |
| return c->getAttributeAsNonPositiveInteger(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__nonPositiveInteger *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__negativeInteger * axiscCallGetAttributeAsNegativeInteger(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__negativeInteger *)NULL; |
| |
| try |
| { |
| return c->getAttributeAsNegativeInteger(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__negativeInteger *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__nonNegativeInteger * axiscCallGetAttributeAsNonNegativeInteger(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__nonNegativeInteger *)NULL; |
| |
| try |
| { |
| return c->getAttributeAsNonNegativeInteger(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__nonNegativeInteger *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__positiveInteger * axiscCallGetAttributeAsPositiveInteger(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__positiveInteger *)NULL; |
| |
| try |
| { |
| return c->getAttributeAsPositiveInteger(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__positiveInteger *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__normalizedString axiscCallGetAttributeAsNormalizedString(AXISCHANDLE call, const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__normalizedString)NULL; |
| |
| try |
| { |
| return c->getAttributeAsNormalizedString(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__normalizedString)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__token axiscCallGetAttributeAsToken(AXISCHANDLE call, const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__token)NULL; |
| |
| try |
| { |
| return c->getAttributeAsToken(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__token)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__language axiscCallGetAttributeAsLanguage(AXISCHANDLE call, const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__language)NULL; |
| |
| try |
| { |
| return c->getAttributeAsLanguage(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__language)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__Name axiscCallGetAttributeAsName(AXISCHANDLE call, const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__Name)NULL; |
| |
| try |
| { |
| return c->getAttributeAsName(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__Name)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__NCName axiscCallGetAttributeAsNCName(AXISCHANDLE call, const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__NCName)NULL; |
| |
| try |
| { |
| return c->getAttributeAsNCName(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__NCName)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__ID axiscCallGetAttributeAsID(AXISCHANDLE call, const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__ID)NULL; |
| |
| try |
| { |
| return c->getAttributeAsID(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__ID)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__IDREF axiscCallGetAttributeAsIDREF(AXISCHANDLE call, const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__IDREF)NULL; |
| |
| try |
| { |
| return c->getAttributeAsIDREF(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__IDREF)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__IDREFS axiscCallGetAttributeAsIDREFS(AXISCHANDLE call, const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__IDREFS)NULL; |
| |
| try |
| { |
| return c->getAttributeAsIDREFS(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__IDREFS)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__ENTITY axiscCallGetAttributeAsENTITY(AXISCHANDLE call, const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__ENTITY)NULL; |
| |
| try |
| { |
| return c->getAttributeAsENTITY(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__ENTITY)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__ENTITIES axiscCallGetAttributeAsENTITIES(AXISCHANDLE call, const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__ENTITIES)NULL; |
| |
| try |
| { |
| return c->getAttributeAsENTITIES(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__ENTITIES)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__NMTOKEN axiscCallGetAttributeAsNMTOKEN(AXISCHANDLE call, const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__NMTOKEN)NULL; |
| |
| try |
| { |
| return c->getAttributeAsNMTOKEN(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__NMTOKEN)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__NMTOKENS axiscCallGetAttributeAsNMTOKENS(AXISCHANDLE call, const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__NMTOKENS)NULL; |
| |
| try |
| { |
| return c->getAttributeAsNMTOKENS(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__NMTOKENS)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__NOTATION axiscCallGetAttributeAsNOTATION(AXISCHANDLE call, const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__NOTATION)NULL; |
| |
| try |
| { |
| return c->getAttributeAsNOTATION(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__NOTATION)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| void * axiscCallGetCmplxObject(AXISCHANDLE call, |
| void * pDZFunct, |
| void * pCreFunct, |
| void * pDelFunct, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return NULL; |
| |
| try |
| { |
| return c->getCmplxObject(pDZFunct,pCreFunct,pDelFunct,pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| Axisc_Array* axiscCallGetCmplxArray(AXISCHANDLE call, |
| Axisc_Array* pArray, |
| void * pDZFunct, |
| void * pCreFunct, |
| void * pDelFunct, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (Axisc_Array *)NULL; |
| |
| try |
| { |
| Axis_Array ObjArray; |
| Axis_Array *pObjArray; |
| |
| if (pArray) |
| ObjArray.set(pArray->m_Array, pArray->m_Size, (XSDTYPE)pArray->m_Type); |
| |
| pObjArray = c->getCmplxArray(&ObjArray, |
| pDZFunct, pCreFunct,pDelFunct, pName, pNamespace); |
| |
| return AxisObjectConverter::cppArrayToC(pObjArray, pArray, false); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (Axisc_Array *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| Axisc_Array* axiscCallGetBasicArray(AXISCHANDLE call, |
| AXISC_XSDTYPE nType, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (Axisc_Array *)NULL; |
| |
| try |
| { |
| Axis_Array *pObjArray = c->getBasicArray((XSDTYPE)nType, pName, pNamespace); |
| |
| return AxisObjectConverter::cppArrayToC(pObjArray, NULL, true); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (Axisc_Array *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| int axiscCallCheckMessage(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| return axiscCallValidateMessage(call, pName, pNamespace, 1); |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| int axiscCallValidateMessage( AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace, |
| AxiscBool consumeIt) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return -1; |
| |
| try |
| { |
| return c->validateMessage(pName,pNamespace, (bool)(consumeIt != 0)); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return -1; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| void axiscCallGetChardataAs(AXISCHANDLE call, |
| void** pValue, |
| AXISC_XSDTYPE type) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| { |
| *pValue = NULL; |
| return; |
| } |
| |
| try |
| { |
| return c->getChardataAs( pValue, (XSDTYPE)type); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| void * axiscCallCheckFault(AXISCHANDLE call, |
| const AxiscChar * pName, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| |
| try |
| { |
| return c->checkFault(pName,pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| int axiscCallGetStatus(AXISCHANDLE call) |
| { |
| Call *c = (Call*)call; |
| |
| try |
| { |
| return c->getStatus(); |
| } |
| catch ( AxisException& e ) |
| { |
| |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return -1; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| AXISCHANDLE axiscCallGetSOAPSerializer(AXISCHANDLE call) |
| { |
| Call *c = (Call*)call; |
| |
| try |
| { |
| return (AXISCHANDLE)(c->getSOAPSerializer()); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| void axiscCallSetProxy(AXISCHANDLE call, |
| const char * pcProxyHost, |
| unsigned int uiProxyPort) |
| { |
| Call *c = (Call*)call; |
| |
| try |
| { |
| c->setProxy(pcProxyHost,uiProxyPort); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| AxiscAnyType * axiscCallGetAnyObject(AXISCHANDLE call) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (AxiscAnyType *)NULL; |
| |
| try |
| { |
| AnyType * pObjCpp = c->getAnyObject(); |
| |
| return AxisObjectConverter::cppAnyTypeToC(pObjCpp, NULL, true); |
| } |
| catch ( AxisException& e ) |
| { |
| |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (AxiscAnyType *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| int axiscCallAddAnyObject(AXISCHANDLE call, |
| AxiscAnyType * pAnyObject) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return -1; |
| |
| try |
| { |
| AnyType objAnyType; |
| |
| if (pAnyObject && pAnyObject->_size > 0) |
| { |
| objAnyType._size = pAnyObject->_size; |
| objAnyType._array = pAnyObject->_array; |
| } |
| |
| int returnCode = c->addAnyObject(&objAnyType); |
| |
| // Reset object so it will not free memory. |
| objAnyType._size = 0; |
| objAnyType._array = NULL; |
| |
| return returnCode; |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return -1; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| const AxiscChar * axiscCallGetNamespacePrefix(AXISCHANDLE call, |
| const AxiscChar * pNamespace) |
| { |
| Call *c = (Call*)call; |
| |
| try |
| { |
| return c->getNamespacePrefix(pNamespace); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (AxiscChar *)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| void axiscCallSetSOAPMethodAttribute(AXISCHANDLE call, |
| const AxiscChar * pLocalname, |
| const AxiscChar * pPrefix, |
| const AxiscChar * pUri, |
| const AxiscChar * pValue) |
| { |
| Call *c = (Call*)call; |
| |
| try |
| { |
| c->setSOAPMethodAttribute(pLocalname,pPrefix,pUri,pValue); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| void axiscCallClearSOAPMethodAttributes(AXISCHANDLE call) |
| { |
| Call *c = (Call*)call; |
| |
| try |
| { |
| c->clearSOAPMethodAttributes(); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| } |
| |
| |
| AXISC_STORAGE_CLASS_INFO |
| xsdc__string axiscCallGetFaultAsXMLString(AXISCHANDLE call) |
| { |
| Call *c = (Call*)call; |
| StubC *s = (StubC *)c->getCStub(); |
| if (s && s->doNotPerformClientRequest) |
| return (xsdc__string)NULL; |
| |
| try |
| { |
| return c->getFaultAsXMLString(); |
| } |
| catch ( AxisException& e ) |
| { |
| processException(c, e); |
| } |
| catch ( ... ) |
| { |
| axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL); |
| } |
| |
| return (xsdc__string)NULL; |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| void axiscCallSetCStub(AXISCHANDLE call, void *pStub) |
| { |
| Call *c = (Call*)call; |
| c->setCStub(pStub); |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| void *axiscCallGetCStub(AXISCHANDLE call) |
| { |
| Call *c = (Call*)call; |
| return c->getCStub(); |
| } |
| |
| AXISC_STORAGE_CLASS_INFO |
| void axiscCallSetSoapFaultNamespace(AXISCHANDLE call, const char * pSoapFaultNamespace) |
| { |
| Call *c = (Call*)call; |
| c->setSoapFaultNamespace(pSoapFaultNamespace); |
| } |
| |
| |
| AXISC_STORAGE_CLASS_INFO |
| void axiscCallAddSoapFaultToList(AXISCHANDLE call, |
| const char * faultName, |
| void * createFp, |
| void * deleteFp, |
| void * deserializerFp) |
| { |
| Call *c = (Call*)call; |
| c->addSoapFaultToList(faultName, createFp, deleteFp, deserializerFp); |
| } |
| |
| |
| |
| |
| |
| } |
