saml/saml2/core/impl/Assertions20Impl.cpp

   1 /**
   2  * Licensed to the University Corporation for Advanced Internet
   3  * Development, Inc. (UCAID) under one or more contributor license
   4  * agreements. See the NOTICE file distributed with this work for
   5  * additional information regarding copyright ownership.
   6  *
   7  * UCAID licenses this file to you under the Apache License,
   8  * Version 2.0 (the "License"); you may not use this file except
   9  * in compliance with the License. You may obtain a copy of the
  10  * License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  17  * either express or implied. See the License for the specific
  18  * language governing permissions and limitations under the License.
  19  */
  20
  21 /**
  22  * Assertions20Impl.cpp
  23  *
  24  * Implementation classes for SAML 2.0 Assertions schema.
  25  */
  26
  27 #include "internal.h"
  28 #include "exceptions.h"
  29 #include "saml/encryption/EncryptedKeyResolver.h"
  30 #include "saml2/core/Assertions.h"
  31 #include "signature/ContentReference.h"
  32
  33 #include <xmltooling/AbstractComplexElement.h>
  34 #include <xmltooling/AbstractSimpleElement.h>
  35 #include <xmltooling/impl/AnyElement.h>
  36 #include <xmltooling/io/AbstractXMLObjectMarshaller.h>
  37 #include <xmltooling/io/AbstractXMLObjectUnmarshaller.h>
  38 #include <xmltooling/signature/KeyInfo.h>
  39 #include <xmltooling/signature/Signature.h>
  40 #include <xmltooling/util/DateTime.h>
  41 #include <xmltooling/util/XMLHelper.h>
  42
  43 #include <ctime>
  44 #include <boost/lambda/bind.hpp>
  45 #include <boost/lambda/if.hpp>
  46 #include <boost/lambda/lambda.hpp>
  47 #include <xercesc/util/XMLUniDefs.hpp>
  48
  49 using namespace opensaml::saml2;
  50 using namespace xmltooling;
  51 using namespace std;
  52 using xmlconstants::XSI_NS;
  53 using xmlconstants::XMLSIG_NS;
  54 using xmlconstants::XMLENC_NS;
  55 using xmlconstants::XML_BOOL_NULL;
  56 using samlconstants::SAML20_NS;
  57 using samlconstants::SAML20_DELEGATION_CONDITION_NS;
  58
  59
  60 #if defined (_MSC_VER)
  61     #pragma warning( push )
  62     #pragma warning( disable : 4250 4251 )
  63 #endif
  64
  65 namespace opensaml {
  66     namespace saml2 {
  67
  68         DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,AssertionIDRef);
  69         DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,AssertionURIRef);
  70         DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,Audience);
  71         DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,AuthnContextClassRef);
  72         DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,AuthnContextDeclRef);
  73         DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,AuthenticatingAuthority);
  74
  75         class SAML_DLLLOCAL NameIDTypeImpl : public virtual NameIDType,
  76             public AbstractSimpleElement,
  77             public AbstractDOMCachingXMLObject,
  78             public AbstractXMLObjectMarshaller,
  79             public AbstractXMLObjectUnmarshaller
  80         {
  81             void init() {
  82                 m_Format=m_SPProvidedID=m_NameQualifier=m_SPNameQualifier=nullptr;
  83             }
  84
  85         protected:
  86             NameIDTypeImpl() {
  87                 init();
  88             }
  89
  90         public:
  91             virtual ~NameIDTypeImpl() {
  92                 XMLString::release(&m_NameQualifier);
  93                 XMLString::release(&m_SPNameQualifier);
  94                 XMLString::release(&m_Format);
  95                 XMLString::release(&m_SPProvidedID);
  96             }
  97
  98             NameIDTypeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
  99                     : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 100                 init();
 101             }
 102
 103             NameIDTypeImpl(const NameIDTypeImpl& src)
 104                     : AbstractXMLObject(src), AbstractSimpleElement(src), AbstractDOMCachingXMLObject(src) {
 105                 init();
 106             }
 107
 108             void _clone(const NameIDTypeImpl& src) {
 109                 IMPL_CLONE_ATTRIB(NameQualifier);
 110                 IMPL_CLONE_ATTRIB(SPNameQualifier);
 111                 IMPL_CLONE_ATTRIB(Format);
 112                 IMPL_CLONE_ATTRIB(SPProvidedID);
 113             }
 114
 115             IMPL_XMLOBJECT_CLONE_EX(NameIDType);
 116             IMPL_STRING_ATTRIB(NameQualifier);
 117             IMPL_STRING_ATTRIB(SPNameQualifier);
 118             IMPL_STRING_ATTRIB(Format);
 119             IMPL_STRING_ATTRIB(SPProvidedID);
 120
 121         protected:
 122             void marshallAttributes(DOMElement* domElement) const {
 123                 MARSHALL_STRING_ATTRIB(NameQualifier,NAMEQUALIFIER,nullptr);
 124                 MARSHALL_STRING_ATTRIB(SPNameQualifier,SPNAMEQUALIFIER,nullptr);
 125                 MARSHALL_STRING_ATTRIB(Format,FORMAT,nullptr);
 126                 MARSHALL_STRING_ATTRIB(SPProvidedID,SPPROVIDEDID,nullptr);
 127             }
 128
 129             void processAttribute(const DOMAttr* attribute) {
 130                 PROC_STRING_ATTRIB(NameQualifier,NAMEQUALIFIER,nullptr);
 131                 PROC_STRING_ATTRIB(SPNameQualifier,SPNAMEQUALIFIER,nullptr);
 132                 PROC_STRING_ATTRIB(Format,FORMAT,nullptr);
 133                 PROC_STRING_ATTRIB(SPProvidedID,SPPROVIDEDID,nullptr);
 134                 AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 135             }
 136         };
 137
 138         class SAML_DLLLOCAL NameIDImpl : public virtual NameID, public NameIDTypeImpl
 139         {
 140         public:
 141             virtual ~NameIDImpl() {}
 142
 143             NameIDImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 144                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
 145
 146             NameIDImpl(const NameIDImpl& src) : AbstractXMLObject(src), NameIDTypeImpl(src) {}
 147
 148             IMPL_XMLOBJECT_CLONE_EX(NameID);
 149         };
 150
 151         class SAML_DLLLOCAL IssuerImpl : public virtual Issuer, public NameIDTypeImpl
 152         {
 153         public:
 154             virtual ~IssuerImpl() {}
 155
 156             IssuerImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 157                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
 158
 159             IssuerImpl(const IssuerImpl& src) : AbstractXMLObject(src), NameIDTypeImpl(src) {}
 160
 161             IMPL_XMLOBJECT_CLONE_EX(Issuer);
 162         };
 163
 164         class SAML_DLLLOCAL EncryptedElementTypeImpl : public virtual EncryptedElementType,
 165             public AbstractComplexElement,
 166             public AbstractDOMCachingXMLObject,
 167             public AbstractXMLObjectMarshaller,
 168             public AbstractXMLObjectUnmarshaller
 169         {
 170             void init() {
 171                 m_EncryptedData=nullptr;
 172                 m_children.push_back(nullptr);
 173                 m_pos_EncryptedData=m_children.begin();
 174             }
 175
 176         protected:
 177             EncryptedElementTypeImpl() {
 178                 init();
 179             }
 180
 181         public:
 182             virtual ~EncryptedElementTypeImpl() {}
 183
 184             EncryptedElementTypeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 185                     : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 186                 init();
 187             }
 188
 189             EncryptedElementTypeImpl(const EncryptedElementTypeImpl& src)
 190                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 191                 init();
 192             }
 193
 194             void _clone(const EncryptedElementTypeImpl& src) {
 195                 IMPL_CLONE_TYPED_CHILD(EncryptedData);
 196                 IMPL_CLONE_TYPED_FOREIGN_CHILDREN(EncryptedKey,xmlencryption);
 197             }
 198
 199             IMPL_XMLOBJECT_CLONE_EX(EncryptedElementType);
 200             IMPL_TYPED_FOREIGN_CHILD(EncryptedData,xmlencryption);
 201             IMPL_TYPED_FOREIGN_CHILDREN(EncryptedKey,xmlencryption,m_children.end());
 202
 203         protected:
 204             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 205                 PROC_TYPED_FOREIGN_CHILD(EncryptedData,xmlencryption,XMLENC_NS,false);
 206                 PROC_TYPED_FOREIGN_CHILDREN(EncryptedKey,xmlencryption,XMLENC_NS,false);
 207                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 208             }
 209         };
 210
 211         class SAML_DLLLOCAL EncryptedIDImpl : public virtual EncryptedID, public EncryptedElementTypeImpl
 212         {
 213         public:
 214             virtual ~EncryptedIDImpl() {}
 215
 216             EncryptedIDImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 217                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
 218
 219             EncryptedIDImpl(const EncryptedIDImpl& src) : AbstractXMLObject(src), EncryptedElementTypeImpl(src) {}
 220
 221             IMPL_XMLOBJECT_CLONE_EX(EncryptedID);
 222         };
 223
 224         class SAML_DLLLOCAL ConditionImpl : public virtual Condition, public AnyElementImpl
 225         {
 226         public:
 227             virtual ~ConditionImpl() {}
 228
 229             ConditionImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 230                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
 231
 232             ConditionImpl(const ConditionImpl& src) : AbstractXMLObject(src), AnyElementImpl(src) {}
 233
 234             IMPL_XMLOBJECT_CLONE(Condition);
 235         };
 236
 237         class SAML_DLLLOCAL AudienceRestrictionImpl : public virtual AudienceRestriction,
 238             public AbstractComplexElement,
 239             public AbstractDOMCachingXMLObject,
 240             public AbstractXMLObjectMarshaller,
 241             public AbstractXMLObjectUnmarshaller
 242         {
 243         public:
 244             virtual ~AudienceRestrictionImpl() {}
 245
 246             AudienceRestrictionImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 247                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
 248
 249             AudienceRestrictionImpl(const AudienceRestrictionImpl& src)
 250                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 251                 IMPL_CLONE_TYPED_CHILDREN(Audience);
 252             }
 253
 254             IMPL_XMLOBJECT_CLONE2(AudienceRestriction,Condition);
 255             IMPL_TYPED_CHILDREN(Audience,m_children.end());
 256
 257         protected:
 258             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 259                 PROC_TYPED_CHILDREN(Audience,SAML20_NS,false);
 260                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 261             }
 262         };
 263
 264         class SAML_DLLLOCAL OneTimeUseImpl : public virtual OneTimeUse,
 265             public AbstractSimpleElement,
 266             public AbstractDOMCachingXMLObject,
 267             public AbstractXMLObjectMarshaller,
 268             public AbstractXMLObjectUnmarshaller
 269         {
 270         public:
 271             virtual ~OneTimeUseImpl() {}
 272
 273             OneTimeUseImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 274                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
 275
 276             OneTimeUseImpl(const OneTimeUseImpl& src)
 277                 : AbstractXMLObject(src), AbstractSimpleElement(src), AbstractDOMCachingXMLObject(src) {}
 278
 279             IMPL_XMLOBJECT_CLONE2(OneTimeUse,Condition);
 280         };
 281
 282         class SAML_DLLLOCAL ProxyRestrictionImpl : public virtual ProxyRestriction,
 283             public AbstractComplexElement,
 284             public AbstractDOMCachingXMLObject,
 285             public AbstractXMLObjectMarshaller,
 286             public AbstractXMLObjectUnmarshaller
 287         {
 288         public:
 289             virtual ~ProxyRestrictionImpl() {
 290                 XMLString::release(&m_Count);
 291             }
 292
 293             ProxyRestrictionImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 294                 : AbstractXMLObject(nsURI, localName, prefix, schemaType), m_Count(nullptr) {}
 295
 296             ProxyRestrictionImpl(const ProxyRestrictionImpl& src)
 297                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src), m_Count(nullptr) {
 298                 IMPL_CLONE_INTEGER_ATTRIB(Count);
 299                 IMPL_CLONE_TYPED_CHILDREN(Audience);
 300             }
 301
 302             IMPL_XMLOBJECT_CLONE2(ProxyRestriction,Condition);
 303             IMPL_TYPED_CHILDREN(Audience,m_children.end());
 304             IMPL_INTEGER_ATTRIB(Count);
 305
 306         protected:
 307             void marshallAttributes(DOMElement* domElement) const {
 308                 MARSHALL_INTEGER_ATTRIB(Count,COUNT,nullptr);
 309             }
 310
 311             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 312                 PROC_TYPED_CHILDREN(Audience,SAML20_NS,false);
 313                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 314             }
 315
 316             void processAttribute(const DOMAttr* attribute) {
 317                 PROC_INTEGER_ATTRIB(Count,COUNT,nullptr);
 318                 AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 319             }
 320         };
 321
 322         class SAML_DLLLOCAL DelegateImpl : public virtual Delegate,
 323             public AbstractComplexElement,
 324             public AbstractDOMCachingXMLObject,
 325             public AbstractXMLObjectMarshaller,
 326             public AbstractXMLObjectUnmarshaller
 327         {
 328             void init() {
 329                 m_ConfirmationMethod=nullptr;
 330                 m_DelegationInstant=nullptr;
 331                 m_BaseID=nullptr;
 332                 m_NameID=nullptr;
 333                 m_EncryptedID=nullptr;
 334                 m_children.push_back(nullptr);
 335                 m_children.push_back(nullptr);
 336                 m_children.push_back(nullptr);
 337                 m_pos_BaseID=m_children.begin();
 338                 m_pos_NameID=m_pos_BaseID;
 339                 ++m_pos_NameID;
 340                 m_pos_EncryptedID=m_pos_NameID;
 341                 ++m_pos_EncryptedID;
 342             }
 343
 344         public:
 345             virtual ~DelegateImpl() {
 346                 XMLString::release(&m_ConfirmationMethod);
 347                 delete m_DelegationInstant;
 348             }
 349
 350             DelegateImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 351                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 352                 init();
 353             }
 354
 355             DelegateImpl(const DelegateImpl& src)
 356                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 357                 init();
 358                 IMPL_CLONE_ATTRIB(ConfirmationMethod);
 359                 IMPL_CLONE_ATTRIB(DelegationInstant);
 360                 IMPL_CLONE_TYPED_CHILD(BaseID);
 361                 IMPL_CLONE_TYPED_CHILD(NameID);
 362                 IMPL_CLONE_TYPED_CHILD(EncryptedID);
 363             }
 364
 365             IMPL_XMLOBJECT_CLONE(Delegate);
 366             IMPL_STRING_ATTRIB(ConfirmationMethod);
 367             IMPL_DATETIME_ATTRIB(DelegationInstant,0);
 368             IMPL_TYPED_CHILD(NameID);
 369             IMPL_TYPED_CHILD(BaseID);
 370             IMPL_TYPED_CHILD(EncryptedID);
 371
 372         protected:
 373             void marshallAttributes(DOMElement* domElement) const {
 374                 MARSHALL_STRING_ATTRIB(ConfirmationMethod,CONFIRMATIONMETHOD,nullptr);
 375                 MARSHALL_DATETIME_ATTRIB(DelegationInstant,DELEGATIONINSTANT,nullptr);
 376             }
 377
 378             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 379                 PROC_TYPED_CHILD(BaseID,SAML20_NS,false);
 380                 PROC_TYPED_CHILD(NameID,SAML20_NS,false);
 381                 PROC_TYPED_CHILD(EncryptedID,SAML20_NS,false);
 382                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 383             }
 384
 385             void processAttribute(const DOMAttr* attribute) {
 386                 PROC_STRING_ATTRIB(ConfirmationMethod,CONFIRMATIONMETHOD,nullptr);
 387                 PROC_DATETIME_ATTRIB(DelegationInstant,DELEGATIONINSTANT,nullptr);
 388                 AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 389             }
 390         };
 391
 392         class SAML_DLLLOCAL DelegationRestrictionTypeImpl : public virtual DelegationRestrictionType,
 393             public AbstractComplexElement,
 394             public AbstractDOMCachingXMLObject,
 395             public AbstractXMLObjectMarshaller,
 396             public AbstractXMLObjectUnmarshaller
 397         {
 398         public:
 399             virtual ~DelegationRestrictionTypeImpl() {}
 400
 401             DelegationRestrictionTypeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 402                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
 403
 404             DelegationRestrictionTypeImpl(const DelegationRestrictionTypeImpl& src)
 405                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 406                 IMPL_CLONE_TYPED_CHILDREN(Delegate);
 407             }
 408
 409             IMPL_XMLOBJECT_CLONE2(DelegationRestrictionType,Condition);
 410             IMPL_TYPED_CHILDREN(Delegate,m_children.end());
 411
 412         protected:
 413             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 414                 PROC_TYPED_CHILDREN(Delegate,SAML20_DELEGATION_CONDITION_NS,false);
 415                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 416             }
 417         };
 418
 419         class SAML_DLLLOCAL ConditionsImpl : public virtual Conditions,
 420             public AbstractComplexElement,
 421             public AbstractDOMCachingXMLObject,
 422             public AbstractXMLObjectMarshaller,
 423             public AbstractXMLObjectUnmarshaller
 424         {
 425             void init() {
 426                 m_NotBefore=m_NotOnOrAfter=nullptr;
 427             }
 428
 429         public:
 430             virtual ~ConditionsImpl() {
 431                 delete m_NotBefore;
 432                 delete m_NotOnOrAfter;
 433             }
 434
 435             ConditionsImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 436                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 437                 init();
 438             }
 439
 440             ConditionsImpl(const ConditionsImpl& src)
 441                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 442                 init();
 443                 IMPL_CLONE_ATTRIB(NotBefore);
 444                 IMPL_CLONE_ATTRIB(NotOnOrAfter);
 445
 446                 IMPL_CLONE_CHILDBAG_BEGIN;
 447                     IMPL_CLONE_TYPED_CHILD_IN_BAG(AudienceRestriction);
 448                     IMPL_CLONE_TYPED_CHILD_IN_BAG(OneTimeUse);
 449                     IMPL_CLONE_TYPED_CHILD_IN_BAG(ProxyRestriction);
 450                     IMPL_CLONE_TYPED_CHILD_IN_BAG(Condition);
 451                 IMPL_CLONE_CHILDBAG_END;
 452             }
 453
 454             IMPL_XMLOBJECT_CLONE(Conditions);
 455             IMPL_DATETIME_ATTRIB(NotBefore,0);
 456             IMPL_DATETIME_ATTRIB(NotOnOrAfter,SAMLTIME_MAX);
 457             IMPL_TYPED_CHILDREN(AudienceRestriction, m_children.end());
 458             IMPL_TYPED_CHILDREN(OneTimeUse,m_children.end());
 459             IMPL_TYPED_CHILDREN(ProxyRestriction, m_children.end());
 460             IMPL_TYPED_CHILDREN(Condition,m_children.end());
 461
 462         protected:
 463             void marshallAttributes(DOMElement* domElement) const {
 464                 MARSHALL_DATETIME_ATTRIB(NotBefore,NOTBEFORE,nullptr);
 465                 MARSHALL_DATETIME_ATTRIB(NotOnOrAfter,NOTONORAFTER,nullptr);
 466             }
 467
 468             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 469                 PROC_TYPED_CHILDREN(AudienceRestriction,SAML20_NS,false);
 470                 PROC_TYPED_CHILDREN(OneTimeUse,SAML20_NS,false);
 471                 PROC_TYPED_CHILDREN(ProxyRestriction,SAML20_NS,false);
 472                 PROC_TYPED_CHILDREN(Condition,SAML20_NS,false);
 473                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 474             }
 475
 476             void processAttribute(const DOMAttr* attribute) {
 477                 PROC_DATETIME_ATTRIB(NotBefore,NOTBEFORE,nullptr);
 478                 PROC_DATETIME_ATTRIB(NotOnOrAfter,NOTONORAFTER,nullptr);
 479                 AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 480             }
 481         };
 482
 483         class SAML_DLLLOCAL SubjectConfirmationDataTypeImpl : public virtual SubjectConfirmationDataType, public virtual AbstractXMLObject
 484         {
 485             void init() {
 486                 m_NotBefore=m_NotOnOrAfter=nullptr;
 487                 m_Recipient=m_InResponseTo=m_Address=nullptr;
 488             }
 489
 490         protected:
 491             SubjectConfirmationDataTypeImpl() {
 492                 init();
 493             }
 494
 495         public:
 496             virtual ~SubjectConfirmationDataTypeImpl() {
 497                 delete m_NotBefore;
 498                 delete m_NotOnOrAfter;
 499                 XMLString::release(&m_Recipient);
 500                 XMLString::release(&m_InResponseTo);
 501                 XMLString::release(&m_Address);
 502             }
 503
 504             SubjectConfirmationDataTypeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 505                     : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 506                 init();
 507             }
 508
 509             SubjectConfirmationDataTypeImpl(const SubjectConfirmationDataTypeImpl& src) : AbstractXMLObject(src) {
 510                 init();
 511             }
 512
 513             void _clone(const SubjectConfirmationDataTypeImpl& src) {
 514                 IMPL_CLONE_ATTRIB(NotBefore);
 515                 IMPL_CLONE_ATTRIB(NotOnOrAfter);
 516                 IMPL_CLONE_ATTRIB(Recipient);
 517                 IMPL_CLONE_ATTRIB(InResponseTo);
 518                 IMPL_CLONE_ATTRIB(Address);
 519             }
 520
 521             SubjectConfirmationDataType* cloneSubjectConfirmationDataType() const {
 522                 return dynamic_cast<SubjectConfirmationDataType*>(clone());
 523             }
 524
 525             IMPL_DATETIME_ATTRIB(NotBefore,0);
 526             IMPL_DATETIME_ATTRIB(NotOnOrAfter,SAMLTIME_MAX);
 527             IMPL_STRING_ATTRIB(Recipient);
 528             IMPL_STRING_ATTRIB(InResponseTo);
 529             IMPL_STRING_ATTRIB(Address);
 530
 531         protected:
 532             void marshallAttributes(DOMElement* domElement) const {
 533                 MARSHALL_DATETIME_ATTRIB(NotBefore,NOTBEFORE,nullptr);
 534                 MARSHALL_DATETIME_ATTRIB(NotOnOrAfter,NOTONORAFTER,nullptr);
 535                 MARSHALL_STRING_ATTRIB(Recipient,RECIPIENT,nullptr);
 536                 MARSHALL_STRING_ATTRIB(InResponseTo,INRESPONSETO,nullptr);
 537                 MARSHALL_STRING_ATTRIB(Address,ADDRESS,nullptr);
 538             }
 539
 540             void processAttribute(const DOMAttr* attribute) {
 541                 PROC_DATETIME_ATTRIB(NotBefore,NOTBEFORE,nullptr);
 542                 PROC_DATETIME_ATTRIB(NotOnOrAfter,NOTONORAFTER,nullptr);
 543                 PROC_STRING_ATTRIB(Recipient,RECIPIENT,nullptr);
 544                 PROC_STRING_ATTRIB(InResponseTo,INRESPONSETO,nullptr);
 545                 PROC_STRING_ATTRIB(Address,ADDRESS,nullptr);
 546             }
 547         };
 548
 549         class SAML_DLLLOCAL SubjectConfirmationDataImpl : public SubjectConfirmationData,
 550             public SubjectConfirmationDataTypeImpl, public AnyElementImpl
 551         {
 552         public:
 553             virtual ~SubjectConfirmationDataImpl() {}
 554
 555             SubjectConfirmationDataImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 556                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
 557
 558             SubjectConfirmationDataImpl(const SubjectConfirmationDataImpl& src)
 559                 : AbstractXMLObject(src), SubjectConfirmationDataTypeImpl(src), AnyElementImpl(src) {}
 560
 561             void _clone(const SubjectConfirmationDataImpl& src) {
 562                 SubjectConfirmationDataTypeImpl::_clone(src);
 563                 AnyElementImpl::_clone(src);
 564             }
 565
 566             IMPL_XMLOBJECT_CLONE_EX(SubjectConfirmationData);
 567
 568             void setAttribute(const xmltooling::QName& qualifiedName, const XMLCh* value, bool ID=false) {
 569                 if (!qualifiedName.hasNamespaceURI()) {
 570                     if (XMLString::equals(qualifiedName.getLocalPart(),NOTBEFORE_ATTRIB_NAME)) {
 571                         setNotBefore(value);
 572                         return;
 573                     }
 574                     else if (XMLString::equals(qualifiedName.getLocalPart(),NOTONORAFTER_ATTRIB_NAME)) {
 575                         setNotOnOrAfter(value);
 576                         return;
 577                     }
 578                     else if (XMLString::equals(qualifiedName.getLocalPart(),RECIPIENT_ATTRIB_NAME)) {
 579                         setRecipient(value);
 580                         return;
 581                     }
 582                     else if (XMLString::equals(qualifiedName.getLocalPart(),INRESPONSETO_ATTRIB_NAME)) {
 583                         setInResponseTo(value);
 584                         return;
 585                     }
 586                     else if (XMLString::equals(qualifiedName.getLocalPart(),ADDRESS_ATTRIB_NAME)) {
 587                         setAddress(value);
 588                         return;
 589                     }
 590                 }
 591                 AbstractAttributeExtensibleXMLObject::setAttribute(qualifiedName, value, ID);
 592             }
 593
 594         protected:
 595             void marshallAttributes(DOMElement* domElement) const {
 596                 SubjectConfirmationDataTypeImpl::marshallAttributes(domElement);
 597                 AnyElementImpl::marshallAttributes(domElement);
 598             }
 599
 600             void processAttribute(const DOMAttr* attribute) {
 601                 PROC_DATETIME_ATTRIB(NotBefore,NOTBEFORE,nullptr);
 602                 PROC_DATETIME_ATTRIB(NotOnOrAfter,NOTONORAFTER,nullptr);
 603                 PROC_STRING_ATTRIB(Recipient,RECIPIENT,nullptr);
 604                 PROC_STRING_ATTRIB(InResponseTo,INRESPONSETO,nullptr);
 605                 PROC_STRING_ATTRIB(Address,ADDRESS,nullptr);
 606                 AnyElementImpl::processAttribute(attribute);
 607             }
 608         };
 609
 610         class SAML_DLLLOCAL KeyInfoConfirmationDataTypeImpl : public virtual KeyInfoConfirmationDataType,
 611                 public SubjectConfirmationDataTypeImpl,
 612                 public AbstractComplexElement,
 613                 public AbstractAttributeExtensibleXMLObject,
 614                 public AbstractDOMCachingXMLObject,
 615                 public AbstractXMLObjectMarshaller,
 616                 public AbstractXMLObjectUnmarshaller
 617         {
 618         public:
 619             virtual ~KeyInfoConfirmationDataTypeImpl() {}
 620
 621             KeyInfoConfirmationDataTypeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 622                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
 623
 624             KeyInfoConfirmationDataTypeImpl(const KeyInfoConfirmationDataTypeImpl& src)
 625                 : AbstractXMLObject(src), SubjectConfirmationDataTypeImpl(src), AbstractComplexElement(src),
 626                     AbstractAttributeExtensibleXMLObject(src), AbstractDOMCachingXMLObject(src) {}
 627
 628             void _clone(const KeyInfoConfirmationDataTypeImpl& src) {
 629                 SubjectConfirmationDataTypeImpl::_clone(src);
 630                 IMPL_CLONE_TYPED_FOREIGN_CHILDREN(KeyInfo,xmlsignature);
 631             }
 632
 633             IMPL_XMLOBJECT_CLONE_EX(KeyInfoConfirmationDataType);
 634             IMPL_TYPED_FOREIGN_CHILDREN(KeyInfo,xmlsignature,m_children.end());
 635
 636         public:
 637             void setAttribute(const xmltooling::QName& qualifiedName, const XMLCh* value, bool ID=false) {
 638                 if (!qualifiedName.hasNamespaceURI()) {
 639                     if (XMLString::equals(qualifiedName.getLocalPart(),NOTBEFORE_ATTRIB_NAME)) {
 640                         setNotBefore(value);
 641                         return;
 642                     }
 643                     else if (XMLString::equals(qualifiedName.getLocalPart(),NOTONORAFTER_ATTRIB_NAME)) {
 644                         setNotOnOrAfter(value);
 645                         return;
 646                     }
 647                     else if (XMLString::equals(qualifiedName.getLocalPart(),RECIPIENT_ATTRIB_NAME)) {
 648                         setRecipient(value);
 649                         return;
 650                     }
 651                     else if (XMLString::equals(qualifiedName.getLocalPart(),INRESPONSETO_ATTRIB_NAME)) {
 652                         setInResponseTo(value);
 653                         return;
 654                     }
 655                     else if (XMLString::equals(qualifiedName.getLocalPart(),ADDRESS_ATTRIB_NAME)) {
 656                         setAddress(value);
 657                         return;
 658                     }
 659                 }
 660                 AbstractAttributeExtensibleXMLObject::setAttribute(qualifiedName, value, ID);
 661             }
 662
 663         protected:
 664             void marshallAttributes(DOMElement* domElement) const {
 665                 SubjectConfirmationDataTypeImpl::marshallAttributes(domElement);
 666                 marshallExtensionAttributes(domElement);
 667             }
 668
 669             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 670                 PROC_TYPED_FOREIGN_CHILDREN(KeyInfo,xmlsignature,XMLSIG_NS,false);
 671                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 672             }
 673
 674             void processAttribute(const DOMAttr* attribute) {
 675                 unmarshallExtensionAttribute(attribute);
 676             }
 677         };
 678
 679         class SAML_DLLLOCAL SubjectConfirmationImpl : public virtual SubjectConfirmation,
 680             public AbstractComplexElement,
 681             public AbstractDOMCachingXMLObject,
 682             public AbstractXMLObjectMarshaller,
 683             public AbstractXMLObjectUnmarshaller
 684         {
 685             void init() {
 686                 m_Method=nullptr;
 687                 m_BaseID=nullptr;
 688                 m_NameID=nullptr;
 689                 m_EncryptedID=nullptr;
 690                 m_SubjectConfirmationData=nullptr;
 691                 m_children.push_back(nullptr);
 692                 m_children.push_back(nullptr);
 693                 m_children.push_back(nullptr);
 694                 m_children.push_back(nullptr);
 695                 m_pos_BaseID=m_children.begin();
 696                 m_pos_NameID=m_pos_BaseID;
 697                 ++m_pos_NameID;
 698                 m_pos_EncryptedID=m_pos_NameID;
 699                 ++m_pos_EncryptedID;
 700                 m_pos_SubjectConfirmationData=m_pos_EncryptedID;
 701                 ++m_pos_SubjectConfirmationData;
 702             }
 703
 704         public:
 705             virtual ~SubjectConfirmationImpl() {
 706                 XMLString::release(&m_Method);
 707             }
 708
 709             SubjectConfirmationImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 710                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 711                 init();
 712             }
 713
 714             SubjectConfirmationImpl(const SubjectConfirmationImpl& src)
 715                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 716                 init();
 717                 IMPL_CLONE_ATTRIB(Method);
 718                 IMPL_CLONE_TYPED_CHILD(BaseID);
 719                 IMPL_CLONE_TYPED_CHILD(NameID);
 720                 IMPL_CLONE_TYPED_CHILD(EncryptedID);
 721                 IMPL_CLONE_XMLOBJECT_CHILD(SubjectConfirmationData);
 722             }
 723
 724             IMPL_XMLOBJECT_CLONE(SubjectConfirmation);
 725             IMPL_STRING_ATTRIB(Method);
 726             IMPL_TYPED_CHILD(BaseID);
 727             IMPL_TYPED_CHILD(NameID);
 728             IMPL_TYPED_CHILD(EncryptedID);
 729             IMPL_XMLOBJECT_CHILD(SubjectConfirmationData);
 730
 731         protected:
 732             void marshallAttributes(DOMElement* domElement) const {
 733                 MARSHALL_STRING_ATTRIB(Method,METHOD,nullptr);
 734             }
 735
 736             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 737                 PROC_TYPED_CHILD(BaseID,SAML20_NS,false);
 738                 PROC_TYPED_CHILD(NameID,SAML20_NS,false);
 739                 PROC_TYPED_CHILD(EncryptedID,SAML20_NS,false);
 740                 PROC_XMLOBJECT_CHILD(SubjectConfirmationData,SAML20_NS);
 741                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 742             }
 743
 744             void processAttribute(const DOMAttr* attribute) {
 745                 PROC_STRING_ATTRIB(Method,METHOD,nullptr);
 746                 AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 747             }
 748         };
 749
 750         class SAML_DLLLOCAL SubjectImpl : public virtual Subject,
 751             public AbstractComplexElement,
 752             public AbstractDOMCachingXMLObject,
 753             public AbstractXMLObjectMarshaller,
 754             public AbstractXMLObjectUnmarshaller
 755         {
 756             void init() {
 757                 m_BaseID=nullptr;
 758                 m_NameID=nullptr;
 759                 m_EncryptedID=nullptr;
 760                 m_children.push_back(nullptr);
 761                 m_children.push_back(nullptr);
 762                 m_children.push_back(nullptr);
 763                 m_pos_BaseID=m_children.begin();
 764                 m_pos_NameID=m_pos_BaseID;
 765                 ++m_pos_NameID;
 766                 m_pos_EncryptedID=m_pos_NameID;
 767                 ++m_pos_EncryptedID;
 768             }
 769
 770         public:
 771             virtual ~SubjectImpl() {}
 772
 773             SubjectImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 774                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 775                 init();
 776             }
 777
 778             SubjectImpl(const SubjectImpl& src)
 779                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 780                 init();
 781                 IMPL_CLONE_TYPED_CHILD(BaseID);
 782                 IMPL_CLONE_TYPED_CHILD(NameID);
 783                 IMPL_CLONE_TYPED_CHILD(EncryptedID);
 784                 IMPL_CLONE_TYPED_CHILDREN(SubjectConfirmation);
 785             }
 786
 787             IMPL_XMLOBJECT_CLONE(Subject);
 788             IMPL_TYPED_CHILD(NameID);
 789             IMPL_TYPED_CHILD(BaseID);
 790             IMPL_TYPED_CHILD(EncryptedID);
 791             IMPL_TYPED_CHILDREN(SubjectConfirmation,m_children.end());
 792
 793         protected:
 794             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 795                 PROC_TYPED_CHILD(BaseID,SAML20_NS,false);
 796                 PROC_TYPED_CHILD(NameID,SAML20_NS,false);
 797                 PROC_TYPED_CHILD(EncryptedID,SAML20_NS,false);
 798                 PROC_TYPED_CHILDREN(SubjectConfirmation,SAML20_NS,false);
 799                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 800             }
 801         };
 802
 803         class SAML_DLLLOCAL SubjectLocalityImpl : public virtual SubjectLocality,
 804             public AbstractSimpleElement,
 805             public AbstractDOMCachingXMLObject,
 806             public AbstractXMLObjectMarshaller,
 807             public AbstractXMLObjectUnmarshaller
 808         {
 809             void init() {
 810                 m_Address=m_DNSName=nullptr;
 811             }
 812
 813         public:
 814             virtual ~SubjectLocalityImpl() {
 815                 XMLString::release(&m_Address);
 816                 XMLString::release(&m_DNSName);
 817             }
 818
 819             SubjectLocalityImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 820                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 821                 init();
 822             }
 823
 824             SubjectLocalityImpl(const SubjectLocalityImpl& src)
 825                     : AbstractXMLObject(src), AbstractSimpleElement(src), AbstractDOMCachingXMLObject(src) {
 826                 init();
 827                 IMPL_CLONE_ATTRIB(Address);
 828                 IMPL_CLONE_ATTRIB(DNSName);
 829             }
 830
 831             IMPL_XMLOBJECT_CLONE(SubjectLocality);
 832             IMPL_STRING_ATTRIB(Address);
 833             IMPL_STRING_ATTRIB(DNSName);
 834
 835         protected:
 836             void marshallAttributes(DOMElement* domElement) const {
 837                 MARSHALL_STRING_ATTRIB(Address,ADDRESS,nullptr);
 838                 MARSHALL_STRING_ATTRIB(DNSName,DNSNAME,nullptr);
 839             }
 840
 841             void processAttribute(const DOMAttr* attribute) {
 842                 PROC_STRING_ATTRIB(Address,ADDRESS,nullptr);
 843                 PROC_STRING_ATTRIB(DNSName,DNSNAME,nullptr);
 844                 AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 845             }
 846         };
 847
 848         class SAML_DLLLOCAL StatementImpl : public virtual Statement, public AnyElementImpl
 849         {
 850         public:
 851             virtual ~StatementImpl() {}
 852
 853             StatementImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 854                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
 855
 856             StatementImpl(const StatementImpl& src) : AbstractXMLObject(src), AnyElementImpl(src) {}
 857
 858             IMPL_XMLOBJECT_CLONE_EX(Statement);
 859         };
 860
 861         //TODO need unit test for this
 862         class SAML_DLLLOCAL AuthnContextDeclImpl : public virtual AuthnContextDecl, public AnyElementImpl
 863         {
 864         public:
 865             virtual ~AuthnContextDeclImpl() {}
 866
 867             AuthnContextDeclImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 868                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
 869
 870             AuthnContextDeclImpl(const AuthnContextDeclImpl& src) : AbstractXMLObject(src), AnyElementImpl(src) {}
 871
 872             IMPL_XMLOBJECT_CLONE_EX(AuthnContextDecl);
 873         };
 874
 875         class SAML_DLLLOCAL AuthnContextImpl : public virtual AuthnContext,
 876             public AbstractComplexElement,
 877             public AbstractDOMCachingXMLObject,
 878             public AbstractXMLObjectMarshaller,
 879             public AbstractXMLObjectUnmarshaller
 880         {
 881             void init() {
 882                 m_AuthnContextClassRef=nullptr;
 883                 m_AuthnContextDecl=nullptr;
 884                 m_AuthnContextDeclRef=nullptr;
 885                 m_children.push_back(nullptr);
 886                 m_children.push_back(nullptr);
 887                 m_children.push_back(nullptr);
 888                 m_pos_AuthnContextClassRef=m_children.begin();
 889                 m_pos_AuthnContextDecl=m_pos_AuthnContextClassRef;
 890                 ++m_pos_AuthnContextDecl;
 891                 m_pos_AuthnContextDeclRef=m_pos_AuthnContextDecl;
 892                 ++m_pos_AuthnContextDeclRef;
 893             }
 894
 895         public:
 896             virtual ~AuthnContextImpl() {}
 897
 898             AuthnContextImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 899                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 900                 init();
 901             }
 902
 903             AuthnContextImpl(const AuthnContextImpl& src)
 904                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 905                 init();
 906                 IMPL_CLONE_TYPED_CHILD(AuthnContextClassRef);
 907                 IMPL_CLONE_XMLOBJECT_CHILD(AuthnContextDecl);
 908                 IMPL_CLONE_TYPED_CHILD(AuthnContextDeclRef);
 909                 IMPL_CLONE_TYPED_CHILDREN(AuthenticatingAuthority);
 910             }
 911
 912             IMPL_XMLOBJECT_CLONE(AuthnContext);
 913             IMPL_TYPED_CHILD(AuthnContextClassRef);
 914             IMPL_XMLOBJECT_CHILD(AuthnContextDecl);
 915             IMPL_TYPED_CHILD(AuthnContextDeclRef);
 916             IMPL_TYPED_CHILDREN(AuthenticatingAuthority,m_children.end());
 917
 918         protected:
 919             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 920                 PROC_TYPED_CHILD(AuthnContextClassRef,SAML20_NS,false);
 921                 PROC_XMLOBJECT_CHILD(AuthnContextDecl,SAML20_NS);
 922                 PROC_TYPED_CHILD(AuthnContextDeclRef,SAML20_NS,false);
 923                 PROC_TYPED_CHILDREN(AuthenticatingAuthority,SAML20_NS,false);
 924                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 925             }
 926         };
 927
 928         class SAML_DLLLOCAL AuthnStatementImpl : public virtual AuthnStatement,
 929             public AbstractComplexElement,
 930             public AbstractDOMCachingXMLObject,
 931             public AbstractXMLObjectMarshaller,
 932             public AbstractXMLObjectUnmarshaller
 933         {
 934             void init() {
 935                 m_AuthnInstant=nullptr;
 936                 m_SessionIndex=nullptr;
 937                 m_SessionNotOnOrAfter=nullptr;
 938                 m_SubjectLocality=nullptr;
 939                 m_AuthnContext=nullptr;
 940                 m_children.push_back(nullptr);
 941                 m_children.push_back(nullptr);
 942                 m_pos_SubjectLocality=m_children.begin();
 943                 m_pos_AuthnContext=m_pos_SubjectLocality;
 944                 ++m_pos_AuthnContext;
 945             }
 946
 947         public:
 948             virtual ~AuthnStatementImpl() {
 949                 delete m_AuthnInstant;
 950                 XMLString::release(&m_SessionIndex);
 951                 delete m_SessionNotOnOrAfter;
 952             }
 953
 954             AuthnStatementImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 955                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 956                 init();
 957             }
 958
 959             AuthnStatementImpl(const AuthnStatementImpl& src)
 960                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 961                 init();
 962                 IMPL_CLONE_ATTRIB(AuthnInstant);
 963                 IMPL_CLONE_ATTRIB(SessionIndex);
 964                 IMPL_CLONE_ATTRIB(SessionNotOnOrAfter);
 965                 IMPL_CLONE_TYPED_CHILD(SubjectLocality);
 966                 IMPL_CLONE_TYPED_CHILD(AuthnContext);
 967             }
 968
 969             IMPL_XMLOBJECT_CLONE2(AuthnStatement,Statement);
 970             IMPL_DATETIME_ATTRIB(AuthnInstant,0);
 971             IMPL_STRING_ATTRIB(SessionIndex);
 972             IMPL_DATETIME_ATTRIB(SessionNotOnOrAfter,SAMLTIME_MAX);
 973             IMPL_TYPED_CHILD(SubjectLocality);
 974             IMPL_TYPED_CHILD(AuthnContext);
 975
 976         protected:
 977             void marshallAttributes(DOMElement* domElement) const {
 978                 MARSHALL_DATETIME_ATTRIB(AuthnInstant,AUTHNINSTANT,nullptr);
 979                 MARSHALL_STRING_ATTRIB(SessionIndex,SESSIONINDEX,nullptr);
 980                 MARSHALL_DATETIME_ATTRIB(SessionNotOnOrAfter,SESSIONNOTONORAFTER,nullptr);
 981             }
 982
 983             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 984                 PROC_TYPED_CHILD(SubjectLocality,SAML20_NS,false);
 985                 PROC_TYPED_CHILD(AuthnContext,SAML20_NS,false);
 986                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 987             }
 988
 989             void processAttribute(const DOMAttr* attribute) {
 990                 PROC_DATETIME_ATTRIB(AuthnInstant,AUTHNINSTANT,nullptr);
 991                 PROC_STRING_ATTRIB(SessionIndex,SESSIONINDEX,nullptr);
 992                 PROC_DATETIME_ATTRIB(SessionNotOnOrAfter,SESSIONNOTONORAFTER,nullptr);
 993                 AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 994             }
 995         };
 996
 997         class SAML_DLLLOCAL ActionImpl : public virtual Action,
 998             public AbstractSimpleElement,
 999             public AbstractDOMCachingXMLObject,
1000             public AbstractXMLObjectMarshaller,
1001             public AbstractXMLObjectUnmarshaller
1002         {
1003         public:
1004             virtual ~ActionImpl() {
1005                 XMLString::release(&m_Namespace);
1006             }
1007
1008             ActionImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
1009                 : AbstractXMLObject(nsURI, localName, prefix, schemaType), m_Namespace(nullptr) {}
1010
1011             ActionImpl(const ActionImpl& src)
1012                     : AbstractXMLObject(src), AbstractSimpleElement(src), AbstractDOMCachingXMLObject(src), m_Namespace(nullptr) {
1013                 IMPL_CLONE_ATTRIB(Namespace);
1014             }
1015
1016             IMPL_XMLOBJECT_CLONE(Action);
1017             IMPL_STRING_ATTRIB(Namespace);
1018
1019         protected:
1020             void marshallAttributes(DOMElement* domElement) const {
1021                 MARSHALL_STRING_ATTRIB(Namespace,NAMESPACE,nullptr);
1022             }
1023
1024             void processAttribute(const DOMAttr* attribute) {
1025                 PROC_STRING_ATTRIB(Namespace,NAMESPACE,nullptr);
1026                 AbstractXMLObjectUnmarshaller::processAttribute(attribute);
1027             }
1028         };
1029
1030         class SAML_DLLLOCAL EvidenceImpl : public virtual Evidence,
1031             public AbstractComplexElement,
1032             public AbstractDOMCachingXMLObject,
1033             public AbstractXMLObjectMarshaller,
1034             public AbstractXMLObjectUnmarshaller
1035         {
1036         public:
1037             virtual ~EvidenceImpl() {}
1038
1039             EvidenceImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
1040                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
1041
1042             EvidenceImpl(const EvidenceImpl& src)
1043                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
1044                 IMPL_CLONE_CHILDBAG_BEGIN;
1045                     IMPL_CLONE_TYPED_CHILD_IN_BAG(AssertionIDRef);
1046                     IMPL_CLONE_TYPED_CHILD_IN_BAG(AssertionURIRef);
1047                     IMPL_CLONE_TYPED_CHILD_IN_BAG(Assertion);
1048                     IMPL_CLONE_TYPED_CHILD_IN_BAG(EncryptedAssertion);
1049                 IMPL_CLONE_CHILDBAG_END;
1050             }
1051
1052             IMPL_XMLOBJECT_CLONE(Evidence);
1053             IMPL_TYPED_CHILDREN(AssertionIDRef,m_children.end());
1054             IMPL_TYPED_CHILDREN(AssertionURIRef,m_children.end());
1055             IMPL_TYPED_CHILDREN(Assertion,m_children.end());
1056             IMPL_TYPED_CHILDREN(EncryptedAssertion,m_children.end());
1057
1058         protected:
1059             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
1060                 PROC_TYPED_CHILDREN(AssertionIDRef,SAML20_NS,false);
1061                 PROC_TYPED_CHILDREN(AssertionURIRef,SAML20_NS,false);
1062                 PROC_TYPED_CHILDREN(Assertion,SAML20_NS,false);
1063                 PROC_TYPED_CHILDREN(EncryptedAssertion,SAML20_NS,false);
1064                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
1065             }
1066         };
1067
1068         class SAML_DLLLOCAL AuthzDecisionStatementImpl : public virtual AuthzDecisionStatement,
1069             public AbstractComplexElement,
1070             public AbstractDOMCachingXMLObject,
1071             public AbstractXMLObjectMarshaller,
1072             public AbstractXMLObjectUnmarshaller
1073         {
1074             void init() {
1075                 m_Resource=nullptr;
1076                 m_Decision=nullptr;
1077                 m_Evidence=nullptr;
1078                 m_children.push_back(nullptr);
1079                 m_pos_Evidence=m_children.begin();
1080             }
1081
1082         public:
1083             virtual ~AuthzDecisionStatementImpl() {
1084                 XMLString::release(&m_Resource);
1085                 XMLString::release(&m_Decision);
1086             }
1087
1088             AuthzDecisionStatementImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
1089                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
1090                 init();
1091             }
1092
1093             AuthzDecisionStatementImpl(const AuthzDecisionStatementImpl& src)
1094                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
1095                 init();
1096                 IMPL_CLONE_ATTRIB(Resource);
1097                 IMPL_CLONE_ATTRIB(Decision);
1098                 IMPL_CLONE_TYPED_CHILD(Evidence);
1099                 IMPL_CLONE_TYPED_CHILDREN(Action);
1100             }
1101
1102             IMPL_XMLOBJECT_CLONE2(AuthzDecisionStatement,Statement);
1103             IMPL_STRING_ATTRIB(Resource);
1104             IMPL_STRING_ATTRIB(Decision);
1105             IMPL_TYPED_CHILD(Evidence);
1106             IMPL_TYPED_CHILDREN(Action, m_pos_Evidence);
1107
1108         protected:
1109             void marshallAttributes(DOMElement* domElement) const {
1110                 MARSHALL_STRING_ATTRIB(Resource,RESOURCE,nullptr);
1111                 MARSHALL_STRING_ATTRIB(Decision,DECISION,nullptr);
1112             }
1113
1114             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
1115                 PROC_TYPED_CHILD(Evidence,SAML20_NS,false);
1116                 PROC_TYPED_CHILDREN(Action,SAML20_NS,false);
1117                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
1118             }
1119
1120             void processAttribute(const DOMAttr* attribute) {
1121                 PROC_STRING_ATTRIB(Resource,RESOURCE,nullptr);
1122                 PROC_STRING_ATTRIB(Decision,DECISION,nullptr);
1123                 AbstractXMLObjectUnmarshaller::processAttribute(attribute);
1124             }
1125         };
1126
1127         class SAML_DLLLOCAL AttributeValueImpl : public virtual AttributeValue, public AnyElementImpl
1128         {
1129         public:
1130             virtual ~AttributeValueImpl() {}
1131
1132             AttributeValueImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
1133                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
1134
1135             AttributeValueImpl(const AttributeValueImpl& src) : AbstractXMLObject(src), AnyElementImpl(src) {}
1136
1137             IMPL_XMLOBJECT_CLONE_EX(AttributeValue);
1138         };
1139
1140
1141         class SAML_DLLLOCAL AttributeImpl : public virtual Attribute,
1142             public AbstractComplexElement,
1143             public AbstractAttributeExtensibleXMLObject,
1144             public AbstractDOMCachingXMLObject,
1145             public AbstractXMLObjectMarshaller,
1146             public AbstractXMLObjectUnmarshaller
1147         {
1148             void init() {
1149                 m_Name=m_NameFormat=m_FriendlyName=nullptr;
1150             }
1151
1152         public:
1153             virtual ~AttributeImpl() {
1154                 XMLString::release(&m_Name);
1155                 XMLString::release(&m_NameFormat);
1156                 XMLString::release(&m_FriendlyName);
1157             }
1158
1159             AttributeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
1160                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
1161                 init();
1162             }
1163
1164             AttributeImpl(const AttributeImpl& src)
1165                     : AbstractXMLObject(src), AbstractComplexElement(src),
1166                         AbstractAttributeExtensibleXMLObject(src), AbstractDOMCachingXMLObject(src) {
1167                 init();
1168                 IMPL_CLONE_ATTRIB(Name);
1169                 IMPL_CLONE_ATTRIB(NameFormat);
1170                 IMPL_CLONE_ATTRIB(FriendlyName);
1171                 IMPL_CLONE_XMLOBJECT_CHILDREN(AttributeValue);
1172             }
1173
1174             IMPL_XMLOBJECT_CLONE(Attribute);
1175             IMPL_STRING_ATTRIB(Name);
1176             IMPL_STRING_ATTRIB(NameFormat);
1177             IMPL_STRING_ATTRIB(FriendlyName);
1178             IMPL_XMLOBJECT_CHILDREN(AttributeValue,m_children.end());
1179
1180             void setAttribute(const xmltooling::QName& qualifiedName, const XMLCh* value, bool ID=false) {
1181                 if (!qualifiedName.hasNamespaceURI()) {
1182                     if (XMLString::equals(qualifiedName.getLocalPart(),NAME_ATTRIB_NAME)) {
1183                         setName(value);
1184                         return;
1185                     }
1186                     else if (XMLString::equals(qualifiedName.getLocalPart(),NAMEFORMAT_ATTRIB_NAME)) {
1187                         setNameFormat(value);
1188                         return;
1189                     }
1190                     else if (XMLString::equals(qualifiedName.getLocalPart(),FRIENDLYNAME_ATTRIB_NAME)) {
1191                         setFriendlyName(value);
1192                         return;
1193                     }
1194                 }
1195                 AbstractAttributeExtensibleXMLObject::setAttribute(qualifiedName, value, ID);
1196             }
1197
1198         protected:
1199             void marshallAttributes(DOMElement* domElement) const {
1200                 MARSHALL_STRING_ATTRIB(Name,NAME,nullptr);
1201                 MARSHALL_STRING_ATTRIB(NameFormat,NAMEFORMAT,nullptr);
1202                 MARSHALL_STRING_ATTRIB(FriendlyName,FRIENDLYNAME,nullptr);
1203                 marshallExtensionAttributes(domElement);
1204             }
1205
1206             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
1207                 getAttributeValues().push_back(childXMLObject);
1208             }
1209
1210             void processAttribute(const DOMAttr* attribute) {
1211                 unmarshallExtensionAttribute(attribute);
1212             }
1213         };
1214
1215         class SAML_DLLLOCAL EncryptedAttributeImpl : public virtual EncryptedAttribute, public EncryptedElementTypeImpl
1216         {
1217         public:
1218             virtual ~EncryptedAttributeImpl() {}
1219
1220             EncryptedAttributeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
1221                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
1222
1223             EncryptedAttributeImpl(const EncryptedAttributeImpl& src) : AbstractXMLObject(src), EncryptedElementTypeImpl(src) {}
1224
1225             IMPL_XMLOBJECT_CLONE_EX(EncryptedAttribute);
1226         };
1227
1228         class SAML_DLLLOCAL AttributeStatementImpl : public virtual AttributeStatement,
1229             public AbstractComplexElement,
1230             public AbstractDOMCachingXMLObject,
1231             public AbstractXMLObjectMarshaller,
1232             public AbstractXMLObjectUnmarshaller
1233         {
1234         public:
1235             virtual ~AttributeStatementImpl() {}
1236
1237             AttributeStatementImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
1238                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
1239
1240             AttributeStatementImpl(const AttributeStatementImpl& src)
1241                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
1242                 IMPL_CLONE_CHILDBAG_BEGIN;
1243                     IMPL_CLONE_TYPED_CHILD_IN_BAG(Attribute);
1244                     IMPL_CLONE_TYPED_CHILD_IN_BAG(EncryptedAttribute);
1245                 IMPL_CLONE_CHILDBAG_END;
1246             }
1247
1248             IMPL_XMLOBJECT_CLONE2(AttributeStatement,Statement);
1249             IMPL_TYPED_CHILDREN(Attribute, m_children.end());
1250             IMPL_TYPED_CHILDREN(EncryptedAttribute, m_children.end());
1251
1252         protected:
1253             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
1254                 PROC_TYPED_CHILDREN(Attribute,SAML20_NS,false);
1255                 PROC_TYPED_CHILDREN(EncryptedAttribute,SAML20_NS,false);
1256                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
1257             }
1258         };
1259
1260         class SAML_DLLLOCAL AdviceImpl : public virtual Advice,
1261             public AbstractComplexElement,
1262             public AbstractDOMCachingXMLObject,
1263             public AbstractXMLObjectMarshaller,
1264             public AbstractXMLObjectUnmarshaller
1265         {
1266         public:
1267             virtual ~AdviceImpl() {}
1268
1269             AdviceImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
1270                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
1271
1272             AdviceImpl(const AdviceImpl& src)
1273                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
1274                 IMPL_CLONE_CHILDBAG_BEGIN;
1275                     IMPL_CLONE_TYPED_CHILD_IN_BAG(AssertionIDRef);
1276                     IMPL_CLONE_TYPED_CHILD_IN_BAG(AssertionURIRef);
1277                     IMPL_CLONE_TYPED_CHILD_IN_BAG(Assertion);
1278                     IMPL_CLONE_TYPED_CHILD_IN_BAG(EncryptedAssertion);
1279                     IMPL_CLONE_XMLOBJECT_CHILD_IN_BAG(UnknownXMLObject);
1280                 IMPL_CLONE_CHILDBAG_END;
1281             }
1282
1283             IMPL_XMLOBJECT_CLONE(Advice);
1284             IMPL_TYPED_CHILDREN(AssertionIDRef,m_children.end());
1285             IMPL_TYPED_CHILDREN(AssertionURIRef,m_children.end());
1286             IMPL_TYPED_CHILDREN(Assertion,m_children.end());
1287             IMPL_TYPED_CHILDREN(EncryptedAssertion,m_children.end());
1288             IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject,m_children.end());
1289
1290         protected:
1291             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
1292                 PROC_TYPED_CHILDREN(AssertionIDRef,SAML20_NS,false);
1293                 PROC_TYPED_CHILDREN(AssertionURIRef,SAML20_NS,false);
1294                 PROC_TYPED_CHILDREN(Assertion,SAML20_NS,false);
1295                 PROC_TYPED_CHILDREN(EncryptedAssertion,SAML20_NS,false);
1296
1297                 // Unknown child.
1298                 const XMLCh* nsURI=root->getNamespaceURI();
1299                 if (!XMLString::equals(nsURI,SAML20_NS) && nsURI && *nsURI) {
1300                     getUnknownXMLObjects().push_back(childXMLObject);
1301                     return;
1302                 }
1303
1304                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
1305             }
1306         };
1307
1308         class SAML_DLLLOCAL EncryptedAssertionImpl : public virtual EncryptedAssertion, public EncryptedElementTypeImpl
1309         {
1310         public:
1311             virtual ~EncryptedAssertionImpl() {}
1312
1313             EncryptedAssertionImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
1314                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
1315
1316             EncryptedAssertionImpl(const EncryptedAssertionImpl& src) : AbstractXMLObject(src), EncryptedElementTypeImpl(src) {}
1317
1318             IMPL_XMLOBJECT_CLONE_EX(EncryptedAssertion);
1319         };
1320
1321         class SAML_DLLLOCAL AssertionImpl : public virtual Assertion,
1322             public AbstractComplexElement,
1323             public AbstractDOMCachingXMLObject,
1324             public AbstractXMLObjectMarshaller,
1325             public AbstractXMLObjectUnmarshaller
1326         {
1327             void init() {
1328                 m_ID=nullptr;
1329                 m_Version=nullptr;
1330                 m_IssueInstant=nullptr;
1331                 m_Issuer=nullptr;
1332                 m_Signature=nullptr;
1333                 m_Subject=nullptr;
1334                 m_Conditions=nullptr;
1335                 m_Advice=nullptr;
1336                 m_children.push_back(nullptr);
1337                 m_children.push_back(nullptr);
1338                 m_children.push_back(nullptr);
1339                 m_children.push_back(nullptr);
1340                 m_children.push_back(nullptr);
1341                 m_pos_Issuer=m_children.begin();
1342                 m_pos_Signature=m_pos_Issuer;
1343                 ++m_pos_Signature;
1344                 m_pos_Subject=m_pos_Signature;
1345                 ++m_pos_Subject;
1346                 m_pos_Conditions=m_pos_Subject;
1347                 ++m_pos_Conditions;
1348                 m_pos_Advice=m_pos_Conditions;
1349                 ++m_pos_Advice;
1350             }
1351
1352         public:
1353             virtual ~AssertionImpl() {
1354                 XMLString::release(&m_ID);
1355                 XMLString::release(&m_Version);
1356                 delete m_IssueInstant;
1357             }
1358
1359             AssertionImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
1360                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
1361                 init();
1362             }
1363
1364             AssertionImpl(const AssertionImpl& src)
1365                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
1366                 init();
1367                 IMPL_CLONE_ATTRIB(Version);
1368                 IMPL_CLONE_ATTRIB(ID);
1369                 IMPL_CLONE_ATTRIB(IssueInstant);
1370                 IMPL_CLONE_TYPED_CHILD(Issuer);
1371                 IMPL_CLONE_TYPED_CHILD(Signature);
1372                 IMPL_CLONE_TYPED_CHILD(Subject);
1373                 IMPL_CLONE_TYPED_CHILD(Conditions);
1374                 IMPL_CLONE_TYPED_CHILD(Advice);
1375                 IMPL_CLONE_CHILDBAG_BEGIN;
1376                     IMPL_CLONE_TYPED_CHILD_IN_BAG(AuthnStatement);
1377                     IMPL_CLONE_TYPED_CHILD_IN_BAG(AttributeStatement);
1378                     IMPL_CLONE_TYPED_CHILD_IN_BAG(AuthzDecisionStatement);
1379                     IMPL_CLONE_TYPED_CHILD_IN_BAG(Statement);
1380                 IMPL_CLONE_CHILDBAG_END;
1381             }
1382
1383             //IMPL_TYPED_CHILD(Signature);
1384             // Need customized setter.
1385         protected:
1386             xmlsignature::Signature* m_Signature;
1387             list<XMLObject*>::iterator m_pos_Signature;
1388         public:
1389             xmlsignature::Signature* getSignature() const {
1390                 return m_Signature;
1391             }
1392
1393             void setSignature(xmlsignature::Signature* sig) {
1394                 prepareForAssignment(m_Signature,sig);
1395                 *m_pos_Signature=m_Signature=sig;
1396                 // Sync content reference back up.
1397                 if (m_Signature)
1398                     m_Signature->setContentReference(new opensaml::ContentReference(*this));
1399             }
1400
1401             IMPL_XMLOBJECT_CLONE(Assertion);
1402             IMPL_STRING_ATTRIB(Version);
1403             IMPL_ID_ATTRIB_EX(ID,ID,nullptr);
1404             IMPL_DATETIME_ATTRIB(IssueInstant,0);
1405             IMPL_TYPED_CHILD(Issuer);
1406             IMPL_TYPED_CHILD(Subject);
1407             IMPL_TYPED_CHILD(Conditions);
1408             IMPL_TYPED_CHILD(Advice);
1409             IMPL_TYPED_CHILDREN(Statement, m_children.end());
1410             IMPL_TYPED_CHILDREN(AuthnStatement, m_children.end());
1411             IMPL_TYPED_CHILDREN(AttributeStatement, m_children.end());
1412             IMPL_TYPED_CHILDREN(AuthzDecisionStatement, m_children.end());
1413
1414         protected:
1415             void prepareForMarshalling() const {
1416                 if (m_Signature)
1417                     declareNonVisibleNamespaces();
1418             }
1419
1420             void marshallAttributes(DOMElement* domElement) const {
1421                 if (!m_Version)
1422                     const_cast<AssertionImpl*>(this)->m_Version=XMLString::transcode("2.0");
1423                 MARSHALL_STRING_ATTRIB(Version,VER,nullptr);
1424                 if (!m_ID)
1425                     const_cast<AssertionImpl*>(this)->m_ID=SAMLConfig::getConfig().generateIdentifier();
1426                 MARSHALL_ID_ATTRIB(ID,ID,nullptr);
1427                 if (!m_IssueInstant) {
1428                     const_cast<AssertionImpl*>(this)->m_IssueInstantEpoch=time(nullptr);
1429                     const_cast<AssertionImpl*>(this)->m_IssueInstant=new DateTime(m_IssueInstantEpoch);
1430                 }
1431                 MARSHALL_DATETIME_ATTRIB(IssueInstant,ISSUEINSTANT,nullptr);
1432             }
1433
1434             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
1435                 PROC_TYPED_CHILD(Issuer,SAML20_NS,false);
1436                 PROC_TYPED_FOREIGN_CHILD(Signature,xmlsignature,XMLSIG_NS,false);
1437                 PROC_TYPED_CHILD(Subject,SAML20_NS,false);
1438                 PROC_TYPED_CHILD(Conditions,SAML20_NS,false);
1439                 PROC_TYPED_CHILD(Advice,SAML20_NS,false);
1440                 PROC_TYPED_CHILDREN(AuthnStatement,SAML20_NS,false);
1441                 PROC_TYPED_CHILDREN(AttributeStatement,SAML20_NS,false);
1442                 PROC_TYPED_CHILDREN(AuthzDecisionStatement,SAML20_NS,false);
1443                 PROC_TYPED_CHILDREN(Statement,SAML20_NS,false);
1444                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
1445             }
1446
1447             void processAttribute(const DOMAttr* attribute) {
1448                 PROC_STRING_ATTRIB(Version,VER,nullptr);
1449                 PROC_ID_ATTRIB(ID,ID,nullptr);
1450                 PROC_DATETIME_ATTRIB(IssueInstant,ISSUEINSTANT,nullptr);
1451                 AbstractXMLObjectUnmarshaller::processAttribute(attribute);
1452             }
1453         };
1454
1455     };
1456 };
1457
1458 #if defined (_MSC_VER)
1459     #pragma warning( pop )
1460 #endif
1461
1462 // Builder Implementations
1463
1464 IMPL_XMLOBJECTBUILDER(Action);
1465 IMPL_XMLOBJECTBUILDER(Advice);
1466 IMPL_XMLOBJECTBUILDER(Assertion);
1467 IMPL_XMLOBJECTBUILDER(AssertionIDRef);
1468 IMPL_XMLOBJECTBUILDER(AssertionURIRef);
1469 IMPL_XMLOBJECTBUILDER(Attribute);
1470 IMPL_XMLOBJECTBUILDER(AttributeStatement);
1471 IMPL_XMLOBJECTBUILDER(AttributeValue);
1472 IMPL_XMLOBJECTBUILDER(Audience);
1473 IMPL_XMLOBJECTBUILDER(AudienceRestriction);
1474 IMPL_XMLOBJECTBUILDER(AuthenticatingAuthority);
1475 IMPL_XMLOBJECTBUILDER(AuthnContext);
1476 IMPL_XMLOBJECTBUILDER(AuthnContextClassRef);
1477 IMPL_XMLOBJECTBUILDER(AuthnContextDecl);
1478 IMPL_XMLOBJECTBUILDER(AuthnContextDeclRef);
1479 IMPL_XMLOBJECTBUILDER(AuthnStatement);
1480 IMPL_XMLOBJECTBUILDER(AuthzDecisionStatement);
1481 IMPL_XMLOBJECTBUILDER(Condition);
1482 IMPL_XMLOBJECTBUILDER(Conditions);
1483 IMPL_XMLOBJECTBUILDER(Delegate);
1484 IMPL_XMLOBJECTBUILDER(DelegationRestrictionType);
1485 IMPL_XMLOBJECTBUILDER(EncryptedAssertion);
1486 IMPL_XMLOBJECTBUILDER(EncryptedAttribute);
1487 IMPL_XMLOBJECTBUILDER(EncryptedID);
1488 IMPL_XMLOBJECTBUILDER(Evidence);
1489 IMPL_XMLOBJECTBUILDER(Issuer);
1490 IMPL_XMLOBJECTBUILDER(KeyInfoConfirmationDataType);
1491 IMPL_XMLOBJECTBUILDER(NameID);
1492 IMPL_XMLOBJECTBUILDER(NameIDType);
1493 IMPL_XMLOBJECTBUILDER(OneTimeUse);
1494 IMPL_XMLOBJECTBUILDER(ProxyRestriction);
1495 IMPL_XMLOBJECTBUILDER(Statement);
1496 IMPL_XMLOBJECTBUILDER(Subject);
1497 IMPL_XMLOBJECTBUILDER(SubjectConfirmation);
1498 IMPL_XMLOBJECTBUILDER(SubjectConfirmationData);
1499 IMPL_XMLOBJECTBUILDER(SubjectLocality);
1500
1501 // Unicode literals
1502 const XMLCh Action::LOCAL_NAME[] =                  UNICODE_LITERAL_6(A,c,t,i,o,n);
1503 const XMLCh Action::TYPE_NAME[] =                   UNICODE_LITERAL_10(A,c,t,i,o,n,T,y,p,e);
1504 const XMLCh Action::NAMESPACE_ATTRIB_NAME[] =       UNICODE_LITERAL_9(N,a,m,e,s,p,a,c,e);
1505 const XMLCh Advice::LOCAL_NAME[] =                  UNICODE_LITERAL_6(A,d,v,i,c,e);
1506 const XMLCh Advice::TYPE_NAME[] =                   UNICODE_LITERAL_10(A,d,v,i,c,e,T,y,p,e);
1507 const XMLCh Assertion::LOCAL_NAME[] =               UNICODE_LITERAL_9(A,s,s,e,r,t,i,o,n);
1508 const XMLCh Assertion::TYPE_NAME[] =                UNICODE_LITERAL_13(A,s,s,e,r,t,i,o,n,T,y,p,e);
1509 const XMLCh Assertion::VER_ATTRIB_NAME[] =          UNICODE_LITERAL_7(V,e,r,s,i,o,n);
1510 const XMLCh Assertion::ID_ATTRIB_NAME[] =           UNICODE_LITERAL_2(I,D);
1511 const XMLCh Assertion::ISSUEINSTANT_ATTRIB_NAME[] = UNICODE_LITERAL_12(I,s,s,u,e,I,n,s,t,a,n,t);
1512 const XMLCh AssertionIDRef::LOCAL_NAME[] =          UNICODE_LITERAL_14(A,s,s,e,r,t,i,o,n,I,D,R,e,f);
1513 const XMLCh AssertionURIRef::LOCAL_NAME[] =         UNICODE_LITERAL_15(A,s,s,e,r,t,i,o,n,U,R,I,R,e,f);
1514 const XMLCh Attribute::LOCAL_NAME[] =               UNICODE_LITERAL_9(A,t,t,r,i,b,u,t,e);
1515 const XMLCh Attribute::TYPE_NAME[] =                UNICODE_LITERAL_13(A,t,t,r,i,b,u,t,e,T,y,p,e);
1516 const XMLCh Attribute::NAME_ATTRIB_NAME[] =         UNICODE_LITERAL_4(N,a,m,e);
1517 const XMLCh Attribute::NAMEFORMAT_ATTRIB_NAME[] =   UNICODE_LITERAL_10(N,a,m,e,F,o,r,m,a,t);
1518 const XMLCh Attribute::FRIENDLYNAME_ATTRIB_NAME[] = UNICODE_LITERAL_12(F,r,i,e,n,d,l,y,N,a,m,e);
1519 const XMLCh AttributeStatement::LOCAL_NAME[] =      UNICODE_LITERAL_18(A,t,t,r,i,b,u,t,e,S,t,a,t,e,m,e,n,t);
1520 const XMLCh AttributeStatement::TYPE_NAME[] =       UNICODE_LITERAL_22(A,t,t,r,i,b,u,t,e,S,t,a,t,e,m,e,n,t,T,y,p,e);
1521 const XMLCh AttributeValue::LOCAL_NAME[] =          UNICODE_LITERAL_14(A,t,t,r,i,b,u,t,e,V,a,l,u,e);
1522 const XMLCh Audience::LOCAL_NAME[] =                UNICODE_LITERAL_8(A,u,d,i,e,n,c,e);
1523 const XMLCh AudienceRestriction::LOCAL_NAME[] =     UNICODE_LITERAL_19(A,u,d,i,e,n,c,e,R,e,s,t,r,i,c,t,i,o,n);
1524 const XMLCh AudienceRestriction::TYPE_NAME[] =      UNICODE_LITERAL_23(A,u,d,i,e,n,c,e,R,e,s,t,r,i,c,t,i,o,n,T,y,p,e);
1525 const XMLCh AuthenticatingAuthority::LOCAL_NAME[] = UNICODE_LITERAL_23(A,u,t,h,e,n,t,i,c,a,t,i,n,g,A,u,t,h,o,r,i,t,y);
1526 const XMLCh AuthnContext::LOCAL_NAME[] =            UNICODE_LITERAL_12(A,u,t,h,n,C,o,n,t,e,x,t);
1527 const XMLCh AuthnContext::TYPE_NAME[] =             UNICODE_LITERAL_16(A,u,t,h,n,C,o,n,t,e,x,t,T,y,p,e);
1528 const XMLCh AuthnContextClassRef::LOCAL_NAME[] =    UNICODE_LITERAL_20(A,u,t,h,n,C,o,n,t,e,x,t,C,l,a,s,s,R,e,f);
1529 const XMLCh AuthnContextDecl::LOCAL_NAME[] =        UNICODE_LITERAL_16(A,u,t,h,n,C,o,n,t,e,x,t,D,e,c,l);
1530 const XMLCh AuthnContextDeclRef::LOCAL_NAME[] =     UNICODE_LITERAL_19(A,u,t,h,n,C,o,n,t,e,x,t,D,e,c,l,R,e,f);
1531 const XMLCh AuthnStatement::LOCAL_NAME[] =          UNICODE_LITERAL_14(A,u,t,h,n,S,t,a,t,e,m,e,n,t);
1532 const XMLCh AuthnStatement::TYPE_NAME[] =           UNICODE_LITERAL_18(A,u,t,h,n,S,t,a,t,e,m,e,n,t,T,y,p,e);
1533 const XMLCh AuthnStatement::AUTHNINSTANT_ATTRIB_NAME[] =    UNICODE_LITERAL_12(A,u,t,h,n,I,n,s,t,a,n,t);
1534 const XMLCh AuthnStatement::SESSIONINDEX_ATTRIB_NAME[] =    UNICODE_LITERAL_12(S,e,s,s,i,o,n,I,n,d,e,x);
1535 const XMLCh AuthnStatement::SESSIONNOTONORAFTER_ATTRIB_NAME[] = UNICODE_LITERAL_19(S,e,s,s,i,o,n,N,o,t,O,n,O,r,A,f,t,e,r);
1536 const XMLCh AuthzDecisionStatement::LOCAL_NAME[] =  UNICODE_LITERAL_22(A,u,t,h,z,D,e,c,i,s,i,o,n,S,t,a,t,e,m,e,n,t);
1537 const XMLCh AuthzDecisionStatement::TYPE_NAME[] =   UNICODE_LITERAL_26(A,u,t,h,z,D,e,c,i,s,i,o,n,S,t,a,t,e,m,e,n,t,T,y,p,e);
1538 const XMLCh AuthzDecisionStatement::RESOURCE_ATTRIB_NAME[] =    UNICODE_LITERAL_8(R,e,s,o,u,r,c,e);
1539 const XMLCh AuthzDecisionStatement::DECISION_ATTRIB_NAME[] =    UNICODE_LITERAL_8(D,e,c,i,s,i,o,n);
1540 const XMLCh AuthzDecisionStatement::DECISION_PERMIT[] = UNICODE_LITERAL_6(P,e,r,m,i,t);
1541 const XMLCh AuthzDecisionStatement::DECISION_DENY[] =   UNICODE_LITERAL_4(D,e,n,y);
1542 const XMLCh AuthzDecisionStatement::DECISION_INDETERMINATE[] =  UNICODE_LITERAL_13(I,n,d,e,t,e,r,m,i,n,a,t,e);
1543 const XMLCh BaseID::LOCAL_NAME[] =                  UNICODE_LITERAL_6(B,a,s,e,I,D);
1544 const XMLCh BaseID::NAMEQUALIFIER_ATTRIB_NAME[] =   UNICODE_LITERAL_13(N,a,m,e,Q,u,a,l,i,f,i,e,r);
1545 const XMLCh BaseID::SPNAMEQUALIFIER_ATTRIB_NAME[] = UNICODE_LITERAL_15(S,P,N,a,m,e,Q,u,a,l,i,f,i,e,r);
1546 const XMLCh Condition::LOCAL_NAME[] =               UNICODE_LITERAL_9(C,o,n,d,i,t,i,o,n);
1547 const XMLCh Conditions::LOCAL_NAME[] =              UNICODE_LITERAL_10(C,o,n,d,i,t,i,o,n,s);
1548 const XMLCh Conditions::TYPE_NAME[] =               UNICODE_LITERAL_14(C,o,n,d,i,t,i,o,n,s,T,y,p,e);
1549 const XMLCh Conditions::NOTBEFORE_ATTRIB_NAME[] =   UNICODE_LITERAL_9(N,o,t,B,e,f,o,r,e);
1550 const XMLCh Conditions::NOTONORAFTER_ATTRIB_NAME[] =UNICODE_LITERAL_12(N,o,t,O,n,O,r,A,f,t,e,r);
1551 const XMLCh Delegate::LOCAL_NAME[] =                UNICODE_LITERAL_8(D,e,l,e,g,a,t,e);
1552 const XMLCh Delegate::TYPE_NAME[] =                 UNICODE_LITERAL_12(D,e,l,e,g,a,t,e,T,y,p,e);
1553 const XMLCh Delegate::CONFIRMATIONMETHOD_ATTRIB_NAME[] = UNICODE_LITERAL_18(C,o,n,f,i,r,m,a,t,i,o,n,M,e,t,h,o,d);
1554 const XMLCh Delegate::DELEGATIONINSTANT_ATTRIB_NAME[] = UNICODE_LITERAL_17(D,e,l,e,g,a,t,i,o,n,I,n,s,t,a,n,t);
1555 const XMLCh DelegationRestrictionType::LOCAL_NAME[] = UNICODE_LITERAL_9(C,o,n,d,i,t,i,o,n);
1556 const XMLCh DelegationRestrictionType::TYPE_NAME[] =UNICODE_LITERAL_25(D,e,l,e,g,a,t,i,o,n,R,e,s,t,r,i,c,t,i,o,n,T,y,p,e);
1557 const XMLCh EncryptedAssertion::LOCAL_NAME[] =      UNICODE_LITERAL_18(E,n,c,r,y,p,t,e,d,A,s,s,e,r,t,i,o,n);
1558 const XMLCh EncryptedAttribute::LOCAL_NAME[] =      UNICODE_LITERAL_18(E,n,c,r,y,p,t,e,d,A,t,t,r,i,b,u,t,e);
1559 const XMLCh EncryptedElementType::LOCAL_NAME[] =    {chNull};
1560 const XMLCh EncryptedElementType::TYPE_NAME[] =     UNICODE_LITERAL_20(E,n,c,r,y,p,t,e,d,E,l,e,m,e,n,t,T,y,p,e);
1561 const XMLCh EncryptedID::LOCAL_NAME[] =             UNICODE_LITERAL_11(E,n,c,r,y,p,t,e,d,I,D);
1562 const XMLCh Evidence::LOCAL_NAME[] =                UNICODE_LITERAL_8(E,v,i,d,e,n,c,e);
1563 const XMLCh Evidence::TYPE_NAME[] =                 UNICODE_LITERAL_12(E,v,i,d,e,n,c,e,T,y,p,e);
1564 const XMLCh Issuer::LOCAL_NAME[] =                  UNICODE_LITERAL_6(I,s,s,u,e,r);
1565 const XMLCh KeyInfoConfirmationDataType::LOCAL_NAME[] = UNICODE_LITERAL_23(S,u,b,j,e,c,t,C,o,n,f,i,r,m,a,t,i,o,n,D,a,t,a);
1566 const XMLCh KeyInfoConfirmationDataType::TYPE_NAME[] = UNICODE_LITERAL_27(K,e,y,I,n,f,o,C,o,n,f,i,r,m,a,t,i,o,n,D,a,t,a,T,y,p,e);
1567 const XMLCh NameID::LOCAL_NAME[] =                  UNICODE_LITERAL_6(N,a,m,e,I,D);
1568 const XMLCh NameIDType::LOCAL_NAME[] =              {chNull};
1569 const XMLCh NameIDType::TYPE_NAME[] =               UNICODE_LITERAL_10(N,a,m,e,I,D,T,y,p,e);
1570 const XMLCh NameIDType::NAMEQUALIFIER_ATTRIB_NAME[] =   UNICODE_LITERAL_13(N,a,m,e,Q,u,a,l,i,f,i,e,r);
1571 const XMLCh NameIDType::SPNAMEQUALIFIER_ATTRIB_NAME[] = UNICODE_LITERAL_15(S,P,N,a,m,e,Q,u,a,l,i,f,i,e,r);
1572 const XMLCh NameIDType::FORMAT_ATTRIB_NAME[] =      UNICODE_LITERAL_6(F,o,r,m,a,t);
1573 const XMLCh NameIDType::SPPROVIDEDID_ATTRIB_NAME[] =    UNICODE_LITERAL_12(S,P,P,r,o,v,i,d,e,d,I,D);
1574 const XMLCh OneTimeUse::LOCAL_NAME[] =              UNICODE_LITERAL_10(O,n,e,T,i,m,e,U,s,e);
1575 const XMLCh OneTimeUse::TYPE_NAME[] =               UNICODE_LITERAL_14(O,n,e,T,i,m,e,U,s,e,T,y,p,e);
1576 const XMLCh ProxyRestriction::LOCAL_NAME[] =        UNICODE_LITERAL_16(P,r,o,x,y,R,e,s,t,r,i,c,t,i,o,n);
1577 const XMLCh ProxyRestriction::TYPE_NAME[] =         UNICODE_LITERAL_20(P,r,o,x,y,R,e,s,t,r,i,c,t,i,o,n,T,y,p,e);
1578 const XMLCh ProxyRestriction::COUNT_ATTRIB_NAME[] = UNICODE_LITERAL_5(C,o,u,n,t);
1579 const XMLCh Statement::LOCAL_NAME[] =               UNICODE_LITERAL_9(S,t,a,t,e,m,e,n,t);
1580 const XMLCh Subject::LOCAL_NAME[] =                 UNICODE_LITERAL_7(S,u,b,j,e,c,t);
1581 const XMLCh Subject::TYPE_NAME[] =                  UNICODE_LITERAL_11(S,u,b,j,e,c,t,T,y,p,e);
1582 const XMLCh SubjectConfirmation::LOCAL_NAME[] =     UNICODE_LITERAL_19(S,u,b,j,e,c,t,C,o,n,f,i,r,m,a,t,i,o,n);
1583 const XMLCh SubjectConfirmation::TYPE_NAME[] =      UNICODE_LITERAL_23(S,u,b,j,e,c,t,C,o,n,f,i,r,m,a,t,i,o,n,T,y,p,e);
1584 const XMLCh SubjectConfirmation::METHOD_ATTRIB_NAME[] = UNICODE_LITERAL_6(M,e,t,h,o,d);
1585 const XMLCh SubjectConfirmationData::LOCAL_NAME[] = UNICODE_LITERAL_23(S,u,b,j,e,c,t,C,o,n,f,i,r,m,a,t,i,o,n,D,a,t,a);
1586 const XMLCh SubjectConfirmationDataType::NOTBEFORE_ATTRIB_NAME[] =      UNICODE_LITERAL_9(N,o,t,B,e,f,o,r,e);
1587 const XMLCh SubjectConfirmationDataType::NOTONORAFTER_ATTRIB_NAME[] =   UNICODE_LITERAL_12(N,o,t,O,n,O,r,A,f,t,e,r);
1588 const XMLCh SubjectConfirmationDataType::INRESPONSETO_ATTRIB_NAME[] =   UNICODE_LITERAL_12(I,n,R,e,s,p,o,n,s,e,T,o);
1589 const XMLCh SubjectConfirmationDataType::RECIPIENT_ATTRIB_NAME[] =      UNICODE_LITERAL_9(R,e,c,i,p,i,e,n,t);
1590 const XMLCh SubjectConfirmationDataType::ADDRESS_ATTRIB_NAME[] =        UNICODE_LITERAL_7(A,d,d,r,e,s,s);
1591 const XMLCh SubjectLocality::LOCAL_NAME[] =         UNICODE_LITERAL_15(S,u,b,j,e,c,t,L,o,c,a,l,i,t,y);
1592 const XMLCh SubjectLocality::TYPE_NAME[] =          UNICODE_LITERAL_19(S,u,b,j,e,c,t,L,o,c,a,l,i,t,y,T,y,p,e);
1593 const XMLCh SubjectLocality::ADDRESS_ATTRIB_NAME[] =UNICODE_LITERAL_7(A,d,d,r,e,s,s);
1594 const XMLCh SubjectLocality::DNSNAME_ATTRIB_NAME[] =UNICODE_LITERAL_7(D,N,S,N,a,m,e);
1595
1596 const XMLCh NameIDType::UNSPECIFIED[] = // urn:oasis:names:tc:SAML:1.1:nameid-format:unspecified
1597 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1598   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1599   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_1, chPeriod, chDigit_1, chColon,
1600   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_i, chLatin_d, chDash,
1601   chLatin_f, chLatin_o, chLatin_r, chLatin_m, chLatin_a, chLatin_t, chColon,
1602   chLatin_u, chLatin_n, chLatin_s, chLatin_p, chLatin_e, chLatin_c, chLatin_i, chLatin_f, chLatin_i, chLatin_e, chLatin_d, chNull
1603 };
1604
1605 const XMLCh NameIDType::EMAIL[] = // urn:oasis:names:tc:SAML:1.1:nameid-format:emailAddress
1606 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1607   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1608   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_1, chPeriod, chDigit_1, chColon,
1609   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_i, chLatin_d, chDash,
1610   chLatin_f, chLatin_o, chLatin_r, chLatin_m, chLatin_a, chLatin_t, chColon,
1611   chLatin_e, chLatin_m, chLatin_a, chLatin_i, chLatin_l, chLatin_A, chLatin_d, chLatin_d, chLatin_r, chLatin_e, chLatin_s, chLatin_s, chNull
1612 };
1613
1614 const XMLCh NameIDType::X509_SUBJECT[] = // urn:oasis:names:tc:SAML:1.1:nameid-format:X509SubjectName
1615 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1616   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1617   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_1, chPeriod, chDigit_1, chColon,
1618   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_i, chLatin_d, chDash,
1619   chLatin_f, chLatin_o, chLatin_r, chLatin_m, chLatin_a, chLatin_t, chColon,
1620   chLatin_X, chDigit_5, chDigit_0, chDigit_9, chLatin_S, chLatin_u, chLatin_b, chLatin_j, chLatin_e, chLatin_c, chLatin_t,
1621   chLatin_N, chLatin_a, chLatin_m, chLatin_e, chNull
1622 };
1623
1624 const XMLCh NameIDType::WIN_DOMAIN_QUALIFIED[] = // urn:oasis:names:tc:SAML:1.1:nameid-format:WindowsDomainQualifiedName
1625 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1626   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1627   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_1, chPeriod, chDigit_1, chColon,
1628   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_i, chLatin_d, chDash,
1629   chLatin_f, chLatin_o, chLatin_r, chLatin_m, chLatin_a, chLatin_t, chColon,
1630   chLatin_W, chLatin_i, chLatin_n, chLatin_d, chLatin_o, chLatin_w, chLatin_s,
1631   chLatin_D, chLatin_o, chLatin_m, chLatin_a, chLatin_i, chLatin_n,
1632   chLatin_Q, chLatin_u, chLatin_a, chLatin_l, chLatin_i, chLatin_f, chLatin_i, chLatin_e, chLatin_d,
1633   chLatin_N, chLatin_a, chLatin_m, chLatin_e, chNull
1634 };
1635
1636 const XMLCh NameIDType::KERBEROS[] = // urn:oasis:names:tc:SAML:2.0:nameid-format:kerberos
1637 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1638   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1639   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1640   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_i, chLatin_d, chDash,
1641   chLatin_f, chLatin_o, chLatin_r, chLatin_m, chLatin_a, chLatin_t, chColon,
1642   chLatin_k, chLatin_e, chLatin_r, chLatin_b, chLatin_e, chLatin_r, chLatin_o, chLatin_s, chNull
1643 };
1644
1645 const XMLCh NameIDType::ENTITY[] = // urn:oasis:names:tc:SAML:2.0:nameid-format:entity
1646 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1647   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1648   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1649   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_i, chLatin_d, chDash,
1650   chLatin_f, chLatin_o, chLatin_r, chLatin_m, chLatin_a, chLatin_t, chColon,
1651   chLatin_e, chLatin_n, chLatin_t, chLatin_i, chLatin_t, chLatin_y, chNull
1652 };
1653
1654 const XMLCh NameIDType::PERSISTENT[] = // urn:oasis:names:tc:SAML:2.0:nameid-format:persistent
1655 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1656   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1657   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1658   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_i, chLatin_d, chDash,
1659   chLatin_f, chLatin_o, chLatin_r, chLatin_m, chLatin_a, chLatin_t, chColon,
1660   chLatin_p, chLatin_e, chLatin_r, chLatin_s, chLatin_i, chLatin_s, chLatin_t, chLatin_e, chLatin_n, chLatin_t, chNull
1661 };
1662
1663 const XMLCh NameIDType::TRANSIENT[] = // urn:oasis:names:tc:SAML:2.0:nameid-format:transient
1664 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1665   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1666   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1667   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_i, chLatin_d, chDash,
1668   chLatin_f, chLatin_o, chLatin_r, chLatin_m, chLatin_a, chLatin_t, chColon,
1669   chLatin_t, chLatin_r, chLatin_a, chLatin_n, chLatin_s, chLatin_i, chLatin_e, chLatin_n, chLatin_t, chNull
1670 };
1671
1672 const XMLCh SubjectConfirmation::BEARER[] = // urn:oasis:names:tc:SAML:2.0:cm:bearer
1673 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1674   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1675   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1676   chLatin_c, chLatin_m, chColon, chLatin_b, chLatin_e, chLatin_a, chLatin_r, chLatin_e, chLatin_r, chNull
1677 };
1678
1679 const XMLCh SubjectConfirmation::HOLDER_KEY[] = // urn:oasis:names:tc:SAML:2.0:cm:holder-of-key
1680 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1681   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1682   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1683   chLatin_c, chLatin_m, chColon, chLatin_h, chLatin_o, chLatin_l, chLatin_d, chLatin_e, chLatin_r, chDash,
1684       chLatin_o, chLatin_f, chDash, chLatin_k, chLatin_e, chLatin_y, chNull
1685 };
1686
1687 const XMLCh SubjectConfirmation::SENDER_VOUCHES[] = // urn:oasis:names:tc:SAML:2.0:cm:sender-vouches
1688 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1689   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1690   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1691   chLatin_c, chLatin_m, chColon, chLatin_s, chLatin_e, chLatin_n, chLatin_d, chLatin_e, chLatin_r, chDash,
1692       chLatin_v, chLatin_o, chLatin_u, chLatin_c, chLatin_h, chLatin_e, chLatin_s, chNull
1693 };
1694
1695 const XMLCh Action::RWEDC_ACTION_NAMESPACE[] = // urn:oasis:names:tc:SAML:1.0:action:rwedc
1696 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1697   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1698   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_1, chPeriod, chDigit_0, chColon,
1699   chLatin_a, chLatin_c, chLatin_t, chLatin_i, chLatin_o, chLatin_n, chColon,
1700   chLatin_r, chLatin_w, chLatin_e, chLatin_d, chLatin_c, chNull
1701 };
1702
1703 const XMLCh Action::RWEDC_NEG_ACTION_NAMESPACE[] = // urn:oasis:names:tc:SAML:1.0:action:rwedc-negation
1704 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1705   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1706   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_1, chPeriod, chDigit_0, chColon,
1707   chLatin_a, chLatin_c, chLatin_t, chLatin_i, chLatin_o, chLatin_n, chColon,
1708   chLatin_r, chLatin_w, chLatin_e, chLatin_d, chLatin_c, chDash,
1709   chLatin_n, chLatin_e, chLatin_g, chLatin_a, chLatin_t, chLatin_i, chLatin_o, chLatin_n, chNull
1710 };
1711
1712 const XMLCh Action::GHPP_ACTION_NAMESPACE[] = // urn:oasis:names:tc:SAML:1.0:action:ghpp
1713 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1714   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1715   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_1, chPeriod, chDigit_0, chColon,
1716   chLatin_a, chLatin_c, chLatin_t, chLatin_i, chLatin_o, chLatin_n, chColon,
1717   chLatin_g, chLatin_h, chLatin_p, chLatin_p, chNull
1718 };
1719
1720 const XMLCh Action::UNIX_ACTION_NAMESPACE[] = // urn:oasis:names:tc:SAML:1.0:action:unix
1721 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1722   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1723   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_1, chPeriod, chDigit_0, chColon,
1724   chLatin_a, chLatin_c, chLatin_t, chLatin_i, chLatin_o, chLatin_n, chColon,
1725   chLatin_u, chLatin_n, chLatin_i, chLatin_x, chNull
1726 };
1727
1728 const XMLCh Attribute::UNSPECIFIED[] = // urn:oasis:names:tc:SAML:2.0:attrname-format:unspecified
1729 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1730   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1731   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1732   chLatin_a, chLatin_t, chLatin_t, chLatin_r, chLatin_n, chLatin_a, chLatin_m, chLatin_e, chDash,
1733   chLatin_f, chLatin_o, chLatin_r, chLatin_m, chLatin_a, chLatin_t, chColon,
1734   chLatin_u, chLatin_n, chLatin_s, chLatin_p, chLatin_e, chLatin_c, chLatin_i, chLatin_f, chLatin_i, chLatin_e, chLatin_d, chNull
1735 };
1736
1737 const XMLCh Attribute::URI_REFERENCE[] = // urn:oasis:names:tc:SAML:2.0:attrname-format:uri
1738 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1739   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1740   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1741   chLatin_a, chLatin_t, chLatin_t, chLatin_r, chLatin_n, chLatin_a, chLatin_m, chLatin_e, chDash,
1742   chLatin_f, chLatin_o, chLatin_r, chLatin_m, chLatin_a, chLatin_t, chColon,
1743   chLatin_u, chLatin_r, chLatin_i, chNull
1744 };
1745
1746 const XMLCh Attribute::BASIC[] = // urn:oasis:names:tc:SAML:2.0:attrname-format:basic
1747 { chLatin_u, chLatin_r, chLatin_n, chColon, chLatin_o, chLatin_a, chLatin_s, chLatin_i, chLatin_s, chColon,
1748   chLatin_n, chLatin_a, chLatin_m, chLatin_e, chLatin_s, chColon, chLatin_t, chLatin_c, chColon,
1749   chLatin_S, chLatin_A, chLatin_M, chLatin_L, chColon, chDigit_2, chPeriod, chDigit_0, chColon,
1750   chLatin_a, chLatin_t, chLatin_t, chLatin_r, chLatin_n, chLatin_a, chLatin_m, chLatin_e, chDash,
1751   chLatin_f, chLatin_o, chLatin_r, chLatin_m, chLatin_a, chLatin_t, chColon,
1752   chLatin_b, chLatin_a, chLatin_s, chLatin_i, chLatin_c, chNull
1753 };