saml/saml2/core/impl/Protocols20Impl.cpp

   1 /**
   2  * Licensed to the University Corporation for Advanced Internet
   3  * Development, Inc. (UCAID) under one or more contributor license
   4  * agreements. See the NOTICE file distributed with this work for
   5  * additional information regarding copyright ownership.
   6  *
   7  * UCAID licenses this file to you under the Apache License,
   8  * Version 2.0 (the "License"); you may not use this file except
   9  * in compliance with the License. You may obtain a copy of the
  10  * License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  17  * either express or implied. See the License for the specific
  18  * language governing permissions and limitations under the License.
  19  */
  20
  21 /**
  22  * Protocols20Impl.cpp
  23  *
  24  * Implementation classes for SAML 2.0 Protocols schema.
  25  */
  26
  27 #include "internal.h"
  28 #include "exceptions.h"
  29 #include "saml2/core/Protocols.h"
  30 #include "signature/ContentReference.h"
  31
  32 #include <xmltooling/AbstractComplexElement.h>
  33 #include <xmltooling/AbstractSimpleElement.h>
  34 #include <xmltooling/encryption/Encryption.h>
  35 #include <xmltooling/impl/AnyElement.h>
  36 #include <xmltooling/io/AbstractXMLObjectMarshaller.h>
  37 #include <xmltooling/io/AbstractXMLObjectUnmarshaller.h>
  38 #include <xmltooling/signature/Signature.h>
  39 #include <xmltooling/util/DateTime.h>
  40 #include <xmltooling/util/XMLHelper.h>
  41
  42 #include <ctime>
  43 #include <xercesc/util/XMLUniDefs.hpp>
  44
  45 using namespace opensaml::saml2p;
  46 using namespace opensaml::saml2;
  47 using namespace xmlsignature;
  48 using namespace xmlencryption;
  49 using namespace xmltooling;
  50 using namespace std;
  51 using xmlconstants::XMLSIG_NS;
  52 using xmlconstants::XMLENC_NS;
  53 using xmlconstants::XML_BOOL_NULL;
  54 using samlconstants::SAML20_NS;
  55 using samlconstants::SAML20P_NS;
  56
  57 #if defined (_MSC_VER)
  58     #pragma warning( push )
  59     #pragma warning( disable : 4250 4251 )
  60 #endif
  61
  62 namespace opensaml {
  63     namespace saml2p {
  64
  65         DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,Artifact);
  66         DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,GetComplete);
  67         DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,NewID);
  68         DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,RequesterID);
  69         DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,SessionIndex);
  70         DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,StatusMessage);
  71
  72         DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,RespondTo);
  73
  74         //TODO need unit test for this, using objects from another namespace
  75         class SAML_DLLLOCAL ExtensionsImpl : public virtual Extensions,
  76              public AbstractComplexElement,
  77              public AbstractDOMCachingXMLObject,
  78              public AbstractXMLObjectMarshaller,
  79              public AbstractXMLObjectUnmarshaller
  80         {
  81         public:
  82             virtual ~ExtensionsImpl() {}
  83
  84             ExtensionsImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
  85                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
  86             }
  87
  88             ExtensionsImpl(const ExtensionsImpl& src)
  89                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
  90                 for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i) {
  91                     if (*i) {
  92                         getUnknownXMLObjects().push_back((*i)->clone());
  93                     }
  94                 }
  95             }
  96
  97             IMPL_XMLOBJECT_CLONE(Extensions);
  98             IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject,m_children.end());
  99
 100         protected:
 101             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 102                 // Unknown child.
 103                 const XMLCh* nsURI=root->getNamespaceURI();
 104                 if (!XMLString::equals(nsURI,SAML20P_NS) && nsURI && *nsURI) {
 105                     getUnknownXMLObjects().push_back(childXMLObject);
 106                     return;
 107                 }
 108
 109                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 110             }
 111         };
 112
 113         class SAML_DLLLOCAL StatusCodeImpl : public virtual StatusCode,
 114              public AbstractComplexElement,
 115              public AbstractDOMCachingXMLObject,
 116              public AbstractXMLObjectMarshaller,
 117              public AbstractXMLObjectUnmarshaller
 118         {
 119             void init() {
 120                 m_Value=nullptr;
 121                 m_StatusCode=nullptr;
 122                 m_children.push_back(nullptr);
 123                 m_pos_StatusCode=m_children.begin();
 124             }
 125
 126             public:
 127                 virtual ~StatusCodeImpl() {
 128                     XMLString::release(&m_Value);
 129                 }
 130
 131                 StatusCodeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 132                         : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 133                     init();
 134                 }
 135
 136                 StatusCodeImpl(const StatusCodeImpl& src)
 137                         : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 138                     init();
 139                     setValue(src.getValue());
 140                     if (src.getStatusCode())
 141                         setStatusCode(src.getStatusCode()->cloneStatusCode());
 142                 }
 143
 144                 IMPL_XMLOBJECT_CLONE(StatusCode);
 145                 IMPL_STRING_ATTRIB(Value);
 146                 IMPL_TYPED_CHILD(StatusCode);
 147
 148             protected:
 149                 void marshallAttributes(DOMElement* domElement) const {
 150                     MARSHALL_STRING_ATTRIB(Value,VALUE,nullptr);
 151                 }
 152
 153                 void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 154                     PROC_TYPED_CHILD(StatusCode,SAML20P_NS,false);
 155                     AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 156                 }
 157
 158                 void processAttribute(const DOMAttr* attribute) {
 159                     PROC_STRING_ATTRIB(Value,VALUE,nullptr);
 160                     AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 161                 }
 162         };
 163
 164         //TODO need unit tests for non-SAML namespace children
 165         class SAML_DLLLOCAL StatusDetailImpl : public virtual StatusDetail,
 166             public AbstractComplexElement,
 167             public AbstractDOMCachingXMLObject,
 168             public AbstractXMLObjectMarshaller,
 169             public AbstractXMLObjectUnmarshaller
 170         {
 171             public:
 172                 virtual ~StatusDetailImpl() {}
 173
 174                 StatusDetailImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 175                     : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 176                 }
 177
 178                 StatusDetailImpl(const StatusDetailImpl& src)
 179                         : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 180                     for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i) {
 181                         if (*i) {
 182                             getUnknownXMLObjects().push_back((*i)->clone());
 183                         }
 184                     }
 185                 }
 186
 187                 IMPL_XMLOBJECT_CLONE(StatusDetail);
 188                 IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject,m_children.end());
 189
 190             protected:
 191                 void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 192                     getUnknownXMLObjects().push_back(childXMLObject);
 193                 }
 194         };
 195
 196
 197         class SAML_DLLLOCAL StatusImpl : public virtual Status,
 198              public AbstractComplexElement,
 199              public AbstractDOMCachingXMLObject,
 200              public AbstractXMLObjectMarshaller,
 201              public AbstractXMLObjectUnmarshaller
 202         {
 203             void init() {
 204                 m_StatusCode=nullptr;
 205                 m_StatusMessage=nullptr;
 206                 m_StatusDetail=nullptr;
 207                 m_children.push_back(nullptr);
 208                 m_children.push_back(nullptr);
 209                 m_children.push_back(nullptr);
 210                 m_pos_StatusCode=m_children.begin();
 211                 m_pos_StatusMessage=m_pos_StatusCode;
 212                 ++m_pos_StatusMessage;
 213                 m_pos_StatusDetail=m_pos_StatusMessage;
 214                 ++m_pos_StatusDetail;
 215             }
 216
 217         public:
 218             virtual ~StatusImpl() { }
 219
 220             StatusImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 221                     : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 222                 init();
 223             }
 224
 225             StatusImpl(const StatusImpl& src) : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 226                 init();
 227                 if (src.getStatusCode())
 228                     setStatusCode(src.getStatusCode()->cloneStatusCode());
 229                 if (src.getStatusMessage())
 230                     setStatusMessage(src.getStatusMessage()->cloneStatusMessage());
 231                 if (src.getStatusDetail())
 232                     setStatusDetail(src.getStatusDetail()->cloneStatusDetail());
 233             }
 234
 235             IMPL_XMLOBJECT_CLONE(Status);
 236             IMPL_TYPED_CHILD(StatusCode);
 237             IMPL_TYPED_CHILD(StatusMessage);
 238             IMPL_TYPED_CHILD(StatusDetail);
 239
 240         protected:
 241             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 242                 PROC_TYPED_CHILD(StatusCode,SAML20P_NS,false);
 243                 PROC_TYPED_CHILD(StatusMessage,SAML20P_NS,false);
 244                 PROC_TYPED_CHILD(StatusDetail,SAML20P_NS,false);
 245                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 246             }
 247         };
 248
 249
 250         class SAML_DLLLOCAL RequestAbstractTypeImpl : public virtual RequestAbstractType,
 251             public AbstractComplexElement,
 252             public AbstractDOMCachingXMLObject,
 253             public AbstractXMLObjectMarshaller,
 254             public AbstractXMLObjectUnmarshaller
 255         {
 256             void init() {
 257                 m_ID=nullptr;
 258                 m_Version=nullptr;
 259                 m_IssueInstant=nullptr;
 260                 m_Destination=nullptr;
 261                 m_Consent=nullptr;
 262                 m_Issuer=nullptr;
 263                 m_Signature=nullptr;
 264                 m_Extensions=nullptr;
 265                 m_children.push_back(nullptr);
 266                 m_children.push_back(nullptr);
 267                 m_children.push_back(nullptr);
 268                 m_pos_Issuer=m_children.begin();
 269                 m_pos_Signature=m_pos_Issuer;
 270                 ++m_pos_Signature;
 271                 m_pos_Extensions=m_pos_Signature;
 272                 ++m_pos_Extensions;
 273             }
 274
 275         protected:
 276             RequestAbstractTypeImpl() {
 277                 init();
 278             }
 279
 280         public:
 281             virtual ~RequestAbstractTypeImpl() {
 282                 XMLString::release(&m_ID);
 283                 XMLString::release(&m_Version);
 284                 XMLString::release(&m_Destination);
 285                 XMLString::release(&m_Consent);
 286                 delete m_IssueInstant;
 287             }
 288
 289             RequestAbstractTypeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 290                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 291                 init();
 292             }
 293
 294             RequestAbstractTypeImpl(const RequestAbstractTypeImpl& src)
 295                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 296                 init();
 297             }
 298
 299             void _clone(const RequestAbstractTypeImpl& src) {
 300                 setID(src.getID());
 301                 setVersion(src.getVersion());
 302                 setIssueInstant(src.getIssueInstant());
 303                 setDestination(src.getDestination());
 304                 setConsent(src.getConsent());
 305                 if (src.getIssuer())
 306                     setIssuer(src.getIssuer()->cloneIssuer());
 307                 if (src.getSignature())
 308                     setSignature(src.getSignature()->cloneSignature());
 309                 if (src.getExtensions())
 310                     setExtensions(src.getExtensions()->cloneExtensions());
 311             }
 312
 313             //IMPL_TYPED_CHILD(Signature);
 314             // Need customized setter.
 315         protected:
 316             Signature* m_Signature;
 317             list<XMLObject*>::iterator m_pos_Signature;
 318         public:
 319             Signature* getSignature() const {
 320                 return m_Signature;
 321             }
 322
 323             void setSignature(Signature* sig) {
 324                 prepareForAssignment(m_Signature,sig);
 325                 *m_pos_Signature=m_Signature=sig;
 326                 // Sync content reference back up.
 327                 if (m_Signature)
 328                     m_Signature->setContentReference(new opensaml::ContentReference(*this));
 329             }
 330
 331             RequestAbstractType* cloneRequestAbstractType() const {
 332                 return dynamic_cast<RequestAbstractType*>(clone());
 333             }
 334
 335             IMPL_STRING_ATTRIB(Version);
 336             IMPL_ID_ATTRIB_EX(ID,ID,nullptr);
 337             IMPL_DATETIME_ATTRIB(IssueInstant,0);
 338             IMPL_STRING_ATTRIB(Destination);
 339             IMPL_STRING_ATTRIB(Consent);
 340             IMPL_TYPED_FOREIGN_CHILD(Issuer,saml2);
 341             IMPL_TYPED_CHILD(Extensions);
 342
 343         protected:
 344             void prepareForMarshalling() const {
 345                 if (m_Signature)
 346                     declareNonVisibleNamespaces();
 347             }
 348
 349             void marshallAttributes(DOMElement* domElement) const {
 350                 if (!m_Version)
 351                     const_cast<RequestAbstractTypeImpl*>(this)->m_Version=XMLString::transcode("2.0");
 352                 MARSHALL_STRING_ATTRIB(Version,VER,nullptr);
 353                 if (!m_ID)
 354                     const_cast<RequestAbstractTypeImpl*>(this)->m_ID=SAMLConfig::getConfig().generateIdentifier();
 355                 MARSHALL_ID_ATTRIB(ID,ID,nullptr);
 356                 if (!m_IssueInstant) {
 357                     const_cast<RequestAbstractTypeImpl*>(this)->m_IssueInstantEpoch=time(nullptr);
 358                     const_cast<RequestAbstractTypeImpl*>(this)->m_IssueInstant=new DateTime(m_IssueInstantEpoch);
 359                 }
 360                 MARSHALL_DATETIME_ATTRIB(IssueInstant,ISSUEINSTANT,nullptr);
 361                 MARSHALL_STRING_ATTRIB(Destination,DESTINATION,nullptr);
 362                 MARSHALL_STRING_ATTRIB(Consent,CONSENT,nullptr);
 363             }
 364
 365             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 366                 PROC_TYPED_FOREIGN_CHILD(Issuer,saml2,SAML20_NS,false);
 367                 PROC_TYPED_FOREIGN_CHILD(Signature,xmlsignature,XMLSIG_NS,false);
 368                 PROC_TYPED_CHILD(Extensions,SAML20P_NS,false);
 369                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 370             }
 371
 372             void processAttribute(const DOMAttr* attribute) {
 373                 PROC_ID_ATTRIB(ID,ID,nullptr);
 374                 PROC_STRING_ATTRIB(Version,VER,nullptr);
 375                 PROC_DATETIME_ATTRIB(IssueInstant,ISSUEINSTANT,nullptr);
 376                 PROC_STRING_ATTRIB(Destination,DESTINATION,nullptr);
 377                 PROC_STRING_ATTRIB(Consent,CONSENT,nullptr);
 378                 AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 379             }
 380         };
 381
 382
 383         class SAML_DLLLOCAL AssertionIDRequestImpl : public virtual AssertionIDRequest, public RequestAbstractTypeImpl
 384         {
 385         public:
 386             virtual ~AssertionIDRequestImpl() { }
 387
 388             AssertionIDRequestImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 389                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) { }
 390
 391             AssertionIDRequestImpl(const AssertionIDRequestImpl& src) : AbstractXMLObject(src), RequestAbstractTypeImpl(src) {
 392             }
 393
 394             void _clone(const AssertionIDRequestImpl& src) {
 395                 RequestAbstractTypeImpl::_clone(src);
 396                 for (vector<AssertionIDRef*>::const_iterator i=src.m_AssertionIDRefs.begin(); i!=src.m_AssertionIDRefs.end(); i++) {
 397                     if (*i) {
 398                         getAssertionIDRefs().push_back((*i)->cloneAssertionIDRef());
 399                     }
 400                 }
 401             }
 402
 403             IMPL_XMLOBJECT_CLONE_EX(AssertionIDRequest);
 404             IMPL_TYPED_FOREIGN_CHILDREN(AssertionIDRef,saml2,m_children.end());
 405
 406         protected:
 407             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 408                 PROC_TYPED_FOREIGN_CHILDREN(AssertionIDRef,saml2,SAML20_NS,false);
 409                 RequestAbstractTypeImpl::processChildElement(childXMLObject,root);
 410             }
 411         };
 412
 413         class SAML_DLLLOCAL SubjectQueryImpl : public virtual SubjectQuery, public RequestAbstractTypeImpl
 414         {
 415             void init() {
 416                 m_Subject = nullptr;
 417                 m_children.push_back(nullptr);
 418                 m_pos_Subject = m_pos_Extensions;
 419                 ++m_pos_Subject;
 420             }
 421
 422         protected:
 423             SubjectQueryImpl() {
 424                 init();
 425             }
 426
 427         public:
 428             virtual ~SubjectQueryImpl() { }
 429
 430             SubjectQueryImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 431                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 432                 init();
 433             }
 434
 435             SubjectQueryImpl(const SubjectQueryImpl& src) : AbstractXMLObject(src), RequestAbstractTypeImpl(src) {
 436                 init();
 437             }
 438
 439             void _clone(const SubjectQueryImpl& src) {
 440                 RequestAbstractTypeImpl::_clone(src);
 441                 if (src.getSubject())
 442                     setSubject(src.getSubject()->cloneSubject());
 443             }
 444
 445             SubjectQuery* cloneSubjectQuery() const {
 446                 return dynamic_cast<SubjectQuery*>(clone());
 447             }
 448
 449             IMPL_TYPED_FOREIGN_CHILD(Subject,saml2);
 450
 451         protected:
 452             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 453                 PROC_TYPED_FOREIGN_CHILD(Subject,saml2,SAML20_NS,false);
 454                 RequestAbstractTypeImpl::processChildElement(childXMLObject,root);
 455             }
 456         };
 457
 458         class SAML_DLLLOCAL RequestedAuthnContextImpl : public virtual RequestedAuthnContext,
 459             public AbstractComplexElement,
 460             public AbstractDOMCachingXMLObject,
 461             public AbstractXMLObjectMarshaller,
 462             public AbstractXMLObjectUnmarshaller
 463         {
 464             void init() {
 465                 m_Comparison=nullptr;
 466             }
 467
 468         public:
 469             virtual ~RequestedAuthnContextImpl() {
 470                 XMLString::release(&m_Comparison);
 471             }
 472
 473             RequestedAuthnContextImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 474                     : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 475                 init();
 476             }
 477
 478             RequestedAuthnContextImpl(const RequestedAuthnContextImpl& src)
 479                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 480                 init();
 481                 setComparison(src.getComparison());
 482                 for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
 483                     if (*i) {
 484                         AuthnContextClassRef* classref=dynamic_cast<AuthnContextClassRef*>(*i);
 485                         if (classref) {
 486                             getAuthnContextClassRefs().push_back(classref->cloneAuthnContextClassRef());
 487                             continue;
 488                         }
 489
 490                         AuthnContextDeclRef* declref=dynamic_cast<AuthnContextDeclRef*>(*i);
 491                         if (declref) {
 492                             getAuthnContextDeclRefs().push_back(declref->cloneAuthnContextDeclRef());
 493                             continue;
 494                         }
 495                     }
 496                 }
 497             }
 498
 499             IMPL_XMLOBJECT_CLONE(RequestedAuthnContext);
 500             IMPL_STRING_ATTRIB(Comparison);
 501             IMPL_TYPED_FOREIGN_CHILDREN(AuthnContextClassRef,saml2,m_children.end());
 502             IMPL_TYPED_FOREIGN_CHILDREN(AuthnContextDeclRef,saml2,m_children.end());
 503
 504         protected:
 505             void marshallAttributes(DOMElement* domElement) const {
 506                 MARSHALL_STRING_ATTRIB(Comparison,COMPARISON,nullptr);
 507             }
 508
 509             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 510                 PROC_TYPED_FOREIGN_CHILDREN(AuthnContextClassRef,saml2,SAML20_NS,false);
 511                 PROC_TYPED_FOREIGN_CHILDREN(AuthnContextDeclRef,saml2,SAML20_NS,false);
 512                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 513             }
 514
 515             void processAttribute(const DOMAttr* attribute) {
 516                 PROC_STRING_ATTRIB(Comparison,COMPARISON,nullptr);
 517                 AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 518             }
 519         };
 520
 521         class SAML_DLLLOCAL AuthnQueryImpl : public virtual AuthnQuery, public SubjectQueryImpl
 522         {
 523             void init() {
 524                 m_SessionIndex=nullptr;
 525                 m_RequestedAuthnContext=nullptr;
 526                 m_children.push_back(nullptr);
 527                 m_pos_RequestedAuthnContext = m_pos_Subject;
 528                 ++m_pos_RequestedAuthnContext;
 529
 530             }
 531
 532         public:
 533             virtual ~AuthnQueryImpl() {
 534                 XMLString::release(&m_SessionIndex);
 535             }
 536
 537             AuthnQueryImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 538                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 539                 init();
 540             }
 541
 542             AuthnQueryImpl(const AuthnQueryImpl& src) : AbstractXMLObject(src), SubjectQueryImpl(src) {
 543                 init();
 544             }
 545
 546             void _clone(const AuthnQueryImpl& src) {
 547                 SubjectQueryImpl::_clone(src);
 548                 setSessionIndex(src.getSessionIndex());
 549                 if (src.getRequestedAuthnContext())
 550                     setRequestedAuthnContext(src.getRequestedAuthnContext()->cloneRequestedAuthnContext());
 551             }
 552
 553             IMPL_XMLOBJECT_CLONE_EX(AuthnQuery);
 554             IMPL_STRING_ATTRIB(SessionIndex);
 555             IMPL_TYPED_CHILD(RequestedAuthnContext);
 556
 557         protected:
 558             void marshallAttributes(DOMElement* domElement) const {
 559                 MARSHALL_STRING_ATTRIB(SessionIndex,SESSIONINDEX,nullptr);
 560                 SubjectQueryImpl::marshallAttributes(domElement);
 561             }
 562
 563             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 564                 PROC_TYPED_CHILD(RequestedAuthnContext,SAML20P_NS,false);
 565                 SubjectQueryImpl::processChildElement(childXMLObject,root);
 566             }
 567             void processAttribute(const DOMAttr* attribute) {
 568                 PROC_STRING_ATTRIB(SessionIndex,SESSIONINDEX,nullptr);
 569                 SubjectQueryImpl::processAttribute(attribute);
 570             }
 571         };
 572
 573         class SAML_DLLLOCAL AttributeQueryImpl : public virtual AttributeQuery, public SubjectQueryImpl
 574         {
 575         public:
 576             virtual ~AttributeQueryImpl() { }
 577
 578             AttributeQueryImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 579                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) { }
 580
 581             AttributeQueryImpl(const AttributeQueryImpl& src) : AbstractXMLObject(src), SubjectQueryImpl(src) {
 582             }
 583
 584             void _clone(const AttributeQueryImpl& src) {
 585                 SubjectQueryImpl::_clone(src);
 586                 for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
 587                     if (*i) {
 588                         Attribute* attrib=dynamic_cast<Attribute*>(*i);
 589                         if (attrib) {
 590                             getAttributes().push_back(attrib->cloneAttribute());
 591                             continue;
 592                         }
 593                     }
 594                 }
 595             }
 596
 597             IMPL_XMLOBJECT_CLONE_EX(AttributeQuery);
 598             IMPL_TYPED_FOREIGN_CHILDREN(Attribute,saml2,m_children.end());
 599
 600         protected:
 601             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 602                 PROC_TYPED_FOREIGN_CHILDREN(Attribute,saml2,SAML20_NS,false);
 603                 SubjectQueryImpl::processChildElement(childXMLObject,root);
 604             }
 605         };
 606
 607         class SAML_DLLLOCAL AuthzDecisionQueryImpl : public virtual AuthzDecisionQuery, public SubjectQueryImpl
 608         {
 609             void init() {
 610                 m_Resource=nullptr;
 611                 m_Evidence=nullptr;
 612                 m_children.push_back(nullptr);
 613                 m_pos_Evidence=m_pos_Subject;
 614                 ++m_pos_Evidence;
 615             }
 616
 617         public:
 618             virtual ~AuthzDecisionQueryImpl() {
 619                 XMLString::release(&m_Resource);
 620             }
 621
 622             AuthzDecisionQueryImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 623                     : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 624                 init();
 625             }
 626
 627             AuthzDecisionQueryImpl(const AuthzDecisionQueryImpl& src) : AbstractXMLObject(src), SubjectQueryImpl(src) {
 628                 init();
 629             }
 630
 631             void _clone(const AuthzDecisionQueryImpl& src) {
 632                 SubjectQueryImpl::_clone(src);
 633                 setResource(src.getResource());
 634                 if (src.getEvidence())
 635                     setEvidence(src.getEvidence()->cloneEvidence());
 636                 for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
 637                     if (*i) {
 638                         Action* action=dynamic_cast<Action*>(*i);
 639                         if (action) {
 640                             getActions().push_back(action->cloneAction());
 641                             continue;
 642                         }
 643                     }
 644                 }
 645             }
 646
 647             IMPL_XMLOBJECT_CLONE_EX(AuthzDecisionQuery);
 648             IMPL_STRING_ATTRIB(Resource);
 649             IMPL_TYPED_FOREIGN_CHILDREN(Action,saml2,m_pos_Evidence);
 650             IMPL_TYPED_FOREIGN_CHILD(Evidence,saml2);
 651
 652         protected:
 653             void marshallAttributes(DOMElement* domElement) const {
 654                 MARSHALL_STRING_ATTRIB(Resource,RESOURCE,nullptr);
 655                 SubjectQueryImpl::marshallAttributes(domElement);
 656             }
 657
 658             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 659                 PROC_TYPED_FOREIGN_CHILD(Evidence,saml2,SAML20_NS,false);
 660                 PROC_TYPED_FOREIGN_CHILDREN(Action,saml2,SAML20_NS,false);
 661                 SubjectQueryImpl::processChildElement(childXMLObject,root);
 662             }
 663             void processAttribute(const DOMAttr* attribute) {
 664                 PROC_STRING_ATTRIB(Resource,RESOURCE,nullptr);
 665                 SubjectQueryImpl::processAttribute(attribute);
 666             }
 667         };
 668
 669         class SAML_DLLLOCAL NameIDPolicyImpl : public virtual NameIDPolicy,
 670             public AbstractSimpleElement,
 671             public AbstractDOMCachingXMLObject,
 672             public AbstractXMLObjectMarshaller,
 673             public AbstractXMLObjectUnmarshaller
 674         {
 675             void init() {
 676                 m_Format=nullptr;
 677                 m_SPNameQualifier=nullptr;
 678                 m_AllowCreate=XML_BOOL_NULL;
 679             }
 680
 681             public:
 682                 virtual ~NameIDPolicyImpl() {
 683                     XMLString::release(&m_Format);
 684                     XMLString::release(&m_SPNameQualifier);
 685                 }
 686
 687                 NameIDPolicyImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 688                         : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 689                     init();
 690                 }
 691
 692                 NameIDPolicyImpl(const NameIDPolicyImpl& src)
 693                         : AbstractXMLObject(src), AbstractSimpleElement(src), AbstractDOMCachingXMLObject(src) {
 694                     init();
 695                     setFormat(src.getFormat());
 696                     setSPNameQualifier(src.getSPNameQualifier());
 697                     AllowCreate(src.m_AllowCreate);
 698                 }
 699
 700                 IMPL_XMLOBJECT_CLONE(NameIDPolicy);
 701                 IMPL_STRING_ATTRIB(Format);
 702                 IMPL_STRING_ATTRIB(SPNameQualifier);
 703                 IMPL_BOOLEAN_ATTRIB(AllowCreate);
 704
 705             protected:
 706                 void marshallAttributes(DOMElement* domElement) const {
 707                     MARSHALL_STRING_ATTRIB(Format,FORMAT,nullptr);
 708                     MARSHALL_STRING_ATTRIB(SPNameQualifier,SPNAMEQUALIFIER,nullptr);
 709                     MARSHALL_BOOLEAN_ATTRIB(AllowCreate,ALLOWCREATE,nullptr);
 710                 }
 711
 712                 void processAttribute(const DOMAttr* attribute) {
 713                     PROC_STRING_ATTRIB(Format,FORMAT,nullptr);
 714                     PROC_STRING_ATTRIB(SPNameQualifier,SPNAMEQUALIFIER,nullptr);
 715                     PROC_BOOLEAN_ATTRIB(AllowCreate,ALLOWCREATE,nullptr);
 716                     AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 717                 }
 718         };
 719
 720         class SAML_DLLLOCAL IDPEntryImpl : public virtual IDPEntry,
 721             public AbstractSimpleElement,
 722             public AbstractDOMCachingXMLObject,
 723             public AbstractXMLObjectMarshaller,
 724             public AbstractXMLObjectUnmarshaller
 725         {
 726             void init() {
 727                 m_ProviderID=nullptr;
 728                 m_Name=nullptr;
 729                 m_Loc=nullptr;
 730             }
 731
 732             public:
 733                 virtual ~IDPEntryImpl() {
 734                     XMLString::release(&m_ProviderID);
 735                     XMLString::release(&m_Name);
 736                     XMLString::release(&m_Loc);
 737                 }
 738
 739                 IDPEntryImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 740                         : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 741                     init();
 742                 }
 743
 744                 IDPEntryImpl(const IDPEntryImpl& src) : AbstractXMLObject(src), AbstractSimpleElement(src), AbstractDOMCachingXMLObject(src) {
 745                     init();
 746                     setProviderID(src.getProviderID());
 747                     setName(src.getName());
 748                     setLoc(src.getLoc());
 749                 }
 750
 751                 IMPL_XMLOBJECT_CLONE(IDPEntry);
 752                 IMPL_STRING_ATTRIB(ProviderID);
 753                 IMPL_STRING_ATTRIB(Name);
 754                 IMPL_STRING_ATTRIB(Loc);
 755
 756             protected:
 757                 void marshallAttributes(DOMElement* domElement) const {
 758                     MARSHALL_STRING_ATTRIB(ProviderID,PROVIDERID,nullptr);
 759                     MARSHALL_STRING_ATTRIB(Name,NAME,nullptr);
 760                     MARSHALL_STRING_ATTRIB(Loc,LOC,nullptr);
 761                 }
 762
 763                 void processAttribute(const DOMAttr* attribute) {
 764                     PROC_STRING_ATTRIB(ProviderID,PROVIDERID,nullptr);
 765                     PROC_STRING_ATTRIB(Name,NAME,nullptr);
 766                     PROC_STRING_ATTRIB(Loc,LOC,nullptr);
 767                     AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 768                 }
 769         };
 770
 771         class SAML_DLLLOCAL IDPListImpl : public virtual IDPList,
 772             public AbstractComplexElement,
 773             public AbstractDOMCachingXMLObject,
 774             public AbstractXMLObjectMarshaller,
 775             public AbstractXMLObjectUnmarshaller
 776         {
 777             void init() {
 778                 m_GetComplete=nullptr;
 779                 m_children.push_back(nullptr);
 780                 m_pos_GetComplete=m_children.begin();
 781             }
 782
 783         public:
 784             virtual ~IDPListImpl() { }
 785
 786             IDPListImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 787                     : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 788                 init();
 789             }
 790
 791             IDPListImpl(const IDPListImpl& src)
 792                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 793                 init();
 794                 if (src.getGetComplete())
 795                     setGetComplete(src.getGetComplete()->cloneGetComplete());
 796                 for (vector<IDPEntry*>::const_iterator i=src.m_IDPEntrys.begin(); i!=src.m_IDPEntrys.end(); ++i) {
 797                     if (*i) {
 798                         getIDPEntrys().push_back((*i)->cloneIDPEntry());
 799                     }
 800                 }
 801             }
 802
 803             IMPL_XMLOBJECT_CLONE(IDPList);
 804             IMPL_TYPED_CHILDREN(IDPEntry,m_pos_GetComplete);
 805             IMPL_TYPED_CHILD(GetComplete);
 806
 807         protected:
 808             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 809                 PROC_TYPED_CHILDREN(IDPEntry,SAML20P_NS,false);
 810                 PROC_TYPED_CHILD(GetComplete,SAML20P_NS,false);
 811                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 812             }
 813         };
 814
 815
 816         class SAML_DLLLOCAL ScopingImpl : public virtual Scoping,
 817             public AbstractComplexElement,
 818             public AbstractDOMCachingXMLObject,
 819             public AbstractXMLObjectMarshaller,
 820             public AbstractXMLObjectUnmarshaller
 821         {
 822             void init() {
 823                 m_ProxyCount=nullptr;
 824                 m_IDPList=nullptr;
 825                 m_children.push_back(nullptr);
 826                 m_pos_IDPList=m_children.begin();
 827             }
 828
 829         public:
 830             virtual ~ScopingImpl() {
 831                 XMLString::release(&m_ProxyCount);
 832             }
 833
 834             ScopingImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 835                     : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 836                 init();
 837             }
 838
 839             ScopingImpl(const ScopingImpl& src)
 840                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 841                 init();
 842                 setProxyCount(src.m_ProxyCount);
 843                 if (src.getIDPList())
 844                     setIDPList(src.getIDPList()->cloneIDPList());
 845                 for (vector<RequesterID*>::const_iterator i=src.m_RequesterIDs.begin(); i!=src.m_RequesterIDs.end(); ++i) {
 846                     if (*i) {
 847                         getRequesterIDs().push_back((*i)->cloneRequesterID());
 848                     }
 849                 }
 850             }
 851
 852             IMPL_XMLOBJECT_CLONE(Scoping);
 853             IMPL_INTEGER_ATTRIB(ProxyCount);
 854             IMPL_TYPED_CHILD(IDPList);
 855             IMPL_TYPED_CHILDREN(RequesterID,m_children.end());
 856
 857         protected:
 858             void marshallAttributes(DOMElement* domElement) const {
 859                 MARSHALL_INTEGER_ATTRIB(ProxyCount,PROXYCOUNT,nullptr);
 860             }
 861
 862             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 863                 PROC_TYPED_CHILD(IDPList,SAML20P_NS,false);
 864                 PROC_TYPED_CHILDREN(RequesterID,SAML20P_NS,false);
 865                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 866             }
 867
 868             void processAttribute(const DOMAttr* attribute) {
 869                 PROC_INTEGER_ATTRIB(ProxyCount,PROXYCOUNT,nullptr);
 870                 AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 871             }
 872         };
 873
 874         class SAML_DLLLOCAL AuthnRequestImpl : public virtual AuthnRequest, public RequestAbstractTypeImpl
 875         {
 876             void init() {
 877                 m_ForceAuthn=XML_BOOL_NULL;
 878                 m_IsPassive=XML_BOOL_NULL;
 879                 m_ProtocolBinding=nullptr;
 880                 m_AssertionConsumerServiceIndex=nullptr;
 881                 m_AssertionConsumerServiceURL=nullptr;
 882                 m_AttributeConsumingServiceIndex=nullptr;
 883                 m_ProviderName=nullptr;
 884
 885                 m_Subject=nullptr;
 886                 m_NameIDPolicy=nullptr;
 887                 m_Conditions=nullptr;
 888                 m_RequestedAuthnContext=nullptr;
 889                 m_Scoping=nullptr;
 890                 m_children.push_back(nullptr);
 891                 m_children.push_back(nullptr);
 892                 m_children.push_back(nullptr);
 893                 m_children.push_back(nullptr);
 894                 m_children.push_back(nullptr);
 895                 m_pos_Subject=m_pos_Extensions;
 896                 ++m_pos_Subject;
 897                 m_pos_NameIDPolicy=m_pos_Subject;
 898                 ++m_pos_NameIDPolicy;
 899                 m_pos_Conditions=m_pos_NameIDPolicy;
 900                 ++m_pos_Conditions;
 901                 m_pos_RequestedAuthnContext=m_pos_Conditions;
 902                 ++m_pos_RequestedAuthnContext;
 903                 m_pos_Scoping=m_pos_RequestedAuthnContext;
 904                 ++m_pos_Scoping;
 905             }
 906
 907         public:
 908             virtual ~AuthnRequestImpl() {
 909                 XMLString::release(&m_ProtocolBinding);
 910                 XMLString::release(&m_AssertionConsumerServiceURL);
 911                 XMLString::release(&m_ProviderName);
 912                 XMLString::release(&m_AssertionConsumerServiceIndex);
 913                 XMLString::release(&m_AttributeConsumingServiceIndex);
 914             }
 915
 916             AuthnRequestImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 917                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 918                 init();
 919             }
 920
 921             AuthnRequestImpl(const AuthnRequestImpl& src) : AbstractXMLObject(src), RequestAbstractTypeImpl(src) {
 922                 init();
 923             }
 924
 925             void _clone(const AuthnRequestImpl& src) {
 926                 RequestAbstractTypeImpl::_clone(src);
 927                 ForceAuthn(src.m_ForceAuthn);
 928                 IsPassive(src.m_IsPassive);
 929                 setProtocolBinding(src.getProtocolBinding());
 930                 setAssertionConsumerServiceIndex(src.m_AssertionConsumerServiceIndex);
 931                 setAssertionConsumerServiceURL(src.getAssertionConsumerServiceURL());
 932                 setAttributeConsumingServiceIndex(src.m_AttributeConsumingServiceIndex);
 933                 setProviderName(src.getProviderName());
 934                 if (src.getSubject())
 935                     setSubject(src.getSubject()->cloneSubject());
 936                 if (src.getNameIDPolicy())
 937                     setNameIDPolicy(src.getNameIDPolicy()->cloneNameIDPolicy());
 938                 if (src.getConditions())
 939                     setConditions(src.getConditions()->cloneConditions());
 940                 if (src.getRequestedAuthnContext())
 941                     setRequestedAuthnContext(src.getRequestedAuthnContext()->cloneRequestedAuthnContext());
 942                 if (src.getScoping())
 943                     setScoping(src.getScoping()->cloneScoping());
 944             }
 945
 946             IMPL_XMLOBJECT_CLONE_EX(AuthnRequest);
 947
 948             IMPL_BOOLEAN_ATTRIB(ForceAuthn);
 949             IMPL_BOOLEAN_ATTRIB(IsPassive);
 950             IMPL_STRING_ATTRIB(ProtocolBinding);
 951             IMPL_INTEGER_ATTRIB(AssertionConsumerServiceIndex);
 952             IMPL_STRING_ATTRIB(AssertionConsumerServiceURL);
 953             IMPL_INTEGER_ATTRIB(AttributeConsumingServiceIndex);
 954             IMPL_STRING_ATTRIB(ProviderName);
 955
 956             IMPL_TYPED_FOREIGN_CHILD(Subject,saml2);
 957             IMPL_TYPED_CHILD(NameIDPolicy);
 958             IMPL_TYPED_FOREIGN_CHILD(Conditions,saml2);
 959             IMPL_TYPED_CHILD(RequestedAuthnContext);
 960             IMPL_TYPED_CHILD(Scoping);
 961
 962         protected:
 963             void marshallAttributes(DOMElement* domElement) const {
 964                 MARSHALL_BOOLEAN_ATTRIB(ForceAuthn,FORCEAUTHN,nullptr);
 965                 MARSHALL_BOOLEAN_ATTRIB(IsPassive,ISPASSIVE,nullptr);
 966                 MARSHALL_STRING_ATTRIB(ProtocolBinding,PROTOCOLBINDING,nullptr);
 967                 MARSHALL_INTEGER_ATTRIB(AssertionConsumerServiceIndex,ASSERTIONCONSUMERSERVICEINDEX,nullptr);
 968                 MARSHALL_STRING_ATTRIB(AssertionConsumerServiceURL,ASSERTIONCONSUMERSERVICEURL,nullptr);
 969                 MARSHALL_INTEGER_ATTRIB(AttributeConsumingServiceIndex,ATTRIBUTECONSUMINGSERVICEINDEX,nullptr);
 970                 MARSHALL_STRING_ATTRIB(ProviderName,PROVIDERNAME,nullptr);
 971                 RequestAbstractTypeImpl::marshallAttributes(domElement);
 972             }
 973
 974             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 975                 PROC_TYPED_FOREIGN_CHILD(Subject,saml2,SAML20_NS,false);
 976                 PROC_TYPED_CHILD(NameIDPolicy,SAML20P_NS,false);
 977                 PROC_TYPED_FOREIGN_CHILD(Conditions,saml2,SAML20_NS,false);
 978                 PROC_TYPED_CHILD(RequestedAuthnContext,SAML20P_NS,false);
 979                 PROC_TYPED_CHILD(Scoping,SAML20P_NS,false);
 980                 RequestAbstractTypeImpl::processChildElement(childXMLObject,root);
 981             }
 982             void processAttribute(const DOMAttr* attribute) {
 983                 PROC_BOOLEAN_ATTRIB(ForceAuthn,FORCEAUTHN,nullptr);
 984                 PROC_BOOLEAN_ATTRIB(IsPassive,ISPASSIVE,nullptr);
 985                 PROC_STRING_ATTRIB(ProtocolBinding,PROTOCOLBINDING,nullptr);
 986                 PROC_INTEGER_ATTRIB(AssertionConsumerServiceIndex,ASSERTIONCONSUMERSERVICEINDEX,nullptr);
 987                 PROC_STRING_ATTRIB(AssertionConsumerServiceURL,ASSERTIONCONSUMERSERVICEURL,nullptr);
 988                 PROC_INTEGER_ATTRIB(AttributeConsumingServiceIndex,ATTRIBUTECONSUMINGSERVICEINDEX,nullptr);
 989                 PROC_STRING_ATTRIB(ProviderName,PROVIDERNAME,nullptr);
 990                 RequestAbstractTypeImpl::processAttribute(attribute);
 991             }
 992         };
 993
 994         class SAML_DLLLOCAL StatusResponseTypeImpl : public virtual StatusResponseType,
 995             public AbstractComplexElement,
 996             public AbstractDOMCachingXMLObject,
 997             public AbstractXMLObjectMarshaller,
 998             public AbstractXMLObjectUnmarshaller
 999         {
1000             void init() {
1001                 m_ID=nullptr;
1002                 m_InResponseTo=nullptr;
1003                 m_Version=nullptr;
1004                 m_IssueInstant=nullptr;
1005                 m_Destination=nullptr;
1006                 m_Consent=nullptr;
1007                 m_Issuer=nullptr;
1008                 m_Signature=nullptr;
1009                 m_Extensions=nullptr;
1010                 m_Status=nullptr;
1011                 m_children.push_back(nullptr);
1012                 m_children.push_back(nullptr);
1013                 m_children.push_back(nullptr);
1014                 m_children.push_back(nullptr);
1015                 m_pos_Issuer=m_children.begin();
1016                 m_pos_Signature=m_pos_Issuer;
1017                 ++m_pos_Signature;
1018                 m_pos_Extensions=m_pos_Signature;
1019                 ++m_pos_Extensions;
1020                 m_pos_Status=m_pos_Extensions;
1021                 ++m_pos_Status;
1022             }
1023
1024         protected:
1025             StatusResponseTypeImpl() {
1026                 init();
1027             }
1028
1029         public:
1030             virtual ~StatusResponseTypeImpl() {
1031                 XMLString::release(&m_ID);
1032                 XMLString::release(&m_InResponseTo);
1033                 XMLString::release(&m_Version);
1034                 XMLString::release(&m_Destination);
1035                 XMLString::release(&m_Consent);
1036                 delete m_IssueInstant;
1037             }
1038
1039             StatusResponseTypeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
1040                     : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
1041                 init();
1042             }
1043
1044             StatusResponseTypeImpl(const StatusResponseTypeImpl& src)
1045                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
1046                 init();
1047             }
1048
1049             void _clone(const StatusResponseTypeImpl& src) {
1050                 setID(src.getID());
1051                 setInResponseTo(src.getInResponseTo());
1052                 setVersion(src.getVersion());
1053                 setIssueInstant(src.getIssueInstant());
1054                 setDestination(src.getDestination());
1055                 setConsent(src.getConsent());
1056                 if (src.getIssuer())
1057                     setIssuer(src.getIssuer()->cloneIssuer());
1058                 if (src.getSignature())
1059                     setSignature(src.getSignature()->cloneSignature());
1060                 if (src.getExtensions())
1061                     setExtensions(src.getExtensions()->cloneExtensions());
1062                 if (src.getStatus())
1063                     setStatus(src.getStatus()->cloneStatus());
1064             }
1065
1066             //IMPL_TYPED_CHILD(Signature);
1067             // Need customized setter.
1068         protected:
1069             Signature* m_Signature;
1070             list<XMLObject*>::iterator m_pos_Signature;
1071         public:
1072             Signature* getSignature() const {
1073                 return m_Signature;
1074             }
1075
1076             void setSignature(Signature* sig) {
1077                 prepareForAssignment(m_Signature,sig);
1078                 *m_pos_Signature=m_Signature=sig;
1079                 // Sync content reference back up.
1080                 if (m_Signature)
1081                     m_Signature->setContentReference(new opensaml::ContentReference(*this));
1082             }
1083
1084             StatusResponseType* cloneStatusResponseType() const {
1085                 return dynamic_cast<StatusResponseType*>(clone());
1086             }
1087
1088             IMPL_STRING_ATTRIB(Version);
1089             IMPL_ID_ATTRIB_EX(ID,ID,nullptr);
1090             IMPL_STRING_ATTRIB(InResponseTo);
1091             IMPL_DATETIME_ATTRIB(IssueInstant,0);
1092             IMPL_STRING_ATTRIB(Destination);
1093             IMPL_STRING_ATTRIB(Consent);
1094             IMPL_TYPED_FOREIGN_CHILD(Issuer,saml2);
1095             IMPL_TYPED_CHILD(Extensions);
1096             IMPL_TYPED_CHILD(Status);
1097
1098         protected:
1099             void prepareForMarshalling() const {
1100                 if (m_Signature)
1101                     declareNonVisibleNamespaces();
1102             }
1103
1104             void marshallAttributes(DOMElement* domElement) const {
1105                 if (!m_Version)
1106                     const_cast<StatusResponseTypeImpl*>(this)->m_Version=XMLString::transcode("2.0");
1107                 MARSHALL_STRING_ATTRIB(Version,VER,nullptr);
1108                 if (!m_ID)
1109                     const_cast<StatusResponseTypeImpl*>(this)->m_ID=SAMLConfig::getConfig().generateIdentifier();
1110                 MARSHALL_ID_ATTRIB(ID,ID,nullptr);
1111                 if (!m_IssueInstant) {
1112                     const_cast<StatusResponseTypeImpl*>(this)->m_IssueInstantEpoch=time(nullptr);
1113                     const_cast<StatusResponseTypeImpl*>(this)->m_IssueInstant=new DateTime(m_IssueInstantEpoch);
1114                 }
1115                 MARSHALL_DATETIME_ATTRIB(IssueInstant,ISSUEINSTANT,nullptr);
1116                 MARSHALL_STRING_ATTRIB(Destination,DESTINATION,nullptr);
1117                 MARSHALL_STRING_ATTRIB(Consent,CONSENT,nullptr);
1118                 MARSHALL_STRING_ATTRIB(InResponseTo,INRESPONSETO,nullptr);
1119             }
1120
1121             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
1122                 PROC_TYPED_FOREIGN_CHILD(Issuer,saml2,SAML20_NS,false);
1123                 PROC_TYPED_FOREIGN_CHILD(Signature,xmlsignature,XMLSIG_NS,false);
1124                 PROC_TYPED_CHILD(Extensions,SAML20P_NS,false);
1125                 PROC_TYPED_CHILD(Status,SAML20P_NS,false);
1126                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
1127             }
1128
1129             void processAttribute(const DOMAttr* attribute) {
1130                 PROC_ID_ATTRIB(ID,ID,nullptr);
1131                 PROC_STRING_ATTRIB(Version,VER,nullptr);
1132                 PROC_STRING_ATTRIB(InResponseTo,INRESPONSETO,nullptr);
1133                 PROC_DATETIME_ATTRIB(IssueInstant,ISSUEINSTANT,nullptr);
1134                 PROC_STRING_ATTRIB(Destination,DESTINATION,nullptr);
1135                 PROC_STRING_ATTRIB(Consent,CONSENT,nullptr);
1136                 AbstractXMLObjectUnmarshaller::processAttribute(attribute);
1137             }
1138         };
1139
1140         class SAML_DLLLOCAL ResponseImpl : public virtual Response, public StatusResponseTypeImpl
1141         {
1142         public:
1143             virtual ~ResponseImpl() { }
1144
1145             ResponseImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
1146                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) { }
1147
1148             ResponseImpl(const ResponseImpl& src) : AbstractXMLObject(src), StatusResponseTypeImpl(src) {
1149             }
1150
1151             void _clone(const ResponseImpl& src) {
1152                 StatusResponseTypeImpl::_clone(src);
1153                 for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
1154                     if (*i) {
1155                         saml2::Assertion* assertion=dynamic_cast<saml2::Assertion*>(*i);
1156                         if (assertion) {
1157                             getAssertions().push_back(assertion->cloneAssertion());
1158                             continue;
1159                         }
1160                         EncryptedAssertion* encAssertion=dynamic_cast<EncryptedAssertion*>(*i);
1161                         if (encAssertion) {
1162                             getEncryptedAssertions().push_back(encAssertion->cloneEncryptedAssertion());
1163                             continue;
1164                         }
1165                     }
1166                 }
1167             }
1168
1169             IMPL_XMLOBJECT_CLONE_EX(Response);
1170             IMPL_TYPED_FOREIGN_CHILDREN(Assertion,saml2,m_children.end());
1171             IMPL_TYPED_FOREIGN_CHILDREN(EncryptedAssertion,saml2,m_children.end());
1172
1173         protected:
1174             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
1175                 PROC_TYPED_FOREIGN_CHILDREN(Assertion,saml2,SAML20_NS,false);
1176                 PROC_TYPED_FOREIGN_CHILDREN(EncryptedAssertion,saml2,SAML20_NS,false);
1177                 StatusResponseTypeImpl::processChildElement(childXMLObject,root);
1178             }
1179         };
1180
1181         class SAML_DLLLOCAL ArtifactResolveImpl : public virtual ArtifactResolve, public RequestAbstractTypeImpl
1182         {
1183             void init() {
1184                 m_Artifact=nullptr;
1185                 m_children.push_back(nullptr);
1186                 m_pos_Artifact=m_pos_Extensions;
1187                 ++m_pos_Artifact;
1188             }
1189
1190         public:
1191             virtual ~ArtifactResolveImpl() { }
1192
1193             ArtifactResolveImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
1194                     : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
1195                 init();
1196             }
1197
1198             ArtifactResolveImpl(const ArtifactResolveImpl& src) : AbstractXMLObject(src), RequestAbstractTypeImpl(src) {
1199                 init();
1200             }
1201
1202             void _clone(const ArtifactResolveImpl& src) {
1203                 RequestAbstractTypeImpl::_clone(src);
1204                 if(src.getArtifact())
1205                     setArtifact(src.getArtifact()->cloneArtifact());
1206             }
1207
1208             IMPL_XMLOBJECT_CLONE_EX(ArtifactResolve);
1209             IMPL_TYPED_CHILD(Artifact);
1210
1211         protected:
1212             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
1213                 PROC_TYPED_CHILD(Artifact,SAML20P_NS,false);
1214                 RequestAbstractTypeImpl::processChildElement(childXMLObject,root);
1215             }
1216         };
1217
1218         class SAML_DLLLOCAL ArtifactResponseImpl : public virtual ArtifactResponse, public StatusResponseTypeImpl
1219         {
1220             void init() {
1221                 m_Payload=nullptr;
1222                 m_children.push_back(nullptr);
1223                 m_pos_Payload=m_pos_Status;
1224                 ++m_pos_Payload;
1225             }
1226
1227         public:
1228             virtual ~ArtifactResponseImpl() { }
1229
1230             ArtifactResponseImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
1231                     : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
1232                 init();
1233             }
1234
1235             ArtifactResponseImpl(const ArtifactResponseImpl& src) : AbstractXMLObject(src), StatusResponseTypeImpl(src) {
1236                 init();
1237             }
1238
1239             void _clone(const ArtifactResponseImpl& src) {
1240                 StatusResponseTypeImpl::_clone(src);
1241                 if (src.getPayload())
1242                     setPayload(src.getPayload()->clone());
1243             }
1244
1245             IMPL_XMLOBJECT_CLONE_EX(ArtifactResponse);
1246             IMPL_XMLOBJECT_CHILD(Payload);
1247
1248         protected:
1249             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
1250                 // These are valid elements for the parent StatusResponseType, so don't process these.
1251                 // If not one of these, then it must be the payload.
1252                 if (!XMLHelper::isNodeNamed(root,SAML20_NS,saml2::Issuer::LOCAL_NAME) &&
1253                     !XMLHelper::isNodeNamed(root,XMLSIG_NS,xmlsignature::Signature::LOCAL_NAME) &&
1254                     !XMLHelper::isNodeNamed(root,SAML20P_NS,saml2p::Extensions::LOCAL_NAME) &&
1255                     !XMLHelper::isNodeNamed(root,SAML20P_NS,saml2p::Status::LOCAL_NAME)) {
1256                     setPayload(childXMLObject);
1257                     return;
1258                 }
1259
1260                 StatusResponseTypeImpl::processChildElement(childXMLObject,root);
1261             }
1262         };
1263
1264         class SAML_DLLLOCAL NewEncryptedIDImpl : public virtual NewEncryptedID,
1265             public AbstractComplexElement,
1266             public AbstractDOMCachingXMLObject,
1267             public AbstractXMLObjectMarshaller,
1268             public AbstractXMLObjectUnmarshaller
1269         {
1270             void init() {
1271                 m_EncryptedData=nullptr;
1272                 m_children.push_back(nullptr);
1273                 m_pos_EncryptedData=m_children.begin();
1274             }
1275
1276         protected:
1277             NewEncryptedIDImpl() {
1278                 init();
1279             }
1280
1281         public:
1282             virtual ~NewEncryptedIDImpl() {}
1283
1284             NewEncryptedIDImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
1285                     : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
1286                 init();
1287             }
1288
1289             NewEncryptedIDImpl(const NewEncryptedIDImpl& src)
1290                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
1291                 init();
1292                 if (src.getEncryptedData())
1293                     setEncryptedData(src.getEncryptedData()->cloneEncryptedData());
1294                 for (vector<xmlencryption::EncryptedKey*>::const_iterator i=src.m_EncryptedKeys.begin(); i!=src.m_EncryptedKeys.end(); i++) {
1295                     if (*i) {
1296                         getEncryptedKeys().push_back((*i)->cloneEncryptedKey());
1297                     }
1298                 }
1299             }
1300
1301             IMPL_XMLOBJECT_CLONE2(NewEncryptedID,EncryptedElementType);
1302             IMPL_TYPED_FOREIGN_CHILD(EncryptedData,xmlencryption);
1303             IMPL_TYPED_FOREIGN_CHILDREN(EncryptedKey,xmlencryption,m_children.end());
1304
1305         protected:
1306             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
1307                 PROC_TYPED_FOREIGN_CHILD(EncryptedData,xmlencryption,XMLENC_NS,false);
1308                 PROC_TYPED_FOREIGN_CHILDREN(EncryptedKey,xmlencryption,XMLENC_NS,false);
1309                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
1310             }
1311         };
1312
1313         class SAML_DLLLOCAL TerminateImpl : public virtual Terminate,
1314             public AbstractSimpleElement,
1315             public AbstractDOMCachingXMLObject,
1316             public AbstractXMLObjectMarshaller,
1317             public AbstractXMLObjectUnmarshaller
1318         {
1319             public:
1320                 virtual ~TerminateImpl() { }
1321
1322                 TerminateImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
1323                     : AbstractXMLObject(nsURI, localName, prefix, schemaType) { }
1324
1325                 TerminateImpl(const TerminateImpl& src)
1326                     : AbstractXMLObject(src), AbstractSimpleElement(src), AbstractDOMCachingXMLObject(src) {
1327                 }
1328
1329                 IMPL_XMLOBJECT_CLONE(Terminate);
1330
1331             protected:
1332                 // has no attributes or children
1333         };
1334
1335         class SAML_DLLLOCAL ManageNameIDRequestImpl : public virtual ManageNameIDRequest, public RequestAbstractTypeImpl
1336         {
1337             void init() {
1338                 m_NameID=nullptr;
1339                 m_EncryptedID=nullptr;
1340                 m_NewID=nullptr;
1341                 m_NewEncryptedID=nullptr;
1342                 m_Terminate=nullptr;
1343                 m_children.push_back(nullptr);
1344                 m_children.push_back(nullptr);
1345                 m_children.push_back(nullptr);
1346                 m_children.push_back(nullptr);
1347                 m_children.push_back(nullptr);
1348                 m_pos_NameID=m_pos_Extensions;
1349                 ++m_pos_NameID;
1350                 m_pos_EncryptedID=m_pos_NameID;
1351                 ++m_pos_EncryptedID;
1352                 m_pos_NewID=m_pos_EncryptedID;
1353                 ++m_pos_NewID;
1354                 m_pos_NewEncryptedID=m_pos_NewID;
1355                 ++m_pos_NewEncryptedID;
1356                 m_pos_Terminate=m_pos_NewEncryptedID;
1357                 ++m_pos_Terminate;
1358             }
1359
1360         public:
1361             virtual ~ManageNameIDRequestImpl() { }
1362
1363             ManageNameIDRequestImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
1364                     : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
1365                 init();
1366             }
1367
1368             ManageNameIDRequestImpl(const ManageNameIDRequestImpl& src) : AbstractXMLObject(src), RequestAbstractTypeImpl(src) {
1369                 init();
1370             }
1371
1372             void _clone(const ManageNameIDRequestImpl& src) {
1373                 RequestAbstractTypeImpl::_clone(src);
1374                 if (src.getNameID())
1375                     setNameID(src.getNameID()->cloneNameID());
1376                 if (src.getEncryptedID())
1377                     setEncryptedID(src.getEncryptedID()->cloneEncryptedID());
1378                 if (src.getNewID())
1379                     setNewID(src.getNewID()->cloneNewID());
1380                 if (src.getNewEncryptedID())
1381                     setNewEncryptedID(src.getNewEncryptedID()->cloneNewEncryptedID());
1382                 if (src.getTerminate())
1383                     setTerminate(src.getTerminate()->cloneTerminate());
1384             }
1385
1386             IMPL_XMLOBJECT_CLONE_EX(ManageNameIDRequest);
1387             IMPL_TYPED_FOREIGN_CHILD(NameID,saml2);
1388             IMPL_TYPED_FOREIGN_CHILD(EncryptedID,saml2);
1389             IMPL_TYPED_CHILD(NewID);
1390             IMPL_TYPED_CHILD(NewEncryptedID);
1391             IMPL_TYPED_CHILD(Terminate);
1392
1393         protected:
1394             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
1395                 PROC_TYPED_FOREIGN_CHILD(NameID,saml2,SAML20_NS,false);
1396                 PROC_TYPED_FOREIGN_CHILD(EncryptedID,saml2,SAML20_NS,false);
1397                 PROC_TYPED_CHILD(NewID,SAML20P_NS,false);
1398                 PROC_TYPED_CHILD(NewEncryptedID,SAML20P_NS,false);
1399                 PROC_TYPED_CHILD(Terminate,SAML20P_NS,false);
1400                 RequestAbstractTypeImpl::processChildElement(childXMLObject,root);
1401             }
1402         };
1403
1404         class SAML_DLLLOCAL ManageNameIDResponseImpl : public virtual ManageNameIDResponse, public StatusResponseTypeImpl
1405         {
1406         public:
1407             virtual ~ManageNameIDResponseImpl() { }
1408
1409             ManageNameIDResponseImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
1410                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) { }
1411
1412             ManageNameIDResponseImpl(const ManageNameIDResponseImpl& src) : AbstractXMLObject(src), StatusResponseTypeImpl(src) {
1413             }
1414
1415             IMPL_XMLOBJECT_CLONE_EX(ManageNameIDResponse);
1416         };
1417
1418         class SAML_DLLLOCAL LogoutRequestImpl : public virtual LogoutRequest, public RequestAbstractTypeImpl
1419         {
1420             void init() {
1421                 m_Reason=nullptr;
1422                 m_NotOnOrAfter=nullptr;
1423                 m_BaseID=nullptr;
1424                 m_NameID=nullptr;
1425                 m_EncryptedID=nullptr;
1426                 m_children.push_back(nullptr);
1427                 m_children.push_back(nullptr);
1428                 m_children.push_back(nullptr);
1429                 m_pos_BaseID=m_pos_Extensions;
1430                 ++m_pos_BaseID;
1431                 m_pos_NameID=m_pos_BaseID;
1432                 ++m_pos_NameID;
1433                 m_pos_EncryptedID=m_pos_NameID;
1434                 ++m_pos_EncryptedID;
1435             }
1436
1437         public:
1438             virtual ~LogoutRequestImpl() {
1439                 XMLString::release(&m_Reason);
1440                 delete m_NotOnOrAfter;
1441             }
1442
1443             LogoutRequestImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
1444                     : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
1445                 init();
1446             }
1447
1448             LogoutRequestImpl(const LogoutRequestImpl& src) : AbstractXMLObject(src), RequestAbstractTypeImpl(src) {
1449                 init();
1450             }
1451
1452             void _clone(const LogoutRequestImpl& src) {
1453                 RequestAbstractTypeImpl::_clone(src);
1454                 setReason(src.getReason());
1455                 setNotOnOrAfter(src.getNotOnOrAfter());
1456                 if (src.getBaseID())
1457                     setBaseID(src.getBaseID()->cloneBaseID());
1458                 if (src.getNameID())
1459                     setNameID(src.getNameID()->cloneNameID());
1460                 if (src.getEncryptedID())
1461                     setEncryptedID(src.getEncryptedID()->cloneEncryptedID());
1462
1463                 for (vector<SessionIndex*>::const_iterator i=src.m_SessionIndexs.begin(); i!=src.m_SessionIndexs.end(); ++i) {
1464                     if (*i) {
1465                         getSessionIndexs().push_back((*i)->cloneSessionIndex());
1466                     }
1467                 }
1468             }
1469
1470             IMPL_XMLOBJECT_CLONE_EX(LogoutRequest);
1471             IMPL_STRING_ATTRIB(Reason);
1472             IMPL_DATETIME_ATTRIB(NotOnOrAfter,SAMLTIME_MAX);
1473             IMPL_TYPED_FOREIGN_CHILD(BaseID,saml2);
1474             IMPL_TYPED_FOREIGN_CHILD(NameID,saml2);
1475             IMPL_TYPED_FOREIGN_CHILD(EncryptedID,saml2);
1476             IMPL_TYPED_CHILDREN(SessionIndex,m_children.end());
1477
1478         protected:
1479             void marshallAttributes(DOMElement* domElement) const {
1480                 MARSHALL_STRING_ATTRIB(Reason,REASON,nullptr);
1481                 MARSHALL_DATETIME_ATTRIB(NotOnOrAfter,NOTONORAFTER,nullptr);
1482                 RequestAbstractTypeImpl::marshallAttributes(domElement);
1483             }
1484
1485             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
1486                 PROC_TYPED_FOREIGN_CHILD(BaseID,saml2,SAML20_NS,false);
1487                 PROC_TYPED_FOREIGN_CHILD(NameID,saml2,SAML20_NS,false);
1488                 PROC_TYPED_FOREIGN_CHILD(EncryptedID,saml2,SAML20_NS,false);
1489                 PROC_TYPED_CHILDREN(SessionIndex,SAML20P_NS,false);
1490                 RequestAbstractTypeImpl::processChildElement(childXMLObject,root);
1491             }
1492             void processAttribute(const DOMAttr* attribute) {
1493                 PROC_STRING_ATTRIB(Reason,REASON,nullptr);
1494                 PROC_DATETIME_ATTRIB(NotOnOrAfter,NOTONORAFTER,nullptr);
1495                 RequestAbstractTypeImpl::processAttribute(attribute);
1496             }
1497         };
1498
1499         class SAML_DLLLOCAL LogoutResponseImpl : public virtual LogoutResponse, public StatusResponseTypeImpl
1500         {
1501         public:
1502             virtual ~LogoutResponseImpl() { }
1503
1504             LogoutResponseImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
1505                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) { }
1506
1507             LogoutResponseImpl(const LogoutResponseImpl& src) : AbstractXMLObject(src), StatusResponseTypeImpl(src) {
1508             }
1509
1510             IMPL_XMLOBJECT_CLONE_EX(LogoutResponse);
1511         };
1512
1513
1514         class SAML_DLLLOCAL NameIDMappingRequestImpl : public virtual NameIDMappingRequest, public RequestAbstractTypeImpl
1515         {
1516             void init() {
1517                 m_BaseID=nullptr;
1518                 m_NameID=nullptr;
1519                 m_EncryptedID=nullptr;
1520                 m_NameIDPolicy=nullptr;
1521                 m_children.push_back(nullptr);
1522                 m_children.push_back(nullptr);
1523                 m_children.push_back(nullptr);
1524                 m_children.push_back(nullptr);
1525                 m_pos_BaseID=m_pos_Extensions;
1526                 ++m_pos_BaseID;
1527                 m_pos_NameID=m_pos_BaseID;
1528                 ++m_pos_NameID;
1529                 m_pos_EncryptedID=m_pos_NameID;
1530                 ++m_pos_EncryptedID;
1531                 m_pos_NameIDPolicy=m_pos_EncryptedID;
1532                 ++m_pos_NameIDPolicy;
1533             }
1534
1535         public:
1536             virtual ~NameIDMappingRequestImpl() { }
1537
1538             NameIDMappingRequestImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
1539                     : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
1540                 init();
1541             }
1542
1543             NameIDMappingRequestImpl(const NameIDMappingRequestImpl& src) : AbstractXMLObject(src), RequestAbstractTypeImpl(src) {
1544                 init();
1545             }
1546
1547             void _clone(const NameIDMappingRequestImpl& src) {
1548                 RequestAbstractTypeImpl::_clone(src);
1549                 if (src.getBaseID())
1550                     setBaseID(src.getBaseID()->cloneBaseID());
1551                 if (src.getNameID())
1552                     setNameID(src.getNameID()->cloneNameID());
1553                 if (src.getEncryptedID())
1554                     setEncryptedID(src.getEncryptedID()->cloneEncryptedID());
1555                 if (src.getNameIDPolicy())
1556                     setNameIDPolicy(src.getNameIDPolicy()->cloneNameIDPolicy());
1557             }
1558
1559             IMPL_XMLOBJECT_CLONE_EX(NameIDMappingRequest);
1560             IMPL_TYPED_FOREIGN_CHILD(BaseID,saml2);
1561             IMPL_TYPED_FOREIGN_CHILD(NameID,saml2);
1562             IMPL_TYPED_FOREIGN_CHILD(EncryptedID,saml2);
1563             IMPL_TYPED_CHILD(NameIDPolicy);
1564
1565         protected:
1566             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
1567                 PROC_TYPED_FOREIGN_CHILD(BaseID,saml2,SAML20_NS,false);
1568                 PROC_TYPED_FOREIGN_CHILD(NameID,saml2,SAML20_NS,false);
1569                 PROC_TYPED_FOREIGN_CHILD(EncryptedID,saml2,SAML20_NS,false);
1570                 PROC_TYPED_CHILD(NameIDPolicy,SAML20P_NS,false);
1571                 RequestAbstractTypeImpl::processChildElement(childXMLObject,root);
1572             }
1573         };
1574
1575         class SAML_DLLLOCAL NameIDMappingResponseImpl : public virtual NameIDMappingResponse, public StatusResponseTypeImpl
1576         {
1577             void init() {
1578                 m_NameID=nullptr;
1579                 m_EncryptedID=nullptr;
1580                 m_children.push_back(nullptr);
1581                 m_children.push_back(nullptr);
1582                 m_pos_NameID=m_pos_Status;
1583                 ++m_pos_NameID;
1584                 m_pos_EncryptedID=m_pos_NameID;
1585                 ++m_pos_EncryptedID;
1586             }
1587
1588         public:
1589             virtual ~NameIDMappingResponseImpl() { }
1590
1591             NameIDMappingResponseImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
1592                     : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
1593                 init();
1594             }
1595
1596             NameIDMappingResponseImpl(const NameIDMappingResponseImpl& src) : AbstractXMLObject(src), StatusResponseTypeImpl(src) {
1597                 init();
1598             }
1599
1600             void _clone(const NameIDMappingResponseImpl& src) {
1601                 StatusResponseTypeImpl::_clone(src);
1602                 if (src.getNameID())
1603                     setNameID(src.getNameID()->cloneNameID());
1604                 if (src.getEncryptedID())
1605                     setEncryptedID(src.getEncryptedID()->cloneEncryptedID());
1606             }
1607
1608             IMPL_XMLOBJECT_CLONE_EX(NameIDMappingResponse);
1609             IMPL_TYPED_FOREIGN_CHILD(NameID,saml2);
1610             IMPL_TYPED_FOREIGN_CHILD(EncryptedID,saml2);
1611
1612         protected:
1613             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
1614                 PROC_TYPED_FOREIGN_CHILD(NameID,saml2,SAML20_NS,false);
1615                 PROC_TYPED_FOREIGN_CHILD(EncryptedID,saml2,SAML20_NS,false);
1616                 StatusResponseTypeImpl::processChildElement(childXMLObject,root);
1617             }
1618         };
1619     };
1620 };
1621
1622 #if defined (_MSC_VER)
1623     #pragma warning( pop )
1624 #endif
1625
1626 // Builder Implementations
1627 IMPL_XMLOBJECTBUILDER(Artifact);
1628 IMPL_XMLOBJECTBUILDER(ArtifactResolve);
1629 IMPL_XMLOBJECTBUILDER(ArtifactResponse);
1630 IMPL_XMLOBJECTBUILDER(AssertionIDRequest);
1631 IMPL_XMLOBJECTBUILDER(AttributeQuery);
1632 IMPL_XMLOBJECTBUILDER(AuthnQuery);
1633 IMPL_XMLOBJECTBUILDER(AuthnRequest);
1634 IMPL_XMLOBJECTBUILDER(AuthzDecisionQuery);
1635 IMPL_XMLOBJECTBUILDER(Extensions);
1636 IMPL_XMLOBJECTBUILDER(GetComplete);
1637 IMPL_XMLOBJECTBUILDER(IDPEntry);
1638 IMPL_XMLOBJECTBUILDER(IDPList);
1639 IMPL_XMLOBJECTBUILDER(LogoutRequest);
1640 IMPL_XMLOBJECTBUILDER(LogoutResponse);
1641 IMPL_XMLOBJECTBUILDER(ManageNameIDRequest);
1642 IMPL_XMLOBJECTBUILDER(ManageNameIDResponse);
1643 IMPL_XMLOBJECTBUILDER(NameIDMappingRequest);
1644 IMPL_XMLOBJECTBUILDER(NameIDMappingResponse);
1645 IMPL_XMLOBJECTBUILDER(NameIDPolicy);
1646 IMPL_XMLOBJECTBUILDER(NewEncryptedID);
1647 IMPL_XMLOBJECTBUILDER(NewID);
1648 IMPL_XMLOBJECTBUILDER(RequestedAuthnContext);
1649 IMPL_XMLOBJECTBUILDER(RequesterID);
1650 IMPL_XMLOBJECTBUILDER(Response);
1651 IMPL_XMLOBJECTBUILDER(Scoping);
1652 IMPL_XMLOBJECTBUILDER(SessionIndex);
1653 IMPL_XMLOBJECTBUILDER(Status);
1654 IMPL_XMLOBJECTBUILDER(StatusCode);
1655 IMPL_XMLOBJECTBUILDER(StatusDetail);
1656 IMPL_XMLOBJECTBUILDER(StatusMessage);
1657 IMPL_XMLOBJECTBUILDER(Terminate);
1658
1659 IMPL_XMLOBJECTBUILDER(RespondTo);
1660
1661 // Unicode literals
1662 const XMLCh Artifact::LOCAL_NAME[] = UNICODE_LITERAL_8(A,r,t,i,f,a,c,t);
1663 const XMLCh ArtifactResolve::LOCAL_NAME[] = UNICODE_LITERAL_15(A,r,t,i,f,a,c,t,R,e,s,o,l,v,e);
1664 const XMLCh ArtifactResolve::TYPE_NAME[] = UNICODE_LITERAL_19(A,r,t,i,f,a,c,t,R,e,s,o,l,v,e,T,y,p,e);
1665 const XMLCh ArtifactResponse::LOCAL_NAME[] = UNICODE_LITERAL_16(A,r,t,i,f,a,c,t,R,e,s,p,o,n,s,e);
1666 const XMLCh ArtifactResponse::TYPE_NAME[] = UNICODE_LITERAL_20(A,r,t,i,f,a,c,t,R,e,s,p,o,n,s,e,T,y,p,e);
1667 const XMLCh AssertionIDRequest::LOCAL_NAME[] = UNICODE_LITERAL_18(A,s,s,e,r,t,i,o,n,I,D,R,e,q,u,e,s,t);
1668 const XMLCh AssertionIDRequest::TYPE_NAME[] = UNICODE_LITERAL_22(A,s,s,e,r,t,i,o,n,I,D,R,e,q,u,e,s,t,T,y,p,e);
1669 const XMLCh AttributeQuery::LOCAL_NAME[] = UNICODE_LITERAL_14(A,t,t,r,i,b,u,t,e,Q,u,e,r,y);
1670 const XMLCh AttributeQuery::TYPE_NAME[] = UNICODE_LITERAL_18(A,t,t,r,i,b,u,t,e,Q,u,e,r,y,T,y,p,e);
1671 const XMLCh AuthnQuery::LOCAL_NAME[] = UNICODE_LITERAL_10(A,u,t,h,n,Q,u,e,r,y);
1672 const XMLCh AuthnQuery::TYPE_NAME[] = UNICODE_LITERAL_14(A,u,t,h,n,Q,u,e,r,y,T,y,p,e);
1673 const XMLCh AuthnQuery::SESSIONINDEX_ATTRIB_NAME[] = UNICODE_LITERAL_12(S,e,s,s,i,o,n,I,n,d,e,x);
1674 const XMLCh AuthnRequest::LOCAL_NAME[] = UNICODE_LITERAL_12(A,u,t,h,n,R,e,q,u,e,s,t);
1675 const XMLCh AuthnRequest::TYPE_NAME[] = UNICODE_LITERAL_16(A,u,t,h,n,R,e,q,u,e,s,t,T,y,p,e);
1676 const XMLCh AuthnRequest::FORCEAUTHN_ATTRIB_NAME[] = UNICODE_LITERAL_10(F,o,r,c,e,A,u,t,h,n);
1677 const XMLCh AuthnRequest::ISPASSIVE_ATTRIB_NAME[] = UNICODE_LITERAL_9(I,s,P,a,s,s,i,v,e);
1678 const XMLCh AuthnRequest::PROTOCOLBINDING_ATTRIB_NAME[] = UNICODE_LITERAL_15(P,r,o,t,o,c,o,l,B,i,n,d,i,n,g);
1679 const XMLCh AuthnRequest::ASSERTIONCONSUMERSERVICEINDEX_ATTRIB_NAME[] = UNICODE_LITERAL_29(A,s,s,e,r,t,i,o,n,C,o,n,s,u,m,e,r,S,e,r,v,i,c,e,I,n,d,e,x);
1680 const XMLCh AuthnRequest::ASSERTIONCONSUMERSERVICEURL_ATTRIB_NAME[] = UNICODE_LITERAL_27(A,s,s,e,r,t,i,o,n,C,o,n,s,u,m,e,r,S,e,r,v,i,c,e,U,R,L);
1681 const XMLCh AuthnRequest::ATTRIBUTECONSUMINGSERVICEINDEX_ATTRIB_NAME[] = UNICODE_LITERAL_30(A,t,t,r,i,b,u,t,e,C,o,n,s,u,m,i,n,g,S,e,r,v,i,c,e,I,n,d,e,x);
1682 const XMLCh AuthnRequest::PROVIDERNAME_ATTRIB_NAME[] = UNICODE_LITERAL_12(P,r,o,v,i,d,e,r,N,a,m,e);
1683 const XMLCh AuthzDecisionQuery::LOCAL_NAME[] = UNICODE_LITERAL_18(A,u,t,h,z,D,e,c,i,s,i,o,n,Q,u,e,r,y);
1684 const XMLCh AuthzDecisionQuery::TYPE_NAME[] = UNICODE_LITERAL_22(A,u,t,h,z,D,e,c,i,s,i,o,n,Q,u,e,r,y,T,y,p,e);
1685 const XMLCh AuthzDecisionQuery::RESOURCE_ATTRIB_NAME[] = UNICODE_LITERAL_8(R,e,s,o,u,r,c,e);
1686 const XMLCh Extensions::LOCAL_NAME[] = UNICODE_LITERAL_10(E,x,t,e,n,s,i,o,n,s);
1687 const XMLCh Extensions::TYPE_NAME[] = UNICODE_LITERAL_14(E,x,t,e,n,s,i,o,n,s,T,y,p,e);
1688 const XMLCh GetComplete::LOCAL_NAME[] = UNICODE_LITERAL_11(G,e,t,C,o,m,p,l,e,t,e);
1689 const XMLCh IDPEntry::LOCAL_NAME[] = UNICODE_LITERAL_8(I,D,P,E,n,t,r,y);
1690 const XMLCh IDPEntry::TYPE_NAME[] = UNICODE_LITERAL_12(I,D,P,E,n,t,r,y,T,y,p,e);
1691 const XMLCh IDPEntry::PROVIDERID_ATTRIB_NAME[] = UNICODE_LITERAL_10(P,r,o,v,i,d,e,r,I,D);
1692 const XMLCh IDPEntry::NAME_ATTRIB_NAME[] = UNICODE_LITERAL_4(N,a,m,e);
1693 const XMLCh IDPEntry::LOC_ATTRIB_NAME[] = UNICODE_LITERAL_3(L,o,c);
1694 const XMLCh IDPList::LOCAL_NAME[] = UNICODE_LITERAL_7(I,D,P,L,i,s,t);
1695 const XMLCh IDPList::TYPE_NAME[] = UNICODE_LITERAL_11(I,D,P,L,i,s,t,T,y,p,e);
1696 const XMLCh LogoutRequest::LOCAL_NAME[] = UNICODE_LITERAL_13(L,o,g,o,u,t,R,e,q,u,e,s,t);
1697 const XMLCh LogoutRequest::TYPE_NAME[] = UNICODE_LITERAL_17(L,o,g,o,u,t,R,e,q,u,e,s,t,T,y,p,e);
1698 const XMLCh LogoutRequest::REASON_ATTRIB_NAME[] = UNICODE_LITERAL_6(R,e,a,s,o,n);
1699 const XMLCh LogoutRequest::NOTONORAFTER_ATTRIB_NAME[] = UNICODE_LITERAL_12(N,o,t,O,n,O,r,A,f,t,e,r);
1700 const XMLCh LogoutResponse::LOCAL_NAME[] = UNICODE_LITERAL_14(L,o,g,o,u,t,R,e,s,p,o,n,s,e);
1701 const XMLCh ManageNameIDRequest::LOCAL_NAME[] = UNICODE_LITERAL_19(M,a,n,a,g,e,N,a,m,e,I,D,R,e,q,u,e,s,t);
1702 const XMLCh ManageNameIDRequest::TYPE_NAME[] = UNICODE_LITERAL_23(M,a,n,a,g,e,N,a,m,e,I,D,R,e,q,u,e,s,t,T,y,p,e);
1703 const XMLCh ManageNameIDResponse::LOCAL_NAME[] = UNICODE_LITERAL_20(M,a,n,a,g,e,N,a,m,e,I,D,R,e,s,p,o,n,s,e);
1704 const XMLCh NameIDMappingRequest::LOCAL_NAME[] = UNICODE_LITERAL_20(N,a,m,e,I,D,M,a,p,p,i,n,g,R,e,q,u,e,s,t);
1705 const XMLCh NameIDMappingRequest::TYPE_NAME[] = UNICODE_LITERAL_24(N,a,m,e,I,D,M,a,p,p,i,n,g,R,e,q,u,e,s,t,T,y,p,e);
1706 const XMLCh NameIDMappingResponse::LOCAL_NAME[] = UNICODE_LITERAL_21(N,a,m,e,I,D,M,a,p,p,i,n,g,R,e,s,p,o,n,s,e);
1707 const XMLCh NameIDMappingResponse::TYPE_NAME[] = UNICODE_LITERAL_25(N,a,m,e,I,D,M,a,p,p,i,n,g,R,e,s,p,o,n,s,e,T,y,p,e);
1708 const XMLCh NameIDPolicy::LOCAL_NAME[] = UNICODE_LITERAL_12(N,a,m,e,I,D,P,o,l,i,c,y);
1709 const XMLCh NameIDPolicy::TYPE_NAME[] = UNICODE_LITERAL_16(N,a,m,e,I,D,P,o,l,i,c,y,T,y,p,e);
1710 const XMLCh NameIDPolicy::FORMAT_ATTRIB_NAME[] = UNICODE_LITERAL_6(F,o,r,m,a,t);
1711 const XMLCh NameIDPolicy::SPNAMEQUALIFIER_ATTRIB_NAME[] = UNICODE_LITERAL_15(S,P,N,a,m,e,Q,u,a,l,i,f,i,e,r);
1712 const XMLCh NameIDPolicy::ALLOWCREATE_ATTRIB_NAME[] = UNICODE_LITERAL_11(A,l,l,o,w,C,r,e,a,t,e);
1713 const XMLCh NewEncryptedID::LOCAL_NAME[] = UNICODE_LITERAL_14(N,e,w,E,n,c,r,y,p,t,e,d,I,D);
1714 const XMLCh NewID::LOCAL_NAME[] = UNICODE_LITERAL_5(N,e,w,I,D);
1715 const XMLCh RequesterID::LOCAL_NAME[] = UNICODE_LITERAL_11(R,e,q,u,e,s,t,e,r,I,D);
1716 const XMLCh RequestedAuthnContext::LOCAL_NAME[] = UNICODE_LITERAL_21(R,e,q,u,e,s,t,e,d,A,u,t,h,n,C,o,n,t,e,x,t);
1717 const XMLCh RequestedAuthnContext::TYPE_NAME[] = UNICODE_LITERAL_25(R,e,q,u,e,s,t,e,d,A,u,t,h,n,C,o,n,t,e,x,t,T,y,p,e);
1718 const XMLCh RequestedAuthnContext::COMPARISON_ATTRIB_NAME[] = UNICODE_LITERAL_10(C,o,m,p,a,r,i,s,o,n);
1719 const XMLCh RequestedAuthnContext::COMPARISON_EXACT[] = UNICODE_LITERAL_5(e,x,a,c,t);
1720 const XMLCh RequestedAuthnContext::COMPARISON_MINIMUM[] = UNICODE_LITERAL_7(m,i,n,i,m,u,m);
1721 const XMLCh RequestedAuthnContext::COMPARISON_MAXIMUM[] = UNICODE_LITERAL_7(m,a,x,i,m,u,m);
1722 const XMLCh RequestedAuthnContext::COMPARISON_BETTER[] = UNICODE_LITERAL_6(b,e,t,t,e,r);
1723 const XMLCh RequestAbstractType::LOCAL_NAME[] = {chNull};
1724 const XMLCh RequestAbstractType::TYPE_NAME[] = UNICODE_LITERAL_19(R,e,q,u,e,s,t,A,b,s,t,r,a,c,t,T,y,p,e);
1725 const XMLCh RequestAbstractType::ID_ATTRIB_NAME[] = UNICODE_LITERAL_2(I,D);
1726 const XMLCh RequestAbstractType::VER_ATTRIB_NAME[] = UNICODE_LITERAL_7(V,e,r,s,i,o,n);
1727 const XMLCh RequestAbstractType::ISSUEINSTANT_ATTRIB_NAME[] = UNICODE_LITERAL_12(I,s,s,u,e,I,n,s,t,a,n,t);
1728 const XMLCh RequestAbstractType::DESTINATION_ATTRIB_NAME[] = UNICODE_LITERAL_11(D,e,s,t,i,n,a,t,i,o,n);
1729 const XMLCh RequestAbstractType::CONSENT_ATTRIB_NAME[] = UNICODE_LITERAL_7(C,o,n,s,e,n,t);
1730 const XMLCh RespondTo::LOCAL_NAME[] = UNICODE_LITERAL_9(R,e,s,p,o,n,d,T,o);
1731 const XMLCh Response::LOCAL_NAME[] = UNICODE_LITERAL_8(R,e,s,p,o,n,s,e);
1732 const XMLCh Response::TYPE_NAME[] = UNICODE_LITERAL_12(R,e,s,p,o,n,s,e,T,y,p,e);
1733 const XMLCh Scoping::LOCAL_NAME[] = UNICODE_LITERAL_7(S,c,o,p,i,n,g);
1734 const XMLCh Scoping::TYPE_NAME[] = UNICODE_LITERAL_11(S,c,o,p,i,n,g,T,y,p,e);
1735 const XMLCh Scoping::PROXYCOUNT_ATTRIB_NAME[] = UNICODE_LITERAL_10(P,r,o,x,y,C,o,u,n,t);
1736 const XMLCh SessionIndex::LOCAL_NAME[] = UNICODE_LITERAL_12(S,e,s,s,i,o,n,I,n,d,e,x);
1737 const XMLCh Status::LOCAL_NAME[] = UNICODE_LITERAL_6(S,t,a,t,u,s);
1738 const XMLCh Status::TYPE_NAME[] = UNICODE_LITERAL_10(S,t,a,t,u,s,T,y,p,e);
1739 const XMLCh StatusCode::LOCAL_NAME[] = UNICODE_LITERAL_10(S,t,a,t,u,s,C,o,d,e);
1740 const XMLCh StatusCode::TYPE_NAME[] = UNICODE_LITERAL_14(S,t,a,t,u,s,C,o,d,e,T,y,p,e);
1741 const XMLCh StatusCode::VALUE_ATTRIB_NAME[] = UNICODE_LITERAL_5(V,a,l,u,e);
1742 const XMLCh StatusDetail::LOCAL_NAME[] = UNICODE_LITERAL_12(S,t,a,t,u,s,D,e,t,a,i,l);
1743 const XMLCh StatusDetail::TYPE_NAME[] = UNICODE_LITERAL_16(S,t,a,t,u,s,D,e,t,a,i,l,T,y,p,e);
1744 const XMLCh StatusMessage::LOCAL_NAME[] = UNICODE_LITERAL_13(S,t,a,t,u,s,M,e,s,s,a,g,e);
1745 const XMLCh StatusResponseType::LOCAL_NAME[] = {chNull};
1746 const XMLCh StatusResponseType::TYPE_NAME[] = UNICODE_LITERAL_18(S,t,a,t,u,s,R,e,s,p,o,n,s,e,T,y,p,e);
1747 const XMLCh StatusResponseType::ID_ATTRIB_NAME[] = UNICODE_LITERAL_2(I,D);
1748 const XMLCh StatusResponseType::INRESPONSETO_ATTRIB_NAME[] = UNICODE_LITERAL_12(I,n,R,e,s,p,o,n,s,e,T,o);
1749 const XMLCh StatusResponseType::VER_ATTRIB_NAME[] = UNICODE_LITERAL_7(V,e,r,s,i,o,n);
1750 const XMLCh StatusResponseType::ISSUEINSTANT_ATTRIB_NAME[] = UNICODE_LITERAL_12(I,s,s,u,e,I,n,s,t,a,n,t);
1751 const XMLCh StatusResponseType::DESTINATION_ATTRIB_NAME[] = UNICODE_LITERAL_11(D,e,s,t,i,n,a,t,i,o,n);
1752 const XMLCh StatusResponseType::CONSENT_ATTRIB_NAME[] = UNICODE_LITERAL_7(C,o,n,s,e,n,t);
1753 const XMLCh SubjectQuery::LOCAL_NAME[] = UNICODE_LITERAL_12(S,u,b,j,e,c,t,Q,u,e,r,y);
1754 const XMLCh SubjectQuery::TYPE_NAME[] = UNICODE_LITERAL_24(S,u,b,j,e,c,t,Q,u,e,r,y,A,b,s,t,r,a,c,t,T,y,p,e);
1755 const XMLCh Terminate::LOCAL_NAME[] = UNICODE_LITERAL_9(T,e,r,m,i,n,a,t,e);
1756 const XMLCh Terminate::TYPE_NAME[] = UNICODE_LITERAL_13(T,e,r,m,i,n,a,t,e,T,y,p,e);
1757
1758 // Unicode literals: LogoutRequest element, Reason attribute
1759 const XMLCh LogoutRequest::REASON_USER[] = // urn:oasis:names:tc:SAML:2.0:logout:user
1760 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1761   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1762   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1763   chLatin_l, chLatin_o, chLatin_g, chLatin_o, chLatin_u, chLatin_t, chColon,
1764   chLatin_u, chLatin_s, chLatin_e, chLatin_r, chNull
1765 };
1766
1767 const XMLCh LogoutRequest::REASON_ADMIN[] = // urn:oasis:names:tc:SAML:2.0:logout:admin
1768 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1769   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1770   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1771   chLatin_l, chLatin_o, chLatin_g, chLatin_o, chLatin_u, chLatin_t, chColon,
1772   chLatin_a, chLatin_d, chLatin_m, chLatin_i, chLatin_n, chNull
1773 };
1774
1775
1776 const XMLCh LogoutRequest::REASON_GLOBAL_TIMEOUT[] = // urn:oasis:names:tc:SAML:2.0:logout:global-timeout
1777 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1778   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1779   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1780   chLatin_l, chLatin_o, chLatin_g, chLatin_o, chLatin_u, chLatin_t, chColon,
1781   chLatin_g, chLatin_l, chLatin_o, chLatin_b, chLatin_a, chLatin_l,
1782     chDash, chLatin_t, chLatin_i, chLatin_m, chLatin_e, chLatin_o, chLatin_u, chLatin_t, chNull
1783 };
1784
1785
1786 const XMLCh LogoutRequest::REASON_SP_TIMEOUT[] = // urn:oasis:names:tc:SAML:2.0:logout:sp-timeout
1787 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1788   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1789   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1790   chLatin_l, chLatin_o, chLatin_g, chLatin_o, chLatin_u, chLatin_t, chColon,
1791   chLatin_s, chLatin_p, chDash, chLatin_t, chLatin_i, chLatin_m, chLatin_e, chLatin_o, chLatin_u, chLatin_t, chNull
1792 };
1793
1794
1795 // Unicode literals, StatusCode Value
1796 const XMLCh StatusCode::SUCCESS[] = //  urn:oasis:names:tc:SAML:2.0:status:Success
1797 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1798   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1799   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1800   chLatin_s, chLatin_t, chLatin_a, chLatin_t, chLatin_u, chLatin_s, chColon,
1801   chLatin_S, chLatin_u, chLatin_c, chLatin_c, chLatin_e, chLatin_s, chLatin_s, chNull
1802 };
1803
1804 const XMLCh StatusCode::REQUESTER[] = //  urn:oasis:names:tc:SAML:2.0:status:Requester
1805 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1806   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1807   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1808   chLatin_s, chLatin_t, chLatin_a, chLatin_t, chLatin_u, chLatin_s, chColon,
1809   chLatin_R, chLatin_e, chLatin_q, chLatin_u, chLatin_e, chLatin_s, chLatin_t, chLatin_e, chLatin_r, chNull
1810 };
1811
1812 const XMLCh StatusCode::RESPONDER[] = //  urn:oasis:names:tc:SAML:2.0:status:Responder
1813 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1814   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1815   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1816   chLatin_s, chLatin_t, chLatin_a, chLatin_t, chLatin_u, chLatin_s, chColon,
1817   chLatin_R, chLatin_e, chLatin_s, chLatin_p, chLatin_o, chLatin_n, chLatin_d, chLatin_e, chLatin_r, chNull
1818 };
1819
1820 const XMLCh StatusCode::VERSION_MISMATCH[] = //  urn:oasis:names:tc:SAML:2.0:status:VersionMismatch
1821 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1822   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1823   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1824   chLatin_s, chLatin_t, chLatin_a, chLatin_t, chLatin_u, chLatin_s, chColon,
1825   chLatin_V, chLatin_e, chLatin_r, chLatin_s, chLatin_i, chLatin_o, chLatin_n,
1826     chLatin_M, chLatin_i, chLatin_s, chLatin_m, chLatin_a, chLatin_t, chLatin_c, chLatin_h, chNull
1827 };
1828
1829 const XMLCh StatusCode::AUTHN_FAILED[] = //  urn:oasis:names:tc:SAML:2.0:status:AuthnFailed
1830 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1831   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1832   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1833   chLatin_s, chLatin_t, chLatin_a, chLatin_t, chLatin_u, chLatin_s, chColon,
1834   chLatin_A, chLatin_u, chLatin_t, chLatin_h, chLatin_n,
1835     chLatin_F, chLatin_a, chLatin_i, chLatin_l, chLatin_e, chLatin_d, chNull
1836 };
1837
1838 const XMLCh StatusCode::INVALID_ATTR_NAME_OR_VALUE[] = //  urn:oasis:names:tc:SAML:2.0:status:InvalidAttrNameOrValue
1839 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1840   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1841   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1842   chLatin_s, chLatin_t, chLatin_a, chLatin_t, chLatin_u, chLatin_s, chColon,
1843   chLatin_I, chLatin_n, chLatin_v, chLatin_a, chLatin_l, chLatin_i, chLatin_d,
1844     chLatin_A, chLatin_t, chLatin_t, chLatin_r, chLatin_N, chLatin_a, chLatin_m, chLatin_e,
1845     chLatin_O, chLatin_r, chLatin_V, chLatin_a, chLatin_l, chLatin_u, chLatin_e, chNull
1846 };
1847
1848 const XMLCh StatusCode::INVALID_NAMEID_POLICY[] = //  urn:oasis:names:tc:SAML:2.0:status:InvalidNameIDPolicy
1849 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1850   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1851   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1852   chLatin_s, chLatin_t, chLatin_a, chLatin_t, chLatin_u, chLatin_s, chColon,
1853   chLatin_I, chLatin_n, chLatin_v, chLatin_a, chLatin_l, chLatin_i, chLatin_d,
1854    chLatin_N, chLatin_a, chLatin_m, chLatin_e, chLatin_I, chLatin_D,
1855    chLatin_P, chLatin_o, chLatin_l, chLatin_i, chLatin_c, chLatin_y, chNull
1856 };
1857
1858 const XMLCh StatusCode::NO_AUTHN_CONTEXT[] = //  urn:oasis:names:tc:SAML:2.0:status:NoAuthnContext
1859 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1860   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1861   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1862   chLatin_s, chLatin_t, chLatin_a, chLatin_t, chLatin_u, chLatin_s, chColon,
1863   chLatin_N, chLatin_o, chLatin_A, chLatin_u, chLatin_t, chLatin_h, chLatin_n,
1864   chLatin_C, chLatin_o, chLatin_n, chLatin_t, chLatin_e, chLatin_x, chLatin_t, chNull
1865 };
1866
1867 const XMLCh StatusCode::NO_AVAILABLE_IDP[] = //  urn:oasis:names:tc:SAML:2.0:status:NoAvailableIDP
1868 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1869   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1870   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1871   chLatin_s, chLatin_t, chLatin_a, chLatin_t, chLatin_u, chLatin_s, chColon,
1872   chLatin_N, chLatin_o, chLatin_A, chLatin_v, chLatin_a, chLatin_i, chLatin_l, chLatin_a, chLatin_b, chLatin_l, chLatin_e,
1873    chLatin_I, chLatin_D, chLatin_P, chNull
1874 };
1875
1876 const XMLCh StatusCode::NO_PASSIVE[] = //  urn:oasis:names:tc:SAML:2.0:status:NoPassive
1877 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1878   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1879   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1880   chLatin_s, chLatin_t, chLatin_a, chLatin_t, chLatin_u, chLatin_s, chColon,
1881   chLatin_N, chLatin_o, chLatin_P, chLatin_a, chLatin_s, chLatin_s, chLatin_i, chLatin_v, chLatin_e, chNull
1882 };
1883
1884 const XMLCh StatusCode::NO_SUPPORTED_IDP[] = //  urn:oasis:names:tc:SAML:2.0:status:NoSupportedIDP
1885 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1886   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1887   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1888   chLatin_s, chLatin_t, chLatin_a, chLatin_t, chLatin_u, chLatin_s, chColon,
1889   chLatin_N, chLatin_o, chLatin_S, chLatin_u, chLatin_p, chLatin_p, chLatin_o, chLatin_r, chLatin_t, chLatin_e, chLatin_d,
1890       chLatin_I, chLatin_D, chLatin_P, chNull
1891 };
1892
1893 const XMLCh StatusCode::PARTIAL_LOGOUT[] = //  urn:oasis:names:tc:SAML:2.0:status:PartialLogout
1894 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1895   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1896   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1897   chLatin_s, chLatin_t, chLatin_a, chLatin_t, chLatin_u, chLatin_s, chColon,
1898   chLatin_P, chLatin_a, chLatin_r, chLatin_t, chLatin_i, chLatin_a, chLatin_l,
1899     chLatin_L, chLatin_o, chLatin_g, chLatin_o, chLatin_u, chLatin_t, chNull
1900 };
1901
1902 const XMLCh StatusCode::PROXY_COUNT_EXCEEDED[] = //  urn:oasis:names:tc:SAML:2.0:status:ProxyCountExceeded
1903 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1904   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1905   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1906   chLatin_s, chLatin_t, chLatin_a, chLatin_t, chLatin_u, chLatin_s, chColon,
1907   chLatin_P, chLatin_r, chLatin_o, chLatin_x, chLatin_y, chLatin_C, chLatin_o, chLatin_u, chLatin_n, chLatin_t,
1908     chLatin_E, chLatin_x, chLatin_c, chLatin_e, chLatin_e, chLatin_d, chLatin_e, chLatin_d, chNull
1909 };
1910
1911 const XMLCh StatusCode::REQUEST_DENIED[] = //  urn:oasis:names:tc:SAML:2.0:status:RequestDenied
1912 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1913   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1914   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1915   chLatin_s, chLatin_t, chLatin_a, chLatin_t, chLatin_u, chLatin_s, chColon,
1916   chLatin_R, chLatin_e, chLatin_q, chLatin_u, chLatin_e, chLatin_s, chLatin_t,
1917     chLatin_D, chLatin_e, chLatin_n, chLatin_i, chLatin_e, chLatin_d, chNull
1918 };
1919
1920 const XMLCh StatusCode::REQUEST_UNSUPPORTED[] = //  urn:oasis:names:tc:SAML:2.0:status:RequestUnsupported
1921 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1922   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1923   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1924   chLatin_s, chLatin_t, chLatin_a, chLatin_t, chLatin_u, chLatin_s, chColon,
1925   chLatin_R, chLatin_e, chLatin_q, chLatin_u, chLatin_e, chLatin_s, chLatin_t,
1926     chLatin_U, chLatin_n, chLatin_s, chLatin_u, chLatin_p, chLatin_p, chLatin_o, chLatin_r, chLatin_t, chLatin_e, chLatin_d, chNull
1927 };
1928
1929 const XMLCh StatusCode::REQUEST_VERSION_DEPRECATED[] = //  urn:oasis:names:tc:SAML:2.0:status:RequestVersionDeprecated
1930 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1931   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1932   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1933   chLatin_s, chLatin_t, chLatin_a, chLatin_t, chLatin_u, chLatin_s, chColon,
1934   chLatin_R, chLatin_e, chLatin_q, chLatin_u, chLatin_e, chLatin_s, chLatin_t,
1935     chLatin_V, chLatin_e, chLatin_r, chLatin_s, chLatin_i, chLatin_o, chLatin_n,
1936     chLatin_D, chLatin_e, chLatin_p, chLatin_r, chLatin_e, chLatin_c, chLatin_a, chLatin_t, chLatin_e, chLatin_d, chNull
1937 };
1938
1939 const XMLCh StatusCode::REQUEST_VERSION_TOO_HIGH[] = //  urn:oasis:names:tc:SAML:2.0:status:RequestVersionTooHigh
1940 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1941   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1942   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1943   chLatin_s, chLatin_t, chLatin_a, chLatin_t, chLatin_u, chLatin_s, chColon,
1944   chLatin_R, chLatin_e, chLatin_q, chLatin_u, chLatin_e, chLatin_s, chLatin_t,
1945   chLatin_V, chLatin_e, chLatin_r, chLatin_s, chLatin_i, chLatin_o, chLatin_n,
1946   chLatin_T, chLatin_o, chLatin_o, chLatin_H, chLatin_i, chLatin_g, chLatin_h, chNull
1947 };
1948
1949 const XMLCh StatusCode::REQUEST_VERSION_TOO_LOW[] = //  urn:oasis:names:tc:SAML:2.0:status:RequestVersionTooLow
1950 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1951   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1952   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1953   chLatin_s, chLatin_t, chLatin_a, chLatin_t, chLatin_u, chLatin_s, chColon,
1954   chLatin_R, chLatin_e, chLatin_q, chLatin_u, chLatin_e, chLatin_s, chLatin_t,
1955     chLatin_V, chLatin_e, chLatin_r, chLatin_s, chLatin_i, chLatin_o, chLatin_n,
1956     chLatin_T, chLatin_o, chLatin_o, chLatin_L, chLatin_o, chLatin_w, chNull
1957 };
1958
1959 const XMLCh StatusCode::RESOURCE_NOT_RECOGNIZED[] = //  urn:oasis:names:tc:SAML:2.0:status:ResourceNotRecognized
1960 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1961   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1962   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1963   chLatin_s, chLatin_t, chLatin_a, chLatin_t, chLatin_u, chLatin_s, chColon,
1964   chLatin_R, chLatin_e, chLatin_s, chLatin_o, chLatin_u, chLatin_r, chLatin_c, chLatin_e,
1965     chLatin_N, chLatin_o, chLatin_t,
1966     chLatin_R, chLatin_e, chLatin_c, chLatin_o, chLatin_g, chLatin_n, chLatin_i, chLatin_z, chLatin_e, chLatin_d, chNull
1967 };
1968
1969 const XMLCh StatusCode::TOO_MANY_RESPONSES[] = //  urn:oasis:names:tc:SAML:2.0:status:TooManyResponses
1970 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1971   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1972   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1973   chLatin_s, chLatin_t, chLatin_a, chLatin_t, chLatin_u, chLatin_s, chColon,
1974   chLatin_T, chLatin_o, chLatin_o, chLatin_M, chLatin_a, chLatin_n, chLatin_y,
1975     chLatin_R, chLatin_e, chLatin_s, chLatin_p, chLatin_o, chLatin_n, chLatin_s, chLatin_e, chLatin_s, chNull
1976 };
1977
1978 const XMLCh StatusCode::UNKNOWN_ATTR_PROFILE[] = //  urn:oasis:names:tc:SAML:2.0:status:UnknownAttrProfile
1979 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1980   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1981   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1982   chLatin_s, chLatin_t, chLatin_a, chLatin_t, chLatin_u, chLatin_s, chColon,
1983   chLatin_U, chLatin_n, chLatin_k, chLatin_n, chLatin_o, chLatin_w, chLatin_n,
1984     chLatin_A, chLatin_t, chLatin_t, chLatin_r,
1985     chLatin_P, chLatin_r, chLatin_o, chLatin_f, chLatin_i, chLatin_l, chLatin_e, chNull
1986 };
1987
1988 const XMLCh StatusCode::UNKNOWN_PRINCIPAL[] = //  urn:oasis:names:tc:SAML:2.0:status:UnknownPrincipal
1989 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1990   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1991   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1992   chLatin_s, chLatin_t, chLatin_a, chLatin_t, chLatin_u, chLatin_s, chColon,
1993   chLatin_U, chLatin_n, chLatin_k, chLatin_n, chLatin_o, chLatin_w, chLatin_n,
1994     chLatin_P, chLatin_r, chLatin_i, chLatin_n, chLatin_c, chLatin_i, chLatin_p, chLatin_a, chLatin_l, chNull
1995 };
1996
1997 const XMLCh StatusCode::UNSUPPORTED_BINDING[] = //  urn:oasis:names:tc:SAML:2.0:status:UnsupportedBinding
1998 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1999   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
2000   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
2001   chLatin_s, chLatin_t, chLatin_a, chLatin_t, chLatin_u, chLatin_s, chColon,
2002   chLatin_U, chLatin_n, chLatin_s, chLatin_u, chLatin_p, chLatin_p, chLatin_o, chLatin_r, chLatin_t, chLatin_e, chLatin_d,
2003     chLatin_B, chLatin_i, chLatin_n, chLatin_d, chLatin_i, chLatin_n, chLatin_g, chNull
2004 };
2005