saml/saml2/core/impl/Protocols20Impl.cpp

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