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