xmltooling/soap/impl/SOAPImpl.cpp

   1 /*
   2  *  Copyright 2001-2010 Internet2
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /**
  18  * SOAPImpl.cpp
  19  *
  20  * Implementation classes for SOAP 1.1 schema.
  21  */
  22
  23 #include "internal.h"
  24 #include "AbstractAttributeExtensibleXMLObject.h"
  25 #include "AbstractComplexElement.h"
  26 #include "AbstractSimpleElement.h"
  27 #include "exceptions.h"
  28 #include "io/AbstractXMLObjectMarshaller.h"
  29 #include "io/AbstractXMLObjectUnmarshaller.h"
  30 #include "soap/SOAP.h"
  31 #include "util/XMLHelper.h"
  32
  33 #include <xercesc/util/XMLUniDefs.hpp>
  34
  35 using namespace soap11;
  36 using namespace xmltooling;
  37 using namespace xercesc;
  38 using namespace std;
  39 using xmlconstants::SOAP11ENV_NS;
  40 using xmlconstants::SOAP11ENV_PREFIX;
  41
  42 #if defined (_MSC_VER)
  43     #pragma warning( push )
  44     #pragma warning( disable : 4250 4251 )
  45 #endif
  46
  47 namespace {
  48
  49     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Faultstring);
  50     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Faultactor);
  51
  52     class XMLTOOL_DLLLOCAL FaultcodeImpl : public virtual Faultcode,
  53         public AbstractSimpleElement,
  54         public AbstractDOMCachingXMLObject,
  55         public AbstractXMLObjectMarshaller,
  56         public AbstractXMLObjectUnmarshaller
  57     {
  58         mutable xmltooling::QName* m_qname;
  59     public:
  60         virtual ~FaultcodeImpl() {
  61             delete m_qname;
  62         }
  63
  64         FaultcodeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
  65             : AbstractXMLObject(nsURI, localName, prefix, schemaType), m_qname(nullptr) {
  66         }
  67
  68         FaultcodeImpl(const FaultcodeImpl& src)
  69                 : AbstractXMLObject(src), AbstractSimpleElement(src), AbstractDOMCachingXMLObject(src), m_qname(nullptr) {
  70             setCode(src.getCode());
  71         }
  72
  73         const xmltooling::QName* getCode() const {
  74             if (!m_qname && getDOM() && getDOM()->getTextContent()) {
  75                 m_qname = XMLHelper::getNodeValueAsQName(getDOM());
  76             }
  77             return m_qname;
  78         }
  79
  80         void setCode(const xmltooling::QName* qname) {
  81             m_qname=prepareForAssignment(m_qname,qname);
  82             if (m_qname) {
  83                 auto_ptr_XMLCh temp(m_qname->toString().c_str());
  84                 setTextContent(temp.get());
  85             }
  86             else {
  87                 setTextContent(nullptr);
  88             }
  89         }
  90
  91         IMPL_XMLOBJECT_CLONE(Faultcode);
  92     };
  93
  94     class XMLTOOL_DLLLOCAL DetailImpl : public virtual Detail,
  95         public AbstractAttributeExtensibleXMLObject,
  96         public AbstractComplexElement,
  97         public AbstractDOMCachingXMLObject,
  98         public AbstractXMLObjectMarshaller,
  99         public AbstractXMLObjectUnmarshaller
 100     {
 101     public:
 102         virtual ~DetailImpl() {}
 103
 104         DetailImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 105             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 106         }
 107
 108         DetailImpl(const DetailImpl& src)
 109                 : AbstractXMLObject(src),
 110                     AbstractAttributeExtensibleXMLObject(src),
 111                     AbstractComplexElement(src),
 112                     AbstractDOMCachingXMLObject(src) {
 113             VectorOf(XMLObject) v=getUnknownXMLObjects();
 114             for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i)
 115                 v.push_back((*i)->clone());
 116         }
 117
 118         IMPL_XMLOBJECT_CLONE(Detail);
 119         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject, m_children.end());
 120
 121     protected:
 122         void marshallAttributes(DOMElement* domElement) const {
 123             marshallExtensionAttributes(domElement);
 124         }
 125
 126         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 127             getUnknownXMLObjects().push_back(childXMLObject);
 128         }
 129
 130         void processAttribute(const DOMAttr* attribute) {
 131             unmarshallExtensionAttribute(attribute);
 132         }
 133     };
 134
 135     class XMLTOOL_DLLLOCAL FaultImpl : public virtual Fault,
 136         public AbstractComplexElement,
 137         public AbstractDOMCachingXMLObject,
 138         public AbstractXMLObjectMarshaller,
 139         public AbstractXMLObjectUnmarshaller
 140     {
 141         void init() {
 142             m_Faultcode=nullptr;
 143             m_Faultstring=nullptr;
 144             m_Faultactor=nullptr;
 145             m_Detail=nullptr;
 146             m_children.push_back(nullptr);
 147             m_children.push_back(nullptr);
 148             m_children.push_back(nullptr);
 149             m_children.push_back(nullptr);
 150             m_pos_Faultcode=m_children.begin();
 151             m_pos_Faultstring=m_pos_Faultcode;
 152             ++m_pos_Faultstring;
 153             m_pos_Faultactor=m_pos_Faultstring;
 154             ++m_pos_Faultactor;
 155             m_pos_Detail=m_pos_Faultactor;
 156             ++m_pos_Detail;
 157         }
 158     protected:
 159         FaultImpl() {
 160             init();
 161         }
 162
 163     public:
 164         virtual ~FaultImpl() {}
 165
 166         FaultImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 167                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 168             init();
 169         }
 170
 171         FaultImpl(const FaultImpl& src)
 172                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 173             init();
 174             if (src.getFaultcode())
 175                 setFaultcode(src.getFaultcode()->cloneFaultcode());
 176             if (src.getFaultstring())
 177                 setFaultstring(src.getFaultstring()->cloneFaultstring());
 178             if (src.getFaultactor())
 179                 setFaultactor(src.getFaultactor()->cloneFaultactor());
 180             if (src.getDetail())
 181                 setDetail(src.getDetail()->cloneDetail());
 182         }
 183
 184         IMPL_XMLOBJECT_CLONE(Fault);
 185         IMPL_TYPED_CHILD(Faultcode);
 186         IMPL_TYPED_CHILD(Faultstring);
 187         IMPL_TYPED_CHILD(Faultactor);
 188         IMPL_TYPED_CHILD(Detail);
 189
 190     protected:
 191         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 192             PROC_TYPED_CHILD(Faultcode,nullptr,false);
 193             PROC_TYPED_CHILD(Faultstring,nullptr,false);
 194             PROC_TYPED_CHILD(Faultactor,nullptr,false);
 195             PROC_TYPED_CHILD(Detail,nullptr,false);
 196             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 197         }
 198     };
 199
 200     class XMLTOOL_DLLLOCAL BodyImpl : public virtual Body,
 201         public AbstractAttributeExtensibleXMLObject,
 202         public AbstractComplexElement,
 203         public AbstractDOMCachingXMLObject,
 204         public AbstractXMLObjectMarshaller,
 205         public AbstractXMLObjectUnmarshaller
 206     {
 207     public:
 208         virtual ~BodyImpl() {
 209         }
 210
 211         BodyImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 212             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 213         }
 214
 215         BodyImpl(const BodyImpl& src)
 216                 : AbstractXMLObject(src),
 217                     AbstractAttributeExtensibleXMLObject(src),
 218                     AbstractComplexElement(src),
 219                     AbstractDOMCachingXMLObject(src) {
 220             VectorOf(XMLObject) v=getUnknownXMLObjects();
 221             for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i)
 222                 v.push_back((*i)->clone());
 223         }
 224
 225         IMPL_XMLOBJECT_CLONE(Body);
 226         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject, m_children.end());
 227
 228     protected:
 229         void marshallAttributes(DOMElement* domElement) const {
 230             marshallExtensionAttributes(domElement);
 231         }
 232
 233         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 234             getUnknownXMLObjects().push_back(childXMLObject);
 235         }
 236
 237         void processAttribute(const DOMAttr* attribute) {
 238             unmarshallExtensionAttribute(attribute);
 239         }
 240     };
 241
 242     class XMLTOOL_DLLLOCAL HeaderImpl : public virtual Header,
 243         public AbstractAttributeExtensibleXMLObject,
 244         public AbstractComplexElement,
 245         public AbstractDOMCachingXMLObject,
 246         public AbstractXMLObjectMarshaller,
 247         public AbstractXMLObjectUnmarshaller
 248     {
 249     public:
 250         virtual ~HeaderImpl() {
 251         }
 252
 253         HeaderImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 254             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 255         }
 256
 257         HeaderImpl(const HeaderImpl& src)
 258                 : AbstractXMLObject(src),
 259                     AbstractAttributeExtensibleXMLObject(src),
 260                     AbstractComplexElement(src),
 261                     AbstractDOMCachingXMLObject(src) {
 262             VectorOf(XMLObject) v=getUnknownXMLObjects();
 263             for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i)
 264                 v.push_back((*i)->clone());
 265         }
 266
 267         IMPL_XMLOBJECT_CLONE(Header);
 268         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject, m_children.end());
 269
 270     protected:
 271         void marshallAttributes(DOMElement* domElement) const {
 272             marshallExtensionAttributes(domElement);
 273         }
 274
 275         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 276             getUnknownXMLObjects().push_back(childXMLObject);
 277         }
 278
 279         void processAttribute(const DOMAttr* attribute) {
 280             unmarshallExtensionAttribute(attribute);
 281         }
 282     };
 283
 284     class XMLTOOL_DLLLOCAL EnvelopeImpl : public virtual Envelope,
 285         public AbstractAttributeExtensibleXMLObject,
 286         public AbstractComplexElement,
 287         public AbstractDOMCachingXMLObject,
 288         public AbstractXMLObjectMarshaller,
 289         public AbstractXMLObjectUnmarshaller
 290     {
 291         void init() {
 292             m_Header=nullptr;
 293             m_Body=nullptr;
 294             m_children.push_back(nullptr);
 295             m_children.push_back(nullptr);
 296             m_pos_Header=m_children.begin();
 297             m_pos_Body=m_pos_Header;
 298             ++m_pos_Body;
 299         }
 300     public:
 301         virtual ~EnvelopeImpl() {}
 302
 303         EnvelopeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 304             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 305             init();
 306         }
 307
 308         EnvelopeImpl(const EnvelopeImpl& src)
 309                 : AbstractXMLObject(src), AbstractAttributeExtensibleXMLObject(src),
 310                     AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 311             init();
 312             if (src.getHeader())
 313                 setHeader(src.getHeader()->cloneHeader());
 314             if (src.getBody())
 315                 setBody(src.getBody()->cloneBody());
 316         }
 317
 318         IMPL_TYPED_CHILD(Header);
 319         IMPL_TYPED_CHILD(Body);
 320         IMPL_XMLOBJECT_CLONE(Envelope);
 321
 322     protected:
 323         void marshallAttributes(DOMElement* domElement) const {
 324             marshallExtensionAttributes(domElement);
 325         }
 326
 327         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 328             PROC_TYPED_CHILD(Header,SOAP11ENV_NS,false);
 329             PROC_TYPED_CHILD(Body,SOAP11ENV_NS,false);
 330             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 331         }
 332
 333         void processAttribute(const DOMAttr* attribute) {
 334             unmarshallExtensionAttribute(attribute);
 335         }
 336     };
 337 };
 338
 339 #if defined (_MSC_VER)
 340     #pragma warning( pop )
 341 #endif
 342
 343 // Builder Implementations
 344
 345 IMPL_XMLOBJECTBUILDER(Body);
 346 IMPL_XMLOBJECTBUILDER(Detail);
 347 IMPL_XMLOBJECTBUILDER(Envelope);
 348 IMPL_XMLOBJECTBUILDER(Fault);
 349 IMPL_XMLOBJECTBUILDER(Faultactor);
 350 IMPL_XMLOBJECTBUILDER(Faultcode);
 351 IMPL_XMLOBJECTBUILDER(Faultstring);
 352 IMPL_XMLOBJECTBUILDER(Header);
 353
 354 // Unicode literals
 355
 356 const XMLCh Body::LOCAL_NAME[] =                        UNICODE_LITERAL_4(B,o,d,y);
 357 const XMLCh Body::TYPE_NAME[] =                         UNICODE_LITERAL_4(B,o,d,y);
 358 const XMLCh Body::ENCODINGSTYLE_ATTRIB_NAME[] =         UNICODE_LITERAL_13(e,n,c,o,d,i,n,g,S,t,y,l,e);
 359 const XMLCh Detail::LOCAL_NAME[] =                      UNICODE_LITERAL_6(d,e,t,a,i,l);
 360 const XMLCh Detail::TYPE_NAME[] =                       UNICODE_LITERAL_6(d,e,t,a,i,l);
 361 const XMLCh Envelope::LOCAL_NAME[] =                    UNICODE_LITERAL_8(E,n,v,e,l,o,p,e);
 362 const XMLCh Envelope::TYPE_NAME[] =                     UNICODE_LITERAL_8(E,n,v,e,l,o,p,e);
 363 const XMLCh Fault::LOCAL_NAME[] =                       UNICODE_LITERAL_5(F,a,u,l,t);
 364 const XMLCh Fault::TYPE_NAME[] =                        UNICODE_LITERAL_5(F,a,u,l,t);
 365 const XMLCh Faultactor::LOCAL_NAME[] =                  UNICODE_LITERAL_10(f,a,u,l,t,a,c,t,o,r);
 366 const XMLCh Faultcode::LOCAL_NAME[] =                   UNICODE_LITERAL_9(f,a,u,l,t,c,o,d,e);
 367 const XMLCh Faultstring::LOCAL_NAME[] =                 UNICODE_LITERAL_11(f,a,u,l,t,s,t,r,i,n,g);
 368 const XMLCh Header::LOCAL_NAME[] =                      UNICODE_LITERAL_6(H,e,a,d,e,r);
 369 const XMLCh Header::TYPE_NAME[] =                       UNICODE_LITERAL_6(H,e,a,d,e,r);
 370 const XMLCh Header::ACTOR_ATTRIB_NAME[] =               UNICODE_LITERAL_5(a,c,t,o,r);
 371 const XMLCh Header::MUSTUNDERSTAND_ATTRIB_NAME[] =      UNICODE_LITERAL_14(m,u,s,t,U,n,d,e,r,s,t,a,n,d);
 372
 373 static const XMLCh _CLIENT[] =                          UNICODE_LITERAL_6(C,l,i,e,n,t);
 374 static const XMLCh _SERVER[] =                          UNICODE_LITERAL_6(S,e,r,v,e,r);
 375 static const XMLCh _MUSTUNDERSTAND[] =                  UNICODE_LITERAL_14(M,u,s,t,U,n,d,e,r,s,t,a,n,d);
 376 static const XMLCh _VERSIONMISMATCH[] =                 UNICODE_LITERAL_15(V,e,r,s,i,o,n,M,i,s,m,a,t,c,h);
 377
 378 xmltooling::QName Faultcode::CLIENT(SOAP11ENV_NS,_CLIENT,SOAP11ENV_PREFIX);
 379 xmltooling::QName Faultcode::SERVER(SOAP11ENV_NS,_SERVER,SOAP11ENV_PREFIX);
 380 xmltooling::QName Faultcode::MUSTUNDERSTAND(SOAP11ENV_NS,_MUSTUNDERSTAND,SOAP11ENV_PREFIX);
 381 xmltooling::QName Faultcode::VERSIONMISMATCH(SOAP11ENV_NS,_VERSIONMISMATCH,SOAP11ENV_PREFIX);