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