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         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             return m_qname;
  75         }
  76
  77         void setCode(const xmltooling::QName* qname) {
  78             m_qname=prepareForAssignment(m_qname,qname);
  79             if (m_qname) {
  80                 auto_ptr_XMLCh temp(m_qname->toString().c_str());
  81                 setTextContent(temp.get());
  82             }
  83             else
  84                 setTextContent(nullptr);
  85         }
  86
  87         IMPL_XMLOBJECT_CLONE(Faultcode);
  88     };
  89
  90     class XMLTOOL_DLLLOCAL DetailImpl : public virtual Detail,
  91         public AbstractAttributeExtensibleXMLObject,
  92         public AbstractComplexElement,
  93         public AbstractDOMCachingXMLObject,
  94         public AbstractXMLObjectMarshaller,
  95         public AbstractXMLObjectUnmarshaller
  96     {
  97     public:
  98         virtual ~DetailImpl() {}
  99
 100         DetailImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 101             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 102         }
 103
 104         DetailImpl(const DetailImpl& src)
 105                 : AbstractXMLObject(src),
 106                     AbstractAttributeExtensibleXMLObject(src),
 107                     AbstractComplexElement(src),
 108                     AbstractDOMCachingXMLObject(src) {
 109             VectorOf(XMLObject) v=getUnknownXMLObjects();
 110             for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i)
 111                 v.push_back((*i)->clone());
 112         }
 113
 114         IMPL_XMLOBJECT_CLONE(Detail);
 115         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject, m_children.end());
 116
 117     protected:
 118         void marshallAttributes(DOMElement* domElement) const {
 119             marshallExtensionAttributes(domElement);
 120         }
 121
 122         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 123             getUnknownXMLObjects().push_back(childXMLObject);
 124         }
 125
 126         void processAttribute(const DOMAttr* attribute) {
 127             unmarshallExtensionAttribute(attribute);
 128         }
 129     };
 130
 131     class XMLTOOL_DLLLOCAL FaultImpl : public virtual Fault,
 132         public AbstractComplexElement,
 133         public AbstractDOMCachingXMLObject,
 134         public AbstractXMLObjectMarshaller,
 135         public AbstractXMLObjectUnmarshaller
 136     {
 137         void init() {
 138             m_Faultcode=nullptr;
 139             m_Faultstring=nullptr;
 140             m_Faultactor=nullptr;
 141             m_Detail=nullptr;
 142             m_children.push_back(nullptr);
 143             m_children.push_back(nullptr);
 144             m_children.push_back(nullptr);
 145             m_children.push_back(nullptr);
 146             m_pos_Faultcode=m_children.begin();
 147             m_pos_Faultstring=m_pos_Faultcode;
 148             ++m_pos_Faultstring;
 149             m_pos_Faultactor=m_pos_Faultstring;
 150             ++m_pos_Faultactor;
 151             m_pos_Detail=m_pos_Faultactor;
 152             ++m_pos_Detail;
 153         }
 154     protected:
 155         FaultImpl() {
 156             init();
 157         }
 158
 159     public:
 160         virtual ~FaultImpl() {}
 161
 162         FaultImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 163                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 164             init();
 165         }
 166
 167         FaultImpl(const FaultImpl& src)
 168                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 169             init();
 170             if (src.getFaultcode())
 171                 setFaultcode(src.getFaultcode()->cloneFaultcode());
 172             if (src.getFaultstring())
 173                 setFaultstring(src.getFaultstring()->cloneFaultstring());
 174             if (src.getFaultactor())
 175                 setFaultactor(src.getFaultactor()->cloneFaultactor());
 176             if (src.getDetail())
 177                 setDetail(src.getDetail()->cloneDetail());
 178         }
 179
 180         IMPL_XMLOBJECT_CLONE(Fault);
 181         IMPL_TYPED_CHILD(Faultcode);
 182         IMPL_TYPED_CHILD(Faultstring);
 183         IMPL_TYPED_CHILD(Faultactor);
 184         IMPL_TYPED_CHILD(Detail);
 185
 186     protected:
 187         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 188             PROC_TYPED_CHILD(Faultcode,nullptr,false);
 189             PROC_TYPED_CHILD(Faultstring,nullptr,false);
 190             PROC_TYPED_CHILD(Faultactor,nullptr,false);
 191             PROC_TYPED_CHILD(Detail,nullptr,false);
 192             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 193         }
 194     };
 195
 196     class XMLTOOL_DLLLOCAL BodyImpl : public virtual Body,
 197         public AbstractAttributeExtensibleXMLObject,
 198         public AbstractComplexElement,
 199         public AbstractDOMCachingXMLObject,
 200         public AbstractXMLObjectMarshaller,
 201         public AbstractXMLObjectUnmarshaller
 202     {
 203     public:
 204         virtual ~BodyImpl() {
 205         }
 206
 207         BodyImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 208             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 209         }
 210
 211         BodyImpl(const BodyImpl& src)
 212                 : AbstractXMLObject(src),
 213                     AbstractAttributeExtensibleXMLObject(src),
 214                     AbstractComplexElement(src),
 215                     AbstractDOMCachingXMLObject(src) {
 216             VectorOf(XMLObject) v=getUnknownXMLObjects();
 217             for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i)
 218                 v.push_back((*i)->clone());
 219         }
 220
 221         IMPL_XMLOBJECT_CLONE(Body);
 222         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject, m_children.end());
 223
 224     protected:
 225         void marshallAttributes(DOMElement* domElement) const {
 226             marshallExtensionAttributes(domElement);
 227         }
 228
 229         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 230             getUnknownXMLObjects().push_back(childXMLObject);
 231         }
 232
 233         void processAttribute(const DOMAttr* attribute) {
 234             unmarshallExtensionAttribute(attribute);
 235         }
 236     };
 237
 238     class XMLTOOL_DLLLOCAL HeaderImpl : public virtual Header,
 239         public AbstractAttributeExtensibleXMLObject,
 240         public AbstractComplexElement,
 241         public AbstractDOMCachingXMLObject,
 242         public AbstractXMLObjectMarshaller,
 243         public AbstractXMLObjectUnmarshaller
 244     {
 245     public:
 246         virtual ~HeaderImpl() {
 247         }
 248
 249         HeaderImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 250             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 251         }
 252
 253         HeaderImpl(const HeaderImpl& src)
 254                 : AbstractXMLObject(src),
 255                     AbstractAttributeExtensibleXMLObject(src),
 256                     AbstractComplexElement(src),
 257                     AbstractDOMCachingXMLObject(src) {
 258             VectorOf(XMLObject) v=getUnknownXMLObjects();
 259             for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i)
 260                 v.push_back((*i)->clone());
 261         }
 262
 263         IMPL_XMLOBJECT_CLONE(Header);
 264         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject, m_children.end());
 265
 266     protected:
 267         void marshallAttributes(DOMElement* domElement) const {
 268             marshallExtensionAttributes(domElement);
 269         }
 270
 271         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 272             getUnknownXMLObjects().push_back(childXMLObject);
 273         }
 274
 275         void processAttribute(const DOMAttr* attribute) {
 276             unmarshallExtensionAttribute(attribute);
 277         }
 278     };
 279
 280     class XMLTOOL_DLLLOCAL EnvelopeImpl : public virtual Envelope,
 281         public AbstractAttributeExtensibleXMLObject,
 282         public AbstractComplexElement,
 283         public AbstractDOMCachingXMLObject,
 284         public AbstractXMLObjectMarshaller,
 285         public AbstractXMLObjectUnmarshaller
 286     {
 287         void init() {
 288             m_Header=nullptr;
 289             m_Body=nullptr;
 290             m_children.push_back(nullptr);
 291             m_children.push_back(nullptr);
 292             m_pos_Header=m_children.begin();
 293             m_pos_Body=m_pos_Header;
 294             ++m_pos_Body;
 295         }
 296     public:
 297         virtual ~EnvelopeImpl() {}
 298
 299         EnvelopeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 300             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 301             init();
 302         }
 303
 304         EnvelopeImpl(const EnvelopeImpl& src)
 305                 : AbstractXMLObject(src), AbstractAttributeExtensibleXMLObject(src),
 306                     AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 307             init();
 308             if (src.getHeader())
 309                 setHeader(src.getHeader()->cloneHeader());
 310             if (src.getBody())
 311                 setBody(src.getBody()->cloneBody());
 312         }
 313
 314         IMPL_TYPED_CHILD(Header);
 315         IMPL_TYPED_CHILD(Body);
 316         IMPL_XMLOBJECT_CLONE(Envelope);
 317
 318     protected:
 319         void marshallAttributes(DOMElement* domElement) const {
 320             marshallExtensionAttributes(domElement);
 321         }
 322
 323         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 324             PROC_TYPED_CHILD(Header,SOAP11ENV_NS,false);
 325             PROC_TYPED_CHILD(Body,SOAP11ENV_NS,false);
 326             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 327         }
 328
 329         void processAttribute(const DOMAttr* attribute) {
 330             unmarshallExtensionAttribute(attribute);
 331         }
 332     };
 333 };
 334
 335 #if defined (_MSC_VER)
 336     #pragma warning( pop )
 337 #endif
 338
 339 // Builder Implementations
 340
 341 IMPL_XMLOBJECTBUILDER(Body);
 342 IMPL_XMLOBJECTBUILDER(Detail);
 343 IMPL_XMLOBJECTBUILDER(Envelope);
 344 IMPL_XMLOBJECTBUILDER(Fault);
 345 IMPL_XMLOBJECTBUILDER(Faultactor);
 346 IMPL_XMLOBJECTBUILDER(Faultcode);
 347 IMPL_XMLOBJECTBUILDER(Faultstring);
 348 IMPL_XMLOBJECTBUILDER(Header);
 349
 350 // Unicode literals
 351
 352 const XMLCh Body::LOCAL_NAME[] =                        UNICODE_LITERAL_4(B,o,d,y);
 353 const XMLCh Body::TYPE_NAME[] =                         UNICODE_LITERAL_4(B,o,d,y);
 354 const XMLCh Body::ENCODINGSTYLE_ATTRIB_NAME[] =         UNICODE_LITERAL_13(e,n,c,o,d,i,n,g,S,t,y,l,e);
 355 const XMLCh Detail::LOCAL_NAME[] =                      UNICODE_LITERAL_6(d,e,t,a,i,l);
 356 const XMLCh Detail::TYPE_NAME[] =                       UNICODE_LITERAL_6(d,e,t,a,i,l);
 357 const XMLCh Envelope::LOCAL_NAME[] =                    UNICODE_LITERAL_8(E,n,v,e,l,o,p,e);
 358 const XMLCh Envelope::TYPE_NAME[] =                     UNICODE_LITERAL_8(E,n,v,e,l,o,p,e);
 359 const XMLCh Fault::LOCAL_NAME[] =                       UNICODE_LITERAL_5(F,a,u,l,t);
 360 const XMLCh Fault::TYPE_NAME[] =                        UNICODE_LITERAL_5(F,a,u,l,t);
 361 const XMLCh Faultactor::LOCAL_NAME[] =                  UNICODE_LITERAL_10(F,a,u,l,t,a,c,t,o,r);
 362 const XMLCh Faultcode::LOCAL_NAME[] =                   UNICODE_LITERAL_9(F,a,u,l,t,c,o,d,e);
 363 const XMLCh Faultstring::LOCAL_NAME[] =                 UNICODE_LITERAL_11(F,a,u,l,t,s,t,r,i,n,g);
 364 const XMLCh Header::LOCAL_NAME[] =                      UNICODE_LITERAL_6(H,e,a,d,e,r);
 365 const XMLCh Header::TYPE_NAME[] =                       UNICODE_LITERAL_6(H,e,a,d,e,r);
 366 const XMLCh Header::ACTOR_ATTRIB_NAME[] =               UNICODE_LITERAL_5(a,c,t,o,r);
 367 const XMLCh Header::MUSTUNDERSTAND_ATTRIB_NAME[] =      UNICODE_LITERAL_14(m,u,s,t,U,n,d,e,r,s,t,a,n,d);
 368
 369 static const XMLCh _CLIENT[] =                          UNICODE_LITERAL_6(C,l,i,e,n,t);
 370 static const XMLCh _SERVER[] =                          UNICODE_LITERAL_6(S,e,r,v,e,r);
 371 static const XMLCh _MUSTUNDERSTAND[] =                  UNICODE_LITERAL_14(M,u,s,t,U,n,d,e,r,s,t,a,n,d);
 372 static const XMLCh _VERSIONMISMATCH[] =                 UNICODE_LITERAL_15(V,e,r,s,i,o,n,M,i,s,m,a,t,c,h);
 373
 374 xmltooling::QName Faultcode::CLIENT(SOAP11ENV_NS,_CLIENT,SOAP11ENV_PREFIX);
 375 xmltooling::QName Faultcode::SERVER(SOAP11ENV_NS,_SERVER,SOAP11ENV_PREFIX);
 376 xmltooling::QName Faultcode::MUSTUNDERSTAND(SOAP11ENV_NS,_MUSTUNDERSTAND,SOAP11ENV_PREFIX);
 377 xmltooling::QName Faultcode::VERSIONMISMATCH(SOAP11ENV_NS,_VERSIONMISMATCH,SOAP11ENV_PREFIX);