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