| |
| /* |
| * 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 <list> |
| #include <iostream> |
| |
| #include <axis/Axis.hpp> |
| #include <axis/GDefine.hpp> |
| |
| #include "SoapDeSerializer.h" |
| #include "SoapEnvelope.h" |
| #include "SoapKeywordMapping.h" |
| #include "URIMapping.h" |
| #include "SoapHeader.h" |
| #include "SoapMethod.h" |
| #include "SoapBody.h" |
| #include "SoapFault.h" |
| #include "ComplexElement.h" |
| #include "CharacterElement.h" |
| #include "apr_base64.h" |
| #include "HexCoder.h" |
| #include "../engine/XMLParserFactory.h" |
| #include "../xml/XMLParser.h" |
| #include "../xml/QName.h" |
| #include "../xml/AxisParseException.h" |
| #include "AxisSoapException.h" |
| #include "../common/AxisGenException.h" |
| |
| #include "../common/AxisTrace.h" |
| |
| |
| |
| AxisChar * pBodyContent; |
| |
| AXIS_CPP_NAMESPACE_START |
| |
| SoapDeSerializer:: |
| SoapDeSerializer () |
| { |
| logEntryEngine("SoapDeSerializer::SoapDeSerializer") |
| |
| m_pParser = XMLParserFactory::getParserObject (); |
| m_pEnv = NULL; |
| m_pHeader = NULL; |
| m_pCurrNode = NULL; |
| m_pNode = NULL; |
| m_pInputStream = NULL; |
| m_nStatus = AXIS_SUCCESS; |
| m_nSoapVersion = VERSION_LAST; |
| |
| m_doNotSkip = false; |
| m_pStub = NULL; |
| |
| logExit() |
| } |
| |
| SoapDeSerializer:: |
| ~SoapDeSerializer () |
| { |
| logEntryEngine("SoapDeSerializer::~SoapDeSerializer") |
| |
| delete m_pEnv; |
| delete m_pHeader; |
| if (m_pParser) |
| XMLParserFactory::destroyParserObject (m_pParser); |
| delete pBodyContent; |
| |
| logExit() |
| } |
| |
| int SoapDeSerializer:: |
| setInputStream (SOAPTransport * pInputStream) |
| { |
| logEntryEngine("SoapDeSerializer::setInputStream") |
| |
| int iStatus = AXIS_FAIL; |
| |
| if (NULL != pInputStream) |
| { |
| m_pInputStream = pInputStream; |
| iStatus = m_pParser->setInputStream (pInputStream); |
| } |
| |
| logExitWithReturnCode(iStatus) |
| |
| return iStatus; |
| } |
| |
| /* |
| * Routine to help obtain parser information and throw it as an exception |
| */ |
| void SoapDeSerializer:: |
| throwParserException() |
| { |
| logEntryEngine("SoapDeSerializer::throwParserException") |
| |
| AxisParseException e; |
| |
| if (m_pParser->getStatus() != AXIS_SUCCESS) |
| e.setMessage(m_pParser->getErrorCode(), "AxisParseException:", m_pParser->getErrorString()); |
| else |
| e.setMessage(SERVER_PARSE_PARSER_FAILED, "AxisParseException:"); |
| |
| logThrowExceptionWithData("AxisParseException", e.what()) |
| |
| throw e; |
| } |
| |
| /* |
| * Routine that handles getting next node, in the future when we sync |
| * up rpc and doc processing and eliminate peek, we should be able to |
| * get rid of the first parameter! |
| */ |
| int SoapDeSerializer:: |
| getNextNode(bool ifNotSet, bool characterMode, bool throwExcOnError) |
| { |
| logSetFunctionNameEngine("SoapDeSerializer::getNextNode") |
| |
| int iStatus = AXIS_FAIL; |
| |
| // If node pointer is set and user requested that we |
| // only get next element if not set, return. |
| if (ifNotSet && m_pNode) |
| iStatus = AXIS_SUCCESS; |
| else |
| { |
| // Ensure m_pNode is NULL before calling parser in case of exceptions. |
| m_pNode = NULL; |
| |
| // Just a sanity check |
| if (m_pParser) |
| { |
| try |
| { |
| m_pNode = m_pParser->next(characterMode); |
| } |
| catch (AxisException &e) |
| { |
| m_nStatus = AXIS_FAIL; |
| if (throwExcOnError) |
| throw e; |
| } |
| |
| // If no node obtained, either there is no more data to read (at this time |
| // we treat this as an error but we do not throw an exception for this) or the |
| // parser had an exception, in which case we throw an exception if requested. |
| if (!m_pNode) |
| { |
| m_nStatus = AXIS_FAIL; |
| if (throwExcOnError && (AXIS_FAIL == m_pParser->getStatus())) |
| throwParserException(); |
| } |
| else |
| iStatus = AXIS_SUCCESS; |
| } |
| } |
| |
| if (AXIS_SUCCESS != iStatus) |
| { |
| logDebug("Status being returned is AXIS_FAIL") |
| } |
| |
| return iStatus; |
| } |
| |
| |
| /* |
| * Routine that ensures we are actually skipping the expected node...usually an end node. |
| */ |
| int SoapDeSerializer:: |
| skipNode(bool verifyIfEndNode, bool throwExcOnError) |
| { |
| logEntryEngine("SoapDeSerializer::skipNode") |
| |
| int rc = getNextNode(false, false, throwExcOnError); |
| |
| if (rc == AXIS_SUCCESS) |
| { |
| if (verifyIfEndNode) |
| { |
| // TODO add code to determine if in fact |
| // TODO the node we are about to skip is an end node. If not, we need |
| // TODO to throw an exception since there could be extra elements that |
| // TODO is due to server/client differences in wsdl being used, etc. |
| // TODO in addition, a check is another safeguard. |
| } |
| |
| m_pNode = NULL; |
| } |
| |
| logExitWithReturnCode(rc) |
| |
| return rc; |
| } |
| |
| SoapEnvelope *SoapDeSerializer:: |
| getEnvelope () |
| { |
| logEntryEngine("SoapDeSerializer::getEnvelope") |
| |
| if (AXIS_FAIL == getNextNode(true)) |
| { |
| logExitWithPointer(NULL) |
| |
| return NULL; |
| } |
| |
| // Better be a start-element. |
| if (START_ELEMENT != m_pNode->m_type) |
| { |
| m_nStatus = AXIS_FAIL; |
| |
| logThrowExceptionWithData("AxisSoapException - CLIENT_SOAP_SOAP_CONTENT_ERROR", "Start-element for SOAP Envelope not found.") |
| |
| throw AxisSoapException (CLIENT_SOAP_SOAP_CONTENT_ERROR, "Start-element for SOAP Envelope not found."); |
| } |
| |
| // We are expecting a SOAP envelope. |
| if (0 != strcmp(m_pNode->m_pchNameOrValue,SoapKeywordMapping::map(SOAP_VER_1_2).pchWords[SKW_ENVELOPE])) |
| { |
| m_nStatus = AXIS_FAIL; |
| |
| logThrowExceptionWithData("AxisSoapException - CLIENT_SOAP_SOAP_CONTENT_ERROR", "Element is not a SOAP Envelope.") |
| |
| throw AxisSoapException (CLIENT_SOAP_SOAP_CONTENT_ERROR, "Element is not a SOAP Envelope."); |
| } |
| |
| // No try/catch block needed here since we already have the node |
| SoapEnvelope *m_pEnvl = new SoapEnvelope (); |
| |
| // set all attributes of SoapEnvelope |
| std::list<Attribute*> attributeList0; |
| Attribute * pAttr = new Attribute ( attributeList0); |
| |
| pAttr->setValue (m_pNode->m_pchNamespace); |
| m_pEnvl->addNamespaceDecl (pAttr); |
| |
| if (0 == strcmp (m_pNode->m_pchNamespace, SoapKeywordMapping::map (SOAP_VER_1_1).pchNamespaceUri)) |
| m_nSoapVersion = SOAP_VER_1_1; |
| else if (0 == strcmp (m_pNode->m_pchNamespace, SoapKeywordMapping::map (SOAP_VER_1_2).pchNamespaceUri)) |
| m_nSoapVersion = SOAP_VER_1_2; |
| else |
| m_nSoapVersion = VERSION_LAST; |
| |
| // Set Attributes |
| for (int i = 0; m_pNode->m_pchAttributes[i]; i += 3) |
| { |
| std::list<Attribute*> attributeList1; |
| pAttr = new Attribute (attributeList1); |
| pAttr->setLocalName (m_pNode->m_pchAttributes[i]); |
| pAttr->setURI (m_pNode->m_pchAttributes[i + 1]); |
| pAttr->setValue (m_pNode->m_pchAttributes[i + 2]); |
| m_pEnvl->addAttribute (pAttr); |
| } |
| |
| // indicate node consumed and return envelope |
| m_pNode = NULL; |
| |
| logExitWithPointer(m_pEnvl) |
| |
| return m_pEnvl; |
| } |
| |
| /* |
| * Header block parsing should be done differently for different SOAP versions. |
| * Since the Header blocks may be requested in a different order than it is in |
| * the SOAP stream there must be a mechanism to manage the situation. Possibly |
| * to re-parse the stream part which has unused header blocks. |
| */ |
| IHeaderBlock *SoapDeSerializer:: |
| getHeaderBlock (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| logEntryEngine("SoapDeSerializer::getHeaderBlock") |
| |
| IHeaderBlock * returnValue = NULL; |
| |
| if (m_pHeader) |
| returnValue = m_pHeader->getHeaderBlock (pName, pNamespace, true); |
| |
| logExitWithPointer(returnValue) |
| |
| return returnValue; |
| } |
| |
| int SoapDeSerializer:: |
| getHeader () |
| { |
| logEntryEngine("SoapDeSerializer::getHeader") |
| |
| if (m_pHeader || AXIS_FAIL == getNextNode()) |
| { |
| logExitWithReturnCode(m_nStatus) |
| |
| return m_nStatus; |
| } |
| |
| if ((START_ELEMENT == m_pNode->m_type) |
| && (m_nSoapVersion != VERSION_LAST) |
| && (0 == strcmp (m_pNode->m_pchNameOrValue,SoapKeywordMapping::map (m_nSoapVersion).pchWords[SKW_HEADER]))) |
| { |
| delete m_pHeader; |
| m_pHeader = new SoapHeader (); |
| |
| // Set any attributes/namspaces to the SoapHeader object |
| while (true) |
| { |
| if (AXIS_FAIL == getNextNode(false, true, false)) |
| break; |
| |
| if ((END_ELEMENT == m_pNode->m_type) && |
| (0 == strcmp (m_pNode->m_pchNameOrValue,SoapKeywordMapping::map (m_nSoapVersion).pchWords[SKW_HEADER]))) |
| { |
| m_pNode = NULL; // indicate node consumed |
| break; |
| } |
| |
| // following is done to ignore anything (eg : the toplevel whitespaces) but a start element. |
| if (START_ELEMENT != m_pNode->m_type) |
| { |
| m_pNode = NULL; // indicate node consumed |
| continue; |
| } |
| |
| HeaderBlock *pHeaderBlock = new HeaderBlock (); |
| |
| if (m_pNode->m_pchNamespace) |
| pHeaderBlock->setURI (m_pNode->m_pchNamespace); |
| |
| pHeaderBlock->setLocalName (m_pNode->m_pchNameOrValue); |
| |
| if ((m_pNode->m_pchAttributes[0]) != NULL) |
| { |
| int iAttributeArrayIndex = 0; |
| |
| while (true) |
| { |
| std::list<Attribute*> attributeList2; |
| Attribute *pAttribute = new Attribute (attributeList2); |
| pAttribute->setLocalName (m_pNode->m_pchAttributes[iAttributeArrayIndex++]); |
| pAttribute->setURI (m_pNode->m_pchAttributes[iAttributeArrayIndex++]); |
| pAttribute->setValue (m_pNode->m_pchAttributes[iAttributeArrayIndex++]); |
| |
| pHeaderBlock->addAttribute (pAttribute); |
| |
| if (m_pNode->m_pchAttributes[iAttributeArrayIndex] == '\0') |
| break; |
| } |
| } |
| |
| BasicNode *pNodeList[10]; |
| pNodeList[0] = NULL; |
| int iListPos = 0; |
| int iLevel = 0; |
| |
| while (true) |
| { |
| if (AXIS_FAIL == getNextNode(false, true, false)) |
| break; |
| |
| if (END_ELEMENT == m_pNode->m_type) |
| { |
| if (iLevel == 0) |
| { |
| //do nothing |
| m_pHeader->addHeaderBlock (pHeaderBlock); |
| break; |
| } |
| else if (iLevel == 1) |
| { |
| if ((pNodeList[0]) != NULL) |
| { |
| pHeaderBlock->addChild (pNodeList[0]); |
| iListPos--; |
| iLevel--; |
| } |
| } |
| else |
| { |
| (pNodeList[iListPos - 2])->addChild (pNodeList[iListPos - 1]); |
| iListPos--; |
| iLevel--; |
| } |
| } |
| else if (START_ELEMENT == m_pNode->m_type) |
| { |
| //createBaisNode and setValue |
| BasicNode *pComplexElement = new ComplexElement (); |
| |
| if (m_pNode->m_pchNamespace) |
| pComplexElement->setURI (m_pNode->m_pchNamespace); |
| |
| pComplexElement->setLocalName (m_pNode->m_pchNameOrValue); |
| |
| //addtoList |
| pNodeList[iListPos] = pComplexElement; |
| iListPos++; |
| iLevel++; |
| } |
| else if (CHARACTER_ELEMENT == m_pNode->m_type) |
| { |
| //createBasicNode and setValue |
| BasicNode *pBasicNode = new CharacterElement (m_pNode->m_pchNameOrValue); |
| |
| //addToImmidiateParent |
| if (iLevel == 0) |
| pHeaderBlock->addChild (pBasicNode); |
| else |
| (pNodeList[iListPos - 1])->addChild (pBasicNode); |
| } |
| } // end while |
| } |
| } |
| |
| logExitWithReturnCode(m_nStatus) |
| |
| return m_nStatus; |
| } |
| |
| // This method adds to allow "all" & "choice" constructs to peek head next element. |
| const char*SoapDeSerializer:: |
| peekNextElementName () |
| { |
| logEntryEngine("SoapDeSerializer::peekNextElementName") |
| |
| const char*name = NULL; |
| |
| if (m_pParser) |
| name = m_pParser->peek (); |
| |
| logExitWithString(name) |
| |
| return name; |
| } |
| |
| int SoapDeSerializer:: |
| getBody () |
| { |
| logEntryEngine("SoapDeSerializer::getBody") |
| |
| int iStatus = AXIS_FAIL; |
| |
| if (AXIS_FAIL == getNextNode(true)) |
| iStatus = m_nStatus; |
| else |
| { |
| // previous header searching may have left a node unidentified |
| if ((START_ELEMENT == m_pNode->m_type) |
| && (m_nSoapVersion != VERSION_LAST) |
| && (0 == strcmp (m_pNode->m_pchNameOrValue,SoapKeywordMapping::map (m_nSoapVersion).pchWords[SKW_BODY]))) |
| { |
| // indicate node consumed |
| m_pNode = NULL; |
| |
| // peek for the method name |
| m_strMethodNameToInvoke = m_pParser->peek(); |
| |
| iStatus = AXIS_SUCCESS; |
| } |
| } |
| |
| logExitWithReturnCode(iStatus) |
| |
| return iStatus; |
| } |
| |
| int SoapDeSerializer:: |
| checkMessageBody (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| return validateMessageBody(pName, pNamespace, true); |
| } |
| |
| int SoapDeSerializer:: |
| validateMessageBody(const AxisChar * pName, const AxisChar * pNamespace, bool consumeIt) |
| { |
| logEntryEngine("SoapDeSerializer::validateMessageBody") |
| |
| int iStatus = AXIS_FAIL; |
| |
| // Will throw exception if failure in parser |
| if (AXIS_FAIL != getNextNode(true)) |
| { |
| if (START_ELEMENT != m_pNode->m_type) |
| { |
| logThrowExceptionWithData("AxisSoapException - CLIENT_SOAP_SOAP_CONTENT_ERROR", "Start-element was not found.") |
| |
| throw AxisSoapException (CLIENT_SOAP_SOAP_CONTENT_ERROR, "Start-element was not found."); |
| } |
| |
| // If a fault has occurred or the node name is unexpected, throw exception |
| // deserialize it as doc literal by setting style. |
| if (0 != strcmp (m_pNode->m_pchNameOrValue, pName)) |
| { |
| setStyle (DOC_LITERAL); |
| |
| logThrowException("AxisGenException - AXISC_NODE_VALUE_MISMATCH_EXCEPTION") |
| |
| throw AxisGenException (AXISC_NODE_VALUE_MISMATCH_EXCEPTION); |
| } |
| |
| // indicate node consumed |
| if (consumeIt) |
| m_pNode = NULL; |
| |
| iStatus = AXIS_SUCCESS; |
| } |
| |
| logExitWithReturnCode(iStatus) |
| |
| return iStatus; |
| } |
| |
| // Used for one-way message processing, to initiate a fault. |
| void SoapDeSerializer:: |
| initiateFault (const AxisChar * pNamespace) |
| { |
| logEntryEngine("SoapDeSerializer::initiateFault") |
| |
| // Will throw exception if failure in parser |
| if (AXIS_FAIL != getNextNode(true)) |
| { |
| if (START_ELEMENT != m_pNode->m_type) |
| { |
| logThrowExceptionWithData("AxisSoapException - CLIENT_SOAP_SOAP_CONTENT_ERROR", "Start-element was not found.") |
| |
| throw AxisSoapException (CLIENT_SOAP_SOAP_CONTENT_ERROR, "Start-element was not found."); |
| } |
| |
| setStyle (DOC_LITERAL); |
| |
| logThrowException("AxisGenException - AXISC_NODE_VALUE_MISMATCH_EXCEPTION") |
| |
| throw AxisGenException (AXISC_NODE_VALUE_MISMATCH_EXCEPTION); |
| } |
| |
| logExit() |
| } |
| |
| void *SoapDeSerializer:: |
| checkForFault (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| logEntryEngine("SoapDeSerializer::checkForFault") |
| |
| if (0 != strcmp ("Fault", pName)) |
| { |
| logThrowExceptionWithData("AxisGenException - AXISC_NODE_VALUE_MISMATCH_EXCEPTION", "Fault element name not valid.") |
| |
| throw AxisGenException (AXISC_NODE_VALUE_MISMATCH_EXCEPTION, |
| "Fault element name not valid."); |
| } |
| |
| if (0 != strcmp (m_pNode->m_pchNameOrValue, pName)) |
| { |
| m_nStatus = AXIS_SUCCESS; |
| m_pNode = NULL; |
| |
| logThrowException("AxisGenException - AXISC_NODE_VALUE_MISMATCH_EXCEPTION") |
| |
| throw AxisGenException (AXISC_NODE_VALUE_MISMATCH_EXCEPTION); |
| } |
| |
| char *pcDetail = NULL; |
| char *pcFaultCode = NULL; |
| char *pcFaultstring = NULL; |
| char *pcFaultactor = NULL; |
| |
| SoapFault *pFault = new SoapFault (); |
| pFault->setDeSerializer (this); |
| |
| // indicate node consumed |
| m_nStatus = AXIS_SUCCESS; |
| m_pNode = NULL; |
| |
| // We deserialize fault code in doc literal. |
| m_nStyle = getStyle (); |
| setStyle (DOC_LITERAL); |
| |
| // getElement or peek will throw exceptions, so need to clean up memory allocations |
| try |
| { |
| // Get fault code |
| pcFaultCode = getElementAsString ("faultcode", 0); |
| pFault->setFaultcode (pcFaultCode == NULL ? "" : pcFaultCode); |
| delete [] pcFaultCode; |
| |
| // Get fault string |
| pcFaultstring = getElementAsString ("faultstring", 0); |
| pFault->setFaultstring (pcFaultstring == NULL ? "" : pcFaultstring); |
| delete [] pcFaultstring; |
| |
| // faultactor is optional |
| const char* elementName = peekNextElementName(); |
| if (strcmp(elementName, "faultactor") == 0) |
| { |
| pcFaultactor = getElementAsString ("faultactor", 0); |
| pFault->setFaultactor (pcFaultactor == NULL ? "" : pcFaultactor); |
| delete [] pcFaultactor; |
| } |
| |
| // detail is optional. |
| // Changed the namespace from null to a single space (an impossible |
| // value) to help method know that it is parsing a fault message. |
| elementName = peekNextElementName(); |
| if (strcmp(elementName, "detail") == 0) |
| { |
| pcDetail = getElementAsString ("detail", " "); |
| |
| if (pcDetail) |
| { |
| pFault->setFaultDetail (pcDetail); |
| delete [] pcDetail; |
| } |
| else |
| { |
| const char *pcCmplxFaultName = ""; |
| |
| if ((AXIS_SUCCESS == getNextNode(true)) && m_pNode->m_pchNameOrValue) |
| pcCmplxFaultName = m_pNode->m_pchNameOrValue; |
| |
| pFault->setCmplxFaultObjectName (pcCmplxFaultName); |
| } |
| } |
| } |
| catch ( ... ) |
| { |
| setStyle (m_nStyle); |
| |
| delete [] pcFaultCode; |
| delete [] pcFaultstring; |
| delete [] pcFaultactor; |
| delete [] pcDetail; |
| delete pFault; |
| |
| logRethrowException() |
| |
| throw; |
| } |
| |
| setStyle (m_nStyle); |
| |
| logExitWithPointer(pFault) |
| |
| return pFault; |
| } |
| |
| int SoapDeSerializer:: |
| init () |
| { |
| logEntryEngine("SoapDeSerializer::init") |
| |
| m_pNode = NULL; |
| m_pCurrNode = NULL; |
| |
| delete m_pEnv; |
| m_pEnv = NULL; |
| |
| delete m_pHeader; |
| m_pHeader = NULL; |
| |
| m_nSoapVersion = VERSION_LAST; |
| m_nStatus = AXIS_SUCCESS; |
| |
| m_pStub = NULL; |
| |
| logExitWithReturnCode(m_nStatus) |
| |
| return m_nStatus; |
| } |
| |
| int SoapDeSerializer:: |
| getVersion () |
| { |
| logEntryEngine("SoapDeSerializer::getVersion") |
| |
| if (VERSION_LAST == m_nSoapVersion) |
| { |
| delete m_pEnv; |
| m_pEnv = NULL; |
| m_pEnv = getEnvelope (); |
| } |
| |
| logExitWithInteger(m_nSoapVersion) |
| |
| return m_nSoapVersion; |
| } |
| |
| /* |
| * Get Size of the single dimension array from arrayType attribute |
| * Ex : enc:arrayType="xs:string[6]" |
| * RPC/Encoded only processing. |
| */ |
| int SoapDeSerializer:: |
| getArraySize () |
| { |
| logEntryEngine("SoapDeSerializer::getArraySize") |
| |
| int nSize = 0; |
| |
| // If not RPC or failure in getNextNode, return zero. |
| if (RPC_ENCODED != m_nStyle || (AXIS_FAIL == getNextNode())) |
| { |
| logExitWithInteger(nSize) |
| |
| return nSize; |
| } |
| |
| // first check whether this is a start element node |
| if (START_ELEMENT == m_pNode->m_type) |
| { |
| // If start-end element, then empty array |
| if (START_END_ELEMENT == m_pNode->m_type2) |
| { |
| skipNode(); |
| |
| logExitWithInteger(nSize) |
| |
| return nSize; |
| } |
| } |
| else if (END_ELEMENT == m_pNode->m_type) |
| { |
| logExitWithInteger(nSize) |
| |
| return nSize; |
| } |
| |
| for (int i = 0; m_pNode->m_pchAttributes[i]; i += 3) |
| { |
| if (URI_ENC == URIMapping::getURI (m_pNode->m_pchAttributes[i + 1]) |
| && (0 == strcmp (m_pNode->m_pchAttributes[i], |
| SoapKeywordMapping::map (m_nSoapVersion).pchWords[SKW_ARRAYTYPE]))) |
| { |
| QName qn; |
| |
| qn.splitQNameString (m_pNode->m_pchAttributes[i + 2], '['); |
| nSize = strtol (qn.localname, &m_pEndptr, 10); |
| qn.mergeQNameString ('['); |
| |
| if (nSize == 0) |
| skipNode(); |
| |
| logExitWithInteger(nSize) |
| |
| return nSize; |
| } |
| } |
| |
| logExitWithInteger(nSize) |
| |
| return nSize; |
| } |
| |
| |
| /* |
| * In rpc/encoded style the stream is as follows, |
| * <abc:ArrayOfPoints xmlns:abc="http://www.opensource.lk/Points" |
| * xmlns:enc="http://www.w3.org/2001/06/soap-encoding" |
| * enc:arrayType="xsd:Point[2]"> |
| * <abc:Point><x>5</x><y>6</y></abc:Point> |
| * <abc:Point><x>7</x><y>8</y></abc:Point> |
| * </abc:ArrayOfPoints> |
| * But in doc/literal style it is, |
| * <points><x>5</x><y>6</y></points> |
| * <points><x>7</x><y>8</y></points> |
| * |
| */ |
| |
| Axis_Array *SoapDeSerializer:: |
| getCmplxArray (Axis_Array* pArray, |
| void *pDZFunct, void *pCreFunct, void *pDelFunct, |
| const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| logEntryEngine("SoapDeSerializer::getCmplxArray") |
| |
| // if anything has gone wrong earlier just do nothing |
| if (AXIS_SUCCESS == m_nStatus) |
| { |
| // Loop through the array adding elements. |
| int arraySize = getArraySize (); |
| int count = 0; |
| const char* elementName; |
| |
| while(RPC_ENCODED != m_nStyle || count < arraySize) |
| { |
| // For RPC-encoded arrays, the element name in array cannot be derived - |
| // within an array value element names are not significant - so |
| // we read until end-of-element is encountered (i.e. null string |
| // is returned from peek()). |
| elementName = m_pParser->peek(); |
| if ((RPC_ENCODED == m_nStyle && 0x00 != *elementName) || strcmp(elementName, pName) == 0) |
| pArray->addElement(getCmplxObject(pDZFunct, pCreFunct, pDelFunct, pName, pNamespace)); |
| else |
| break; |
| |
| ++count; |
| } |
| |
| if (AXIS_FAIL == m_nStatus) // TODO - not sure this line is needed |
| m_pNode = NULL; // TODO - not sure this line is needed |
| else if (arraySize > 0) |
| skipNode(); |
| } |
| |
| logExitWithPointer(pArray) |
| |
| return pArray; |
| } |
| |
| /* |
| * In rpc/encoded style the stream is as follows, |
| * <abc:ArrayOfPhoneNumbers xmlns:abc="http://example.org/2001/06/numbers" |
| * xmlns:enc="http://www.w3.org/2001/06/soap-encoding" |
| * enc:arrayType="xsd:string[2]"> |
| * <item>+94-112-500500</item> |
| * <item>+94-112-500500</item> |
| * </abc:ArrayOfPhoneNumbers> |
| * But in doc/literal style it is, |
| * <phonenumbers>+94-112-500500</phonenumbers> |
| * <phonenumbers>+94-112-500500</phonenumbers> |
| * |
| * |
| */ |
| |
| Axis_Array*SoapDeSerializer:: |
| getBasicArray (XSDTYPE nType, const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| logEntryEngine("SoapDeSerializer::getBasicArray") |
| |
| int size = 0; |
| Axis_Array* Array = new Axis_Array(); |
| Array->m_Type = nType; |
| |
| // if anything has gone wrong earlier just do nothing |
| if (AXIS_SUCCESS == m_nStatus) |
| { |
| // Loop through the array adding elements. |
| IAnySimpleType* pSimpleType = NULL; |
| void * pValue = NULL; |
| |
| try |
| { |
| size = getArraySize (); |
| const char* elementName; |
| int count = 0; |
| |
| while(RPC_ENCODED != m_nStyle || count < size) |
| { |
| // For RPC-encoded arrays, the element name in array cannot be derived - |
| // within an array value element names are not significant - |
| // so we read until end-of-element is encountered (i.e. null string |
| // is returned from peek()). |
| elementName = m_pParser->peek(); |
| if ((RPC_ENCODED == m_nStyle && 0x00 != *elementName) || strcmp(elementName, pName) == 0) |
| { |
| // TODO instead of deleting the pointer use it by by-passing addElement(). |
| if (XSD_ANYTYPE != nType) |
| { |
| if (0 == count) |
| pSimpleType = AxisUtils::createSimpleTypeObject(nType); |
| getElement(pName, pNamespace, pSimpleType, (bool)(RPC_ENCODED == m_nStyle)); |
| pValue = pSimpleType->getValue(); |
| Array->addElement(pValue); |
| Axis::AxisDelete(pValue, pSimpleType->getType()); |
| } |
| else |
| { |
| pValue = getElementAsAnyType(pName, pNamespace); |
| Array->addElement(pValue); |
| Axis::AxisDelete(pValue, XSD_ANYTYPE); |
| } |
| |
| pValue = NULL; |
| } |
| else |
| break; |
| |
| ++count; |
| } |
| } |
| catch ( ... ) |
| { |
| if (pSimpleType) |
| { |
| if (pValue) |
| Axis::AxisDelete(pValue, pSimpleType->getType()); |
| delete pSimpleType; |
| } |
| |
| delete Array; |
| |
| logRethrowException() |
| |
| throw; |
| } |
| |
| delete pSimpleType; |
| |
| if (AXIS_FAIL == m_nStatus) // TODO - not sure this line is needed |
| m_pNode = NULL; // TODO - not sure this line is needed |
| else if (size > 0) |
| skipNode(); |
| } |
| |
| logExitWithPointer(Array) |
| |
| return Array; |
| } |
| |
| /* |
| * In doc/lit style pName is the name of the type instance "result" |
| * <result> |
| * <name>Widgets Inc.</name> |
| * <symbol>WID</symbol> |
| * <public>true</public> |
| * </result> |
| * But in rpc/encoded style pName is the name of the type "QuoteInfoType" |
| * <tns:QuoteInfoType xmlns:tns="http://www.getquote.org/test"> |
| * <name xsi:type="xsd:string">Widgets Inc.</name> |
| * <symbol xsi:type="xsd:string">WID</symbol> |
| * <public xsi:type="xsd:boolean">true</public> |
| * </tns:QuoteInfoType> |
| * |
| */ |
| void *SoapDeSerializer:: |
| getCmplxObject (void *pDZFunct, void *pCreFunct, void *pDelFunct, |
| const AxisChar * pName, const AxisChar * pNamespace, bool isFault) |
| { |
| logEntryEngine("SoapDeSerializer::getCmplxObject") |
| |
| if (!isFault) |
| { |
| if (AXIS_SUCCESS == m_nStatus && (RPC_ENCODED != m_nStyle) && (m_pNode == NULL)) |
| { |
| const char*name = peekNextElementName(); |
| if (0 != strcmp (pName, name)) |
| { |
| logExitWithPointer(NULL) |
| |
| return NULL; |
| } |
| } |
| |
| if (AXIS_SUCCESS != m_nStatus || (AXIS_FAIL == getNextNode(RPC_ENCODED != m_nStyle))) |
| { |
| logExitWithPointer(NULL) |
| |
| return NULL; |
| } |
| } |
| |
| if (RPC_ENCODED != m_nStyle) // TODO - why do we selectively do this check and not for all? |
| if (0 != strcmp (pName, m_pNode->m_pchNameOrValue)) |
| { |
| /* |
| * TODO: Need to verify what WS-I 1.0 says |
| * about the mandatory of all the elements in the response in case of |
| * null value or none filled value. Some Web services servers work |
| * like this. This apply for all the rest of the deserializer. |
| */ |
| logExitWithPointer(NULL) |
| |
| return NULL; |
| } |
| |
| // TODO - even if node is nil, there may be attributes associated with the element that |
| // TODO - need to be deserialized - thus in the generated code we need to get the nil |
| // TODO - attribute if element is nillable and check if it is true or false, in which case |
| // TODO - we would short-circuit the deserialization after any other attributes have been |
| // TODO - obtained. Thus changes will need to be made here and in the code generator. |
| // if node contain attributes let them be used by the complex type's deserializer |
| if (isNilValue()) |
| { |
| skipNode(); |
| |
| logExitWithPointer(NULL) |
| |
| return NULL; |
| } |
| |
| // Make attributes available to code that deserializes the attributes |
| m_pCurrNode = NULL; |
| if (0 != m_pNode->m_pchAttributes[0]) |
| m_pCurrNode = m_pNode; |
| |
| // indicate node consumed |
| m_pNode = NULL; |
| |
| if (!isFault && AXIS_FAIL == m_nStatus) |
| { |
| logExitWithPointer(NULL) |
| |
| return NULL; |
| } |
| |
| // Call the Axis-generated routine that will deserialize complex object, |
| // including any attributes. |
| |
| logDebugArg1("Calling object create function for %s", pName) |
| |
| void *pObject = ((AXIS_OBJECT_CREATE_FUNCT) pCreFunct) (0); |
| |
| logDebugArg2("Returned from object create function for %s, returned object %p", pName, pObject) |
| |
| if (pObject && pDZFunct) |
| { |
| try |
| { |
| m_doNotSkip = false; |
| |
| logDebugArg1("Calling object deserializer function for %s", pName) |
| |
| m_nStatus = ((AXIS_DESERIALIZE_FUNCT) pDZFunct) (pObject, this); |
| |
| logDebugArg2("Returned from object deserializer function for %s, status=%d", pName, m_nStatus) |
| |
| |
| if (AXIS_SUCCESS == m_nStatus) |
| { |
| if (!m_doNotSkip) |
| skipNode(); |
| m_doNotSkip = false; |
| } |
| else |
| { |
| logDebugArg2("Calling object delete function for %s for object %p", pName, pObject) |
| |
| ((AXIS_OBJECT_DELETE_FUNCT) pDelFunct) (pObject, 0); |
| |
| logDebugArg1("Returned from object delete function for %s", pName) |
| |
| pObject = NULL; |
| } |
| } |
| catch ( ... ) |
| { |
| logDebugArg2("Calling object delete function for %s for object %p", pName, pObject) |
| |
| ((AXIS_OBJECT_DELETE_FUNCT) pDelFunct) (pObject, 0); |
| |
| logDebugArg1("Returned from object delete function for %s", pName) |
| |
| logRethrowException() |
| |
| throw; |
| } |
| } |
| |
| logExitWithPointer(pObject) |
| |
| return pObject; |
| } |
| |
| void * SoapDeSerializer:: |
| getAttribute(const AxisChar* pName, const AxisChar * pNamespace, IAnySimpleType * pSimpleType) |
| { |
| logEntryEngine("SoapDeSerializer::getAttribute") |
| |
| void *returnValue = NULL; |
| |
| if (m_pCurrNode) |
| { |
| for (int i=0; m_pCurrNode->m_pchAttributes[i]; i += 3) |
| { |
| if (0 == strcmp(m_pCurrNode->m_pchAttributes[i], pName)) |
| { |
| pSimpleType->deserialize(m_pCurrNode->m_pchAttributes[i+2]); |
| returnValue = pSimpleType->getValue(); |
| break; |
| } |
| } |
| } |
| |
| logExitWithPointer(returnValue) |
| |
| return returnValue; |
| } |
| |
| xsd__int *SoapDeSerializer:: |
| getAttributeAsInt (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Int simpleType; |
| return (xsd__int *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__boolean *SoapDeSerializer:: |
| getAttributeAsBoolean (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Boolean simpleType; |
| return (xsd__boolean *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__unsignedInt *SoapDeSerializer:: |
| getAttributeAsUnsignedInt (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| UnsignedInt simpleType; |
| return (xsd__unsignedInt *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__short *SoapDeSerializer:: |
| getAttributeAsShort (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Short simpleType; |
| return (xsd__short *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__unsignedShort *SoapDeSerializer:: |
| getAttributeAsUnsignedShort (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| UnsignedShort simpleType; |
| return (xsd__unsignedShort *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__byte *SoapDeSerializer:: |
| getAttributeAsByte (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Byte simpleType; |
| return (xsd__byte *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__unsignedByte *SoapDeSerializer:: |
| getAttributeAsUnsignedByte (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| UnsignedByte simpleType; |
| return (xsd__unsignedByte *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__long *SoapDeSerializer:: |
| getAttributeAsLong (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Long simpleType; |
| return (xsd__long *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__integer *SoapDeSerializer:: |
| getAttributeAsInteger (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Integer simpleType; |
| return (xsd__integer *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__nonNegativeInteger *SoapDeSerializer:: |
| getAttributeAsNonNegativeInteger (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| NonNegativeInteger simpleType; |
| return (xsd__nonNegativeInteger *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__positiveInteger *SoapDeSerializer:: |
| getAttributeAsPositiveInteger (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| PositiveInteger simpleType; |
| return (xsd__positiveInteger *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__nonPositiveInteger *SoapDeSerializer:: |
| getAttributeAsNonPositiveInteger (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| NonPositiveInteger simpleType; |
| return (xsd__nonPositiveInteger *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__negativeInteger *SoapDeSerializer:: |
| getAttributeAsNegativeInteger (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| NegativeInteger simpleType; |
| return (xsd__negativeInteger *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__unsignedLong *SoapDeSerializer:: |
| getAttributeAsUnsignedLong (const AxisChar *pName, const AxisChar * pNamespace) |
| { |
| UnsignedLong simpleType; |
| return (xsd__unsignedLong *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__float *SoapDeSerializer:: |
| getAttributeAsFloat (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Float simpleType; |
| return (xsd__float *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__double *SoapDeSerializer:: |
| getAttributeAsDouble (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Double simpleType; |
| return (xsd__double *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__decimal *SoapDeSerializer:: |
| getAttributeAsDecimal (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Decimal simpleType; |
| return (xsd__decimal *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__NOTATION SoapDeSerializer:: |
| getAttributeAsNOTATION (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| NOTATION simpleType; |
| return (xsd__NOTATION)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__string SoapDeSerializer:: |
| getAttributeAsString (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| String simpleType; |
| return (xsd__string)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__normalizedString SoapDeSerializer:: |
| getAttributeAsNormalizedString (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| NormalizedString simpleType; |
| return (xsd__normalizedString)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__token SoapDeSerializer:: |
| getAttributeAsToken (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Token simpleType; |
| return (xsd__token)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__language SoapDeSerializer:: |
| getAttributeAsLanguage (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Language simpleType; |
| return (xsd__language)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__NMTOKEN SoapDeSerializer:: |
| getAttributeAsNMTOKEN (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| NMTOKEN simpleType; |
| return (xsd__NMTOKEN)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__NMTOKENS SoapDeSerializer:: |
| getAttributeAsNMTOKENS (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| NMTOKENS simpleType; |
| return (xsd__NMTOKENS)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__Name SoapDeSerializer:: |
| getAttributeAsName (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Name simpleType; |
| return (xsd__Name)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__NCName SoapDeSerializer:: |
| getAttributeAsNCName (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| NCName simpleType; |
| return (xsd__NCName)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__ID SoapDeSerializer:: |
| getAttributeAsID (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| ID simpleType; |
| return (xsd__ID)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__IDREF SoapDeSerializer:: |
| getAttributeAsIDREF (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| IDREF simpleType; |
| return (xsd__IDREF)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__IDREFS SoapDeSerializer:: |
| getAttributeAsIDREFS (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| IDREFS simpleType; |
| return (xsd__IDREFS)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__ENTITY SoapDeSerializer:: |
| getAttributeAsENTITY (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| ENTITY simpleType; |
| return (xsd__ENTITY)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__ENTITIES SoapDeSerializer:: |
| getAttributeAsENTITIES (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| ENTITIES simpleType; |
| return (xsd__ENTITIES)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__anyURI SoapDeSerializer:: |
| getAttributeAsAnyURI (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| AnyURI simpleType; |
| return (xsd__anyURI)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__QName SoapDeSerializer:: |
| getAttributeAsQName (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| XSD_QName simpleType; |
| return (xsd__QName)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__hexBinary *SoapDeSerializer:: |
| getAttributeAsHexBinary (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| HexBinary simpleType; |
| return (xsd__hexBinary *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__base64Binary *SoapDeSerializer:: |
| getAttributeAsBase64Binary (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Base64Binary simpleType; |
| return (xsd__base64Binary *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__dateTime *SoapDeSerializer:: |
| getAttributeAsDateTime (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| DateTime simpleType; |
| return (xsd__dateTime *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__date *SoapDeSerializer:: |
| getAttributeAsDate (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Date simpleType; |
| return (xsd__date *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__time *SoapDeSerializer:: |
| getAttributeAsTime (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Time simpleType; |
| return (xsd__time *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__gDay*SoapDeSerializer:: |
| getAttributeAsGDay (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| GDay simpleType; |
| return (xsd__gDay *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__gMonth*SoapDeSerializer:: |
| getAttributeAsGMonth (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| GMonth simpleType; |
| return (xsd__gMonth *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__gMonthDay*SoapDeSerializer:: |
| getAttributeAsGMonthDay (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| GMonthDay simpleType; |
| return (xsd__gMonthDay *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__gYear*SoapDeSerializer:: |
| getAttributeAsGYear (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| GYear simpleType; |
| return (xsd__gYear *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__gYearMonth*SoapDeSerializer:: |
| getAttributeAsGYearMonth (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| GYearMonth simpleType; |
| return (xsd__gYearMonth *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| xsd__duration *SoapDeSerializer:: |
| getAttributeAsDuration (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Duration simpleType; |
| return (xsd__duration *)getAttribute(pName, pNamespace, &simpleType); |
| } |
| |
| bool SoapDeSerializer:: |
| isNilValue() |
| { |
| logEntryEngine("SoapDeSerializer::isNilValue") |
| |
| bool isNillResult = false; |
| |
| // Go through the attributes looking for nil. We consider |
| // "true" or "1" to be equivalent. |
| for (int i = 0; m_pNode->m_pchAttributes[i]; i += 3) |
| { |
| string sLocalName = m_pNode->m_pchAttributes[i]; |
| string sValue = m_pNode->m_pchAttributes[i + 2]; |
| |
| if (strcmp("nil", sLocalName.c_str()) == 0 && |
| (strcmp("true", sValue.c_str()) == 0 || strcmp( "1", sValue.c_str()) == 0)) |
| { |
| isNillResult = true; |
| break; |
| } |
| } |
| |
| logExitWithBoolean(isNillResult) |
| |
| return isNillResult; |
| } |
| |
| void SoapDeSerializer:: |
| processFaultDetail(IAnySimpleType * pSimpleType, const AxisChar* elementValue) |
| { |
| logEntryEngine("SoapDeSerializer::processFaultDetail") |
| |
| bool isWhiteSpace = true; |
| |
| int len = elementValue ? strlen(elementValue) : 0; |
| |
| // See if detail element character data is whitespace |
| for (int i=0; i<len; ++i) |
| if (!(*elementValue == '\r' || *elementValue == '\n' |
| || *elementValue == '\t' || *elementValue == ' ')) |
| { |
| isWhiteSpace = false; |
| break; |
| } |
| |
| // If it is whitespace, peek to see if next element is the start of |
| // a new element, in which case the fault detail is complex. Peek() |
| // return null string if end-element tag is encountered. |
| char *workingString = (char *)elementValue; |
| if (isWhiteSpace) |
| { |
| // Since we will be doing a peek, elementValue will no longer |
| // be valid, so if we will deserialize null string if we need to. |
| workingString = ""; |
| |
| // if end tag not found, must be complex detail - fault handling code |
| // will know what to do when we return with no deserialization |
| const char* nextName = m_pParser->peek(); |
| if (nextName[0] != 0x00) |
| { |
| m_pNode = NULL; // node consumed |
| |
| logExit() |
| |
| return; |
| } |
| } |
| |
| // If here, detail is simple character data, deserialize simple string |
| pSimpleType->deserialize(workingString); |
| skipNode(); |
| |
| logExit() |
| |
| return; |
| } |
| |
| void SoapDeSerializer:: |
| getElement (const AxisChar * pName, const AxisChar * pNamespace, |
| IAnySimpleType * pSimpleType, |
| bool isArrayElement) |
| { |
| logEntryEngine("SoapDeSerializer::getElement") |
| |
| if (AXIS_SUCCESS != m_nStatus) |
| { |
| logExit() |
| |
| return; |
| } |
| |
| if ((RPC_ENCODED != m_nStyle) && (m_pNode == NULL)) |
| { |
| const char*name = peekNextElementName(); |
| if (0 != strcmp (pName, name)) |
| { |
| logExit() |
| |
| return; |
| } |
| } |
| |
| if (AXIS_FAIL == getNextNode(RPC_ENCODED != m_nStyle)) |
| { |
| logExit() |
| |
| return; |
| } |
| |
| bool bNillFound = false; |
| if (0 == strcmp (pName, m_pNode->m_pchNameOrValue)) |
| bNillFound = isNilValue(); |
| |
| if (RPC_ENCODED == m_nStyle) |
| { |
| // it is an error if type is different if the type exists |
| bool foundType; |
| if (!bNillFound && !isArrayElement |
| && (pSimpleType->getType() != getXSDType(m_pNode, foundType)) && foundType) |
| m_nStatus = AXIS_FAIL; |
| } |
| else if (0 != strcmp (pName, m_pNode->m_pchNameOrValue)) |
| { |
| logExit() |
| |
| return; |
| } |
| |
| if (AXIS_FAIL == m_nStatus) |
| { |
| logExit() |
| |
| return; |
| } |
| |
| // get next element, character mode |
| if (AXIS_FAIL == getNextNode(false, true)) |
| { |
| logExit() |
| |
| return; |
| } |
| |
| if (CHARACTER_ELEMENT == m_pNode->m_type) |
| { |
| const AxisChar* elementValue = m_pNode->m_pchNameOrValue; |
| |
| // Code for fault finding. As added protection against false findings, |
| // the namespace has been set to an invalid value of a single space character. |
| if (pNamespace != NULL && *pNamespace == ' ') |
| processFaultDetail(pSimpleType, elementValue); |
| else |
| { |
| pSimpleType->deserialize(elementValue); |
| skipNode(); |
| } |
| } |
| else if (END_ELEMENT == m_pNode->m_type) |
| { |
| // xsi:nil="true" OR empty tag case <tag/> |
| pSimpleType->deserialize(bNillFound ? NULL : ""); |
| m_pNode = NULL; |
| } |
| |
| logExit() |
| |
| return; |
| } |
| |
| /* |
| * Deserializing Elements as values directly. |
| */ |
| xsd__boolean *SoapDeSerializer:: |
| getElementAsBoolean (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Boolean simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getBoolean(); |
| } |
| |
| xsd__int *SoapDeSerializer:: |
| getElementAsInt (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Int simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getInt(); |
| } |
| |
| |
| xsd__unsignedInt *SoapDeSerializer:: |
| getElementAsUnsignedInt (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| UnsignedInt simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getUnsignedInt(); |
| } |
| |
| xsd__short *SoapDeSerializer:: |
| getElementAsShort (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Short simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getShort(); |
| } |
| |
| xsd__unsignedShort *SoapDeSerializer:: |
| getElementAsUnsignedShort (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| UnsignedShort simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getUnsignedShort(); |
| } |
| |
| xsd__byte *SoapDeSerializer:: |
| getElementAsByte (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Byte simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getByte(); |
| } |
| |
| xsd__unsignedByte *SoapDeSerializer:: |
| getElementAsUnsignedByte (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| UnsignedByte simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getUnsignedByte(); |
| } |
| |
| xsd__long *SoapDeSerializer:: |
| getElementAsLong (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Long simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getLong(); |
| } |
| |
| xsd__integer *SoapDeSerializer:: |
| getElementAsInteger (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Integer simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getInteger(); |
| } |
| |
| xsd__unsignedLong *SoapDeSerializer:: |
| getElementAsUnsignedLong (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| UnsignedLong simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getUnsignedLong(); |
| } |
| |
| xsd__float *SoapDeSerializer:: |
| getElementAsFloat (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Float simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getFloat(); |
| } |
| |
| xsd__double *SoapDeSerializer:: |
| getElementAsDouble (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Double simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getDouble(); |
| } |
| |
| xsd__decimal *SoapDeSerializer:: |
| getElementAsDecimal (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Decimal simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getDecimal(); |
| } |
| |
| xsd__string SoapDeSerializer:: |
| getElementAsString (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| String simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getString(); |
| } |
| |
| xsd__anyURI SoapDeSerializer:: |
| getElementAsAnyURI (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| AnyURI simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getAnyURI(); |
| } |
| |
| xsd__QName SoapDeSerializer:: |
| getElementAsQName (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| XSD_QName simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getQName(); |
| } |
| |
| xsd__hexBinary *SoapDeSerializer:: |
| getElementAsHexBinary (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| HexBinary simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getHexBinary(); |
| } |
| |
| xsd__base64Binary *SoapDeSerializer:: |
| getElementAsBase64Binary (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Base64Binary simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getBase64Binary(); |
| } |
| |
| xsd__dateTime *SoapDeSerializer:: |
| getElementAsDateTime (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| DateTime simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getDateTime(); |
| } |
| |
| xsd__date *SoapDeSerializer:: |
| getElementAsDate (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Date simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getDate(); |
| } |
| |
| xsd__time *SoapDeSerializer:: |
| getElementAsTime (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Time simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getTime(); |
| } |
| |
| xsd__duration *SoapDeSerializer:: |
| getElementAsDuration (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Duration simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getDuration(); |
| } |
| |
| xsd__gYearMonth *SoapDeSerializer:: |
| getElementAsGYearMonth (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| GYearMonth simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getGYearMonth(); |
| } |
| |
| xsd__gYear *SoapDeSerializer:: |
| getElementAsGYear (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| GYear simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getGYear(); |
| } |
| |
| xsd__gMonthDay *SoapDeSerializer:: |
| getElementAsGMonthDay (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| GMonthDay simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getGMonthDay(); |
| } |
| |
| xsd__gDay *SoapDeSerializer:: |
| getElementAsGDay (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| GDay simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getGDay(); |
| } |
| |
| xsd__gMonth *SoapDeSerializer:: |
| getElementAsGMonth (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| GMonth simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getGMonth(); |
| } |
| |
| xsd__nonPositiveInteger *SoapDeSerializer:: |
| getElementAsNonPositiveInteger (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| NonPositiveInteger simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getNonPositiveInteger(); |
| } |
| |
| xsd__negativeInteger *SoapDeSerializer:: |
| getElementAsNegativeInteger (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| NegativeInteger simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getNegativeInteger(); |
| } |
| |
| xsd__nonNegativeInteger *SoapDeSerializer:: |
| getElementAsNonNegativeInteger (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| NonNegativeInteger simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getNonNegativeInteger(); |
| } |
| |
| xsd__positiveInteger *SoapDeSerializer:: |
| getElementAsPositiveInteger (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| PositiveInteger simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getPositiveInteger(); |
| } |
| |
| xsd__normalizedString SoapDeSerializer:: |
| getElementAsNormalizedString (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| NormalizedString simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getNormalizedString(); |
| } |
| |
| xsd__token SoapDeSerializer:: |
| getElementAsToken (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Token simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getToken(); |
| } |
| |
| xsd__language SoapDeSerializer:: |
| getElementAsLanguage (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Language simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getLanguage(); |
| } |
| |
| xsd__Name SoapDeSerializer:: |
| getElementAsName (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| Name simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getName(); |
| } |
| |
| xsd__NCName SoapDeSerializer:: |
| getElementAsNCName (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| NCName simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getNCName(); |
| } |
| |
| xsd__ID SoapDeSerializer:: |
| getElementAsID (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| ID simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getID(); |
| } |
| |
| xsd__IDREF SoapDeSerializer:: |
| getElementAsIDREF (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| IDREF simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getIDREF(); |
| } |
| |
| xsd__IDREFS SoapDeSerializer:: |
| getElementAsIDREFS (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| IDREFS simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getIDREFS(); |
| } |
| |
| xsd__ENTITY SoapDeSerializer:: |
| getElementAsENTITY (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| ENTITY simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getENTITY(); |
| } |
| |
| xsd__ENTITIES SoapDeSerializer:: |
| getElementAsENTITIES (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| ENTITIES simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getENTITIES(); |
| } |
| |
| xsd__NMTOKEN SoapDeSerializer:: |
| getElementAsNMTOKEN (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| NMTOKEN simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getNMTOKEN(); |
| } |
| |
| xsd__NMTOKENS SoapDeSerializer:: |
| getElementAsNMTOKENS (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| NMTOKENS simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getNMTOKENS(); |
| } |
| |
| xsd__NOTATION SoapDeSerializer:: |
| getElementAsNOTATION (const AxisChar * pName, const AxisChar * pNamespace) |
| { |
| NOTATION simpleType; |
| getElement(pName, pNamespace, &simpleType); |
| return simpleType.getNOTATION(); |
| } |
| |
| xsd__anyType SoapDeSerializer:: |
| getElementAsAnyType(const AxisChar* pName, const AxisChar* pNamespace) |
| { |
| xsd__anyType ret = NULL; |
| |
| if (AXIS_SUCCESS != m_nStatus) |
| return ret; |
| |
| AnyType *any = getAnyObject(pName, pNamespace); |
| if (NULL != any) |
| { |
| if (any->_size != 0) |
| { |
| ret = any->_array[0]; |
| any->_array[0] = NULL; |
| delete [] any->_array; |
| } |
| delete any; |
| } |
| |
| return ret; |
| } |
| |
| xsd__string SoapDeSerializer:: |
| getFaultAsXMLString() |
| { |
| if (AXIS_SUCCESS != m_nStatus || RPC_ENCODED == m_nStyle) |
| return NULL; |
| |
| AnyType *any = getAnyObject(); |
| if (any == NULL) |
| return (xsd__string)NULL; |
| |
| int len = 1, i; // Add 1 for the null terminator |
| for (i=0; i<any->_size; i++) |
| if (any->_array[i]) |
| len += strlen(any->_array[i]); |
| |
| xsd__string ret = new char[len]; |
| memset(ret,0,len); |
| for (i=0; i<any->_size; i++) |
| if (any->_array[i]) |
| { |
| strcat(ret,any->_array[i]); |
| delete [] any->_array[i]; |
| } |
| delete [] any->_array; |
| delete any; |
| return ret; |
| } |
| |
| /* |
| * This method checks the attribute list of pElement node for the xsi:type |
| * attribute. If it is found then finds what the type is. Otherwise returns |
| * XSD_UNKNOWN. |
| */ |
| XSDTYPE SoapDeSerializer:: |
| getXSDType (const AnyElement * pElement, bool & foundType) |
| { |
| foundType = false; |
| |
| XSDTYPE type = XSD_UNKNOWN; |
| |
| /* first check whether this is a start element node */ |
| if (START_ELEMENT == pElement->m_type) |
| { |
| for (int i = 0; pElement->m_pchAttributes[i]; i += 3) |
| { |
| if (URI_XSI == URIMapping::getURI (pElement->m_pchAttributes[i + 1])) |
| { |
| ::QName qn; |
| |
| qn.splitQNameString (pElement->m_pchAttributes[i + 2], ':'); |
| const char * pNS = m_pParser->getNS4Prefix (qn.uri); |
| if (pNS) |
| { |
| if (URI_XSD == URIMapping::getURI (pNS) || URI_ENC == URIMapping::getURI (pNS)) |
| type = TypeMapping::map (qn.localname); |
| } |
| qn.mergeQNameString (':'); |
| foundType = true; |
| break; |
| } |
| } |
| } |
| |
| return type; |
| } |
| |
| /* |
| * Used by the Axis Engine to get any left header blocks in the deserializer |
| * even after the completion of message path. Then those headers will be added |
| * to the serializer because they are probably headers targetted to nex soap |
| * processors. |
| */ |
| HeaderBlock * SoapDeSerializer:: |
| getHeaderBlock () |
| { |
| logEntryEngine("SoapDeSerializer::getHeaderBlock") |
| |
| HeaderBlock *returnValue = NULL; |
| |
| if (m_pHeader) |
| returnValue = (HeaderBlock *) m_pHeader->getHeaderBlock (true); |
| |
| logExitWithPointer(returnValue) |
| |
| return returnValue; |
| } |
| |
| /* |
| * Used probably by a handler to add a header block to the Deserializer. |
| * Probably to be used by a subsequent handler in the request message path |
| */ |
| int AXISCALL SoapDeSerializer:: |
| addHeaderBlock (IHeaderBlock * pBlk) |
| { |
| logEntryEngine("SoapDeSerializer::addHeaderBlock") |
| |
| if (!m_pHeader) |
| m_pHeader = new SoapHeader (); |
| m_pHeader->addHeaderBlock ((HeaderBlock *) pBlk); |
| |
| logExitWithReturnCode(AXIS_SUCCESS) |
| |
| return AXIS_SUCCESS; |
| } |
| |
| xsd__hexBinary SoapDeSerializer:: |
| getBodyAsHexBinary () |
| { |
| /* TODO */ |
| getNextNode(); |
| |
| // skip the BODY element declaration |
| if ((START_ELEMENT == m_pNode->m_type) |
| && (0 == strcmp (m_pNode->m_pchNameOrValue, |
| SoapKeywordMapping::map (m_nSoapVersion).pchWords[SKW_BODY]))) |
| getNextNode(); |
| |
| string bodyContent = ""; |
| |
| if (m_pNode) |
| { |
| while (!((END_ELEMENT == m_pNode->m_type) && |
| (0 == strcmp (m_pNode->m_pchNameOrValue, |
| SoapKeywordMapping::map (m_nSoapVersion).pchWords[SKW_BODY])))) |
| bodyContent += AnyElemntUtils::toString(m_pNode); |
| } |
| |
| xsd__hexBinary value; |
| xsd__int size = bodyContent.length() / 2; |
| xsd__unsignedByte * pTemp = new xsd__unsignedByte[size + 1]; |
| Hex_Decode (pTemp, bodyContent.c_str()); |
| pTemp[size] = 0; // Null terminate so it could be used as a string |
| value.set(pTemp, size); |
| delete [] pTemp; |
| |
| return value; |
| } |
| |
| xsd__base64Binary SoapDeSerializer:: |
| getBodyAsBase64Binary () |
| { |
| /* TODO */ |
| getNextNode(); |
| |
| // skip the BODY element declaration |
| if ((START_ELEMENT == m_pNode->m_type) |
| && (0 == strcmp (m_pNode->m_pchNameOrValue, |
| SoapKeywordMapping::map (m_nSoapVersion).pchWords[SKW_BODY]))) |
| getNextNode(); |
| |
| string bodyContent = ""; |
| |
| if (m_pNode) |
| { |
| while (!((END_ELEMENT == m_pNode->m_type) && |
| (0 == strcmp (m_pNode->m_pchNameOrValue, |
| SoapKeywordMapping::map (m_nSoapVersion).pchWords[SKW_BODY])))) |
| bodyContent += AnyElemntUtils::toString(m_pNode); |
| } |
| |
| xsd__base64Binary value; |
| xsd__int size = apr_base64_decode_len (bodyContent.c_str()); |
| xsd__unsignedByte * pTemp = new xsd__unsignedByte[size + 1]; |
| size = apr_base64_decode_binary (pTemp, bodyContent.c_str()); |
| pTemp[size] = 0; // Null terminate so it could used as a string |
| value.set(pTemp, size); |
| delete [] pTemp; |
| return value; |
| } |
| |
| AxisChar *SoapDeSerializer:: |
| getBodyAsChar () |
| { |
| if (AXIS_FAIL == getNextNode()) |
| return NULL; |
| |
| // skip the BODY element declaration |
| if ((START_ELEMENT == m_pNode->m_type) |
| && (0 == strcmp (m_pNode->m_pchNameOrValue, |
| SoapKeywordMapping::map (m_nSoapVersion).pchWords[SKW_BODY]))) |
| { |
| if (AXIS_FAIL == getNextNode()) |
| return NULL; |
| } |
| |
| pBodyContent = new AxisChar[1000]; |
| pBodyContent[0] = '\0'; |
| |
| while (!((END_ELEMENT == m_pNode->m_type) && |
| (0 == strcmp (m_pNode->m_pchNameOrValue, |
| SoapKeywordMapping::map (m_nSoapVersion).pchWords[SKW_BODY])))) |
| strcat (pBodyContent, (AnyElemntUtils::toString (m_pNode)).c_str ()); |
| |
| return pBodyContent; |
| } |
| |
| int SoapDeSerializer:: |
| setNewSoapBody (AxisChar * pNewSoapBody) |
| { |
| DeSerializerMemBufInputStream stream (pNewSoapBody); |
| return m_pParser->setInputStream (&stream); |
| } |
| |
| bool SoapDeSerializer:: |
| isAnyMustUnderstandHeadersLeft () |
| { |
| /* TODO */ |
| return false; |
| } |
| |
| int SoapDeSerializer:: |
| flushInputStream () |
| { |
| logEntryEngine("SoapDeSerializer::flushInputStream") |
| |
| int iStatus = AXIS_FAIL; |
| |
| if (m_pInputStream) |
| { |
| int nChars = 100; |
| char pBuffer[100]; |
| |
| while (TRANSPORT_IN_PROGRESS == m_pInputStream->getBytes (pBuffer, &nChars)); |
| iStatus = AXIS_SUCCESS; |
| } |
| |
| logExitWithReturnCode(iStatus) |
| |
| return iStatus; |
| } |
| |
| AnyType * SoapDeSerializer:: |
| getAnyObject () |
| { |
| return getAnyObject(NULL, NULL); |
| } |
| |
| |
| AnyType * SoapDeSerializer:: |
| getAnyObject (const AxisChar* pName, const AxisChar* pNamespace) |
| { |
| logEntryEngine("SoapDeSerializer::getAnyObject") |
| |
| // If pname is passed, then we need to move the parser pointer for RPC. |
| if ((pName != NULL && RPC_ENCODED == m_nStyle) || (m_pNode == NULL)) |
| { |
| getNextNode(false, false); |
| if (m_pNode == NULL) |
| { |
| logExitWithPointer(NULL) |
| |
| return (AnyType *)NULL; |
| } |
| } |
| |
| int tagCount = 0; |
| int lstSize = 0; |
| bool bContinue = true; |
| bool bElementFound = false; |
| AxisString xmlStr = ""; |
| AxisString nsDecls = ""; |
| |
| if (m_pNode) |
| { |
| // If this is an end-element node, simply return, there is no element to parse. Note |
| // we do not consume the node. |
| if (END_ELEMENT == m_pNode->m_type) |
| { |
| logExitWithPointer(NULL) |
| |
| return (AnyType *)NULL; |
| } |
| |
| // There may have been namespace declarations that were previously processed....get it from |
| // the node and reset the node variable. |
| nsDecls = ((AnyElement*)m_pNode)->m_strXMLNSDeclsForAnyObject.c_str(); |
| ((AnyElement*)m_pNode)->m_strXMLNSDeclsForAnyObject.clear(); |
| } |
| |
| stack <AxisString> nsPrefixStack; |
| |
| AxisString inValue = ""; |
| AxisString outValue = ""; |
| |
| // Loop and get an XML element node and its sub-elements. |
| // Note the a schema element will not be counted as an element but will be included as part |
| // of the data returned. |
| while (m_pNode && ((END_ELEMENT != m_pNode->m_type) || (tagCount > 0) || bContinue)) |
| { |
| // Root element needs to be what is expected for doc/literal. |
| if (pName != NULL |
| && RPC_ENCODED != m_nStyle |
| && START_ELEMENT == m_pNode->m_type) |
| { |
| if (0 != strcmp (pName, m_pNode->m_pchNameOrValue)) |
| { |
| // Need to save namespace string just in case it is needed later. |
| ((AnyElement*)m_pNode)->m_strXMLNSDeclsForAnyObject = nsDecls.c_str(); |
| |
| logExitWithPointer(NULL) |
| |
| return (AnyType *)NULL; |
| } |
| |
| // We do not need to do the check anymore |
| pName = NULL; |
| } |
| |
| // Continue if processing start prefix as we haven't yet found the true start of the tag |
| bContinue = false; |
| if (START_PREFIX == m_pNode->m_type) |
| bContinue = true; |
| |
| // if empty element we need to do a parser get to consume the end-element node. |
| // Note that start/end elements are not included in tagCount processing since the node |
| // is processed completely on first pass since it contains no sub-elements. |
| if (START_END_ELEMENT == m_pNode->m_type2) |
| { |
| if (END_ELEMENT == m_pNode->m_type) |
| { |
| m_pNode = m_pParser->anyNext (); |
| continue; |
| } |
| } |
| else |
| { |
| // Increment counter if entering new tag, Decrement counter if exiting tag |
| if (START_ELEMENT == m_pNode->m_type) |
| tagCount++; |
| else if (END_ELEMENT == m_pNode->m_type) |
| tagCount--; |
| } |
| |
| if (START_PREFIX == m_pNode->m_type) |
| { |
| nsDecls += " xmlns"; |
| if (m_pNode->m_pchNameOrValue && (*(m_pNode->m_pchNameOrValue) != 0x00)) |
| { |
| nsDecls += ":"; |
| nsDecls += m_pNode->m_pchNameOrValue; |
| } |
| nsDecls += "="; |
| nsDecls += PLATFORM_DOUBLE_QUOTE_S; |
| nsDecls += m_pNode->m_pchNamespace; |
| nsDecls += PLATFORM_DOUBLE_QUOTE_S; |
| } |
| else if (CHARACTER_ELEMENT != m_pNode->m_type) |
| { |
| bElementFound = true; |
| serializeTag (xmlStr, m_pNode, nsDecls, nsPrefixStack); |
| nsDecls = ""; |
| } |
| else |
| { |
| inValue = m_pNode->m_pchNameOrValue; |
| IAnySimpleType::replaceReservedCharacters(inValue, outValue); |
| xmlStr += outValue; |
| } |
| |
| // If element obtained...break out. Otherwise, get next node. |
| if (bElementFound && !bContinue && tagCount == 0 && (!xmlStr.empty ())) |
| { |
| // If the anyType element is empty element, we need to consume END_ELEMENT. |
| if (START_END_ELEMENT == m_pNode->m_type2 && START_ELEMENT == m_pNode->m_type) |
| m_pNode = m_pParser->anyNext (); |
| |
| m_pNode = NULL; |
| } |
| else |
| m_pNode = m_pParser->anyNext (); |
| } |
| |
| // Generate the axis type where we store anyType XML objects. |
| AnyType *pAny = new AnyType (); |
| pAny->_array = 0; |
| pAny->_size = 0; |
| |
| if (!xmlStr.empty ()) |
| { |
| pAny->_array = new char *[1]; |
| |
| const char *s = xmlStr.c_str (); |
| logDebugArg1("\nAnyType array element\n%s\n", s) |
| |
| pAny->_array[0] = new char[xmlStr.size() + 1]; |
| strcpy (pAny->_array[0], s); |
| |
| pAny->_size = 1; |
| } |
| |
| logExitWithPointer(pAny) |
| |
| return pAny; |
| } |
| |
| void SoapDeSerializer:: |
| serializeTag (AxisString & xmlStr, |
| const AnyElement * node, |
| AxisString & nsDecls, |
| std::stack<AxisString> & nsPrefixStack) |
| { |
| const XML_Ch *pchPrefix = 0; |
| |
| AxisString nsPrefix = ""; |
| |
| if (START_ELEMENT == node->m_type) |
| { |
| xmlStr += "<"; |
| |
| if (node->m_pchNamespace && (*(node->m_pchNamespace) != 0x00)) |
| { |
| pchPrefix = m_pParser->getPrefix4NS (node->m_pchNamespace); |
| |
| if (pchPrefix && *pchPrefix != 0x00) |
| { |
| nsPrefix = pchPrefix; |
| |
| xmlStr += pchPrefix; |
| xmlStr += ":"; |
| } |
| } |
| |
| // We do not need to save namespace prefix if start/end element. |
| if (START_END_ELEMENT != node->m_type2) |
| nsPrefixStack.push(nsPrefix); |
| |
| xmlStr += node->m_pchNameOrValue; |
| |
| if (!nsDecls.empty ()) |
| xmlStr += nsDecls.c_str (); |
| |
| if (node->m_pchAttributes) |
| { |
| int j; |
| |
| /* structure of the m_pchAttributes[] array is, |
| * sequence of (local_name, namespace_uri, value) |
| */ |
| |
| for (j = 0; j < 300; j += 3) /* MAX_NO_OF_ATTRIBUTES = 100 */ |
| { |
| if (node->m_pchAttributes[j]) |
| { |
| if (node->m_pchAttributes[j + 1]) |
| pchPrefix = m_pParser->getPrefix4NS (node->m_pchAttributes[j + 1]); |
| else |
| pchPrefix = NULL; |
| |
| xmlStr += " "; |
| |
| if (pchPrefix && (*pchPrefix != 0x00)) |
| { |
| xmlStr += pchPrefix; |
| xmlStr += ":"; |
| } |
| |
| xmlStr += node->m_pchAttributes[j]; |
| xmlStr += "="; |
| xmlStr += PLATFORM_DOUBLE_QUOTE_S; |
| xmlStr += node->m_pchAttributes[j + 2]; |
| xmlStr += PLATFORM_DOUBLE_QUOTE_S; |
| } |
| else |
| break; |
| } |
| } |
| |
| if (START_END_ELEMENT == node->m_type2) |
| xmlStr += " />"; |
| else |
| xmlStr += ">"; |
| } |
| else if (END_ELEMENT == node->m_type) |
| { |
| AxisString prefixTag = ""; |
| |
| if (!nsPrefixStack.empty()) |
| { |
| nsPrefix = nsPrefixStack.top(); |
| nsPrefixStack.pop(); |
| |
| if (!nsPrefix.empty()) |
| { |
| prefixTag += nsPrefix; |
| prefixTag += ":"; |
| } |
| } |
| |
| xmlStr += "</"; |
| xmlStr += prefixTag; |
| xmlStr += node->m_pchNameOrValue; |
| if (START_END_ELEMENT == node->m_type2) |
| xmlStr += " />"; |
| else |
| xmlStr += ">"; |
| } |
| } |
| |
| void SoapDeSerializer:: |
| getChardataAs (void **pValue, XSDTYPE type) |
| { |
| logEntryEngine("SoapDeSerializer::getChardataAs") |
| |
| if (pValue && AXIS_FAIL != getNextNode(true, true)) |
| { |
| *pValue = NULL; |
| if (CHARACTER_ELEMENT == m_pNode->m_type) |
| { |
| IAnySimpleType* pSimpleType = AxisUtils::createSimpleTypeObject(type); |
| pSimpleType->deserialize(m_pNode->m_pchNameOrValue); |
| *pValue = pSimpleType->getValue(); |
| delete pSimpleType; |
| } |
| else if (END_ELEMENT == m_pNode->m_type) |
| { |
| m_doNotSkip = true; |
| m_pNode = NULL; |
| } |
| } |
| |
| logExit() |
| } |
| |
| /* This function is never called. */ |
| AXIS_TRANSPORT_STATUS SoapDeSerializer:: |
| DeSerializerMemBufInputStream:: |
| sendBytes (const char *pcSendBuffer, const void *pBufferid) |
| { |
| return TRANSPORT_FINISHED; |
| } |
| |
| AXIS_TRANSPORT_STATUS SoapDeSerializer:: |
| DeSerializerMemBufInputStream:: |
| getBytes (char *pcBuffer, int *piRetSize) |
| { |
| logEntryEngine("SoapDeSerializer::DeSerializerMemBufInputStream::getBytes") |
| |
| if (!m_pcDeSeriaMemBuffer) |
| { |
| logExitWithMessage("Returned return code of TRANSPORT_FAILED") |
| |
| return TRANSPORT_FAILED; |
| } |
| |
| int nBufLen = strlen (m_pcDeSeriaMemBuffer); |
| if (0 == nBufLen) |
| { |
| logExitWithMessage("Returned return code of TRANSPORT_FINISHED") |
| |
| return TRANSPORT_FINISHED; |
| } |
| |
| nBufLen = ((*piRetSize - 1) < nBufLen) ? (*piRetSize - 1) : nBufLen; |
| strncpy (pcBuffer, m_pcDeSeriaMemBuffer, nBufLen); |
| pcBuffer[nBufLen] = 0; |
| m_pcDeSeriaMemBuffer += nBufLen; |
| |
| logExitWithMessage("Returned return code of TRANSPORT_IN_PROGRESS") |
| |
| return TRANSPORT_IN_PROGRESS; |
| } |
| |
| ISoapAttachment* SoapDeSerializer:: |
| getAttachment(const char* pcAttachmentid) |
| { |
| return m_pInputStream->getAttachment(pcAttachmentid); |
| } |
| |
| ISoapAttachment** SoapDeSerializer:: |
| getAllAttachments(int *pAttchArraySize) |
| { |
| return m_pInputStream->getAllAttachments(pAttchArraySize); |
| } |
| |
| const char* SoapDeSerializer:: |
| getMethodNameToInvoke() |
| { |
| return m_strMethodNameToInvoke.c_str(); |
| } |
| |
| void SoapDeSerializer:: |
| setMethodNameToInvoke(const char* methodName) |
| { |
| logEntryEngine("SoapDeSerializer::setMethodNameToInvoke") |
| |
| m_strMethodNameToInvoke = methodName; |
| |
| logExit() |
| } |
| |
| AXIS_CPP_NAMESPACE_END |
