public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
+ void init() {
+ m_NotBefore=m_NotOnOrAfter=nullptr;
+ }
+
public:
virtual ~ConditionsImpl() {
delete m_NotBefore;
}
}
- void init() {
- m_NotBefore=m_NotOnOrAfter=nullptr;
- }
-
IMPL_XMLOBJECT_CLONE(Conditions);
IMPL_DATETIME_ATTRIB(NotBefore,0);
IMPL_DATETIME_ATTRIB(NotOnOrAfter,SAMLTIME_MAX);
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
+ void init() {
+ m_Format=m_NameQualifier=nullptr;
+ }
+
public:
virtual ~NameIdentifierImpl() {
XMLString::release(&m_Format);
setNameQualifier(src.getNameQualifier());
}
- void init() {
- m_Format=m_NameQualifier=nullptr;
- }
-
IMPL_XMLOBJECT_CLONE(NameIdentifier);
IMPL_STRING_ATTRIB(Format);
IMPL_STRING_ATTRIB(NameQualifier);
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
+ void init() {
+ m_SubjectConfirmationData=nullptr;
+ m_KeyInfo=nullptr;
+ m_children.push_back(nullptr);
+ m_children.push_back(nullptr);
+ m_pos_SubjectConfirmationData=m_children.begin();
+ m_pos_KeyInfo=m_pos_SubjectConfirmationData;
+ ++m_pos_KeyInfo;
+ }
+
public:
virtual ~SubjectConfirmationImpl() {}
setSubjectConfirmationData(src.getSubjectConfirmationData()->clone());
if (src.getKeyInfo())
setKeyInfo(src.getKeyInfo()->cloneKeyInfo());
- VectorOf(ConfirmationMethod) v=getConfirmationMethods();
for (vector<ConfirmationMethod*>::const_iterator i=src.m_ConfirmationMethods.begin(); i!=src.m_ConfirmationMethods.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneConfirmationMethod());
+ getConfirmationMethods().push_back((*i)->cloneConfirmationMethod());
}
}
}
- void init() {
- m_SubjectConfirmationData=nullptr;
- m_KeyInfo=nullptr;
- m_children.push_back(nullptr);
- m_children.push_back(nullptr);
- m_pos_SubjectConfirmationData=m_children.begin();
- m_pos_KeyInfo=m_pos_SubjectConfirmationData;
- ++m_pos_KeyInfo;
- }
-
IMPL_XMLOBJECT_CLONE(SubjectConfirmation);
IMPL_TYPED_CHILDREN(ConfirmationMethod,m_pos_SubjectConfirmationData);
IMPL_XMLOBJECT_CHILD(SubjectConfirmationData);
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
+ void init() {
+ m_NameIdentifier=nullptr;
+ m_SubjectConfirmation=nullptr;
+ m_children.push_back(nullptr);
+ m_children.push_back(nullptr);
+ m_pos_NameIdentifier=m_children.begin();
+ m_pos_SubjectConfirmation=m_pos_NameIdentifier;
+ ++m_pos_SubjectConfirmation;
+ }
+
public:
virtual ~SubjectImpl() {}
setSubjectConfirmation(src.getSubjectConfirmation()->cloneSubjectConfirmation());
}
- void init() {
- m_NameIdentifier=nullptr;
- m_SubjectConfirmation=nullptr;
- m_children.push_back(nullptr);
- m_children.push_back(nullptr);
- m_pos_NameIdentifier=m_children.begin();
- m_pos_SubjectConfirmation=m_pos_NameIdentifier;
- ++m_pos_SubjectConfirmation;
- }
-
IMPL_XMLOBJECT_CLONE(Subject);
IMPL_TYPED_CHILD(NameIdentifier);
IMPL_TYPED_CHILD(SubjectConfirmation);
m_children.push_back(nullptr);
m_pos_Subject=m_children.begin();
}
+
protected:
SubjectStatementImpl() {
init();
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
+ void init() {
+ m_IPAddress=m_DNSAddress=nullptr;
+ }
+
public:
virtual ~SubjectLocalityImpl() {
XMLString::release(&m_IPAddress);
setDNSAddress(src.getDNSAddress());
}
- void init() {
- m_IPAddress=m_DNSAddress=nullptr;
- }
-
IMPL_XMLOBJECT_CLONE(SubjectLocality);
IMPL_STRING_ATTRIB(IPAddress);
IMPL_STRING_ATTRIB(DNSAddress);
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
+ void init() {
+ m_AuthorityKind=nullptr;
+ m_Location=m_Binding=nullptr;
+ }
+
public:
virtual ~AuthorityBindingImpl() {
delete m_AuthorityKind;
setBinding(src.getBinding());
}
- void init() {
- m_AuthorityKind=nullptr;
- m_Location=m_Binding=nullptr;
- }
-
IMPL_XMLOBJECT_CLONE(AuthorityBinding);
IMPL_XMLOBJECT_ATTRIB(AuthorityKind,xmltooling::QName);
IMPL_STRING_ATTRIB(Location);
setAuthenticationInstant(src.getAuthenticationInstant());
if (src.getSubjectLocality())
setSubjectLocality(src.getSubjectLocality()->cloneSubjectLocality());
- VectorOf(AuthorityBinding) v=getAuthorityBindings();
for (vector<AuthorityBinding*>::const_iterator i=src.m_AuthorityBindings.begin(); i!=src.m_AuthorityBindings.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneAuthorityBinding());
+ getAuthorityBindings().push_back((*i)->cloneAuthorityBinding());
}
}
}
: AbstractXMLObject(nsURI, localName, prefix, schemaType), m_Namespace(nullptr) {
}
- ActionImpl(const ActionImpl& src) : AbstractXMLObject(src), AbstractSimpleElement(src), AbstractDOMCachingXMLObject(src) {
+ ActionImpl(const ActionImpl& src)
+ : AbstractXMLObject(src), AbstractSimpleElement(src), AbstractDOMCachingXMLObject(src), m_Namespace(nullptr) {
setNamespace(src.getNamespace());
}
setDecision(src.getDecision());
if (src.getEvidence())
setEvidence(src.getEvidence()->cloneEvidence());
- VectorOf(Action) v=getActions();
for (vector<Action*>::const_iterator i=src.m_Actions.begin(); i!=src.m_Actions.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneAction());
+ getActions().push_back((*i)->cloneAction());
}
}
}
init();
setAttributeName(src.getAttributeName());
setAttributeNamespace(src.getAttributeNamespace());
- VectorOf(XMLObject) v=getAttributeValues();
for (vector<XMLObject*>::const_iterator i=src.m_AttributeValues.begin(); i!=src.m_AttributeValues.end(); i++) {
if (*i) {
- v.push_back((*i)->clone());
+ getAttributeValues().push_back((*i)->clone());
}
}
}
void _clone(const AttributeStatementImpl& src) {
SubjectStatementImpl::_clone(src);
- VectorOf(Attribute) v=getAttributes();
for (vector<Attribute*>::const_iterator i=src.m_Attributes.begin(); i!=src.m_Attributes.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneAttribute());
+ getAttributes().push_back((*i)->cloneAttribute());
}
}
}
continue;
}
- getUnknownXMLObjects().push_back((*i)->clone());
+ if (*i) {
+ getUnknownXMLObjects().push_back((*i)->clone());
+ }
}
}
}
m_pos_Signature=m_pos_Advice;
++m_pos_Signature;
}
+
public:
virtual ~AssertionImpl() {
XMLString::release(&m_MinorVersion);
void _clone(const AttributeQueryImpl& src) {
SubjectQueryImpl::_clone(src);
setResource(src.getResource());
- VectorOf(AttributeDesignator) v=getAttributeDesignators();
for (vector<AttributeDesignator*>::const_iterator i=src.m_AttributeDesignators.begin(); i!=src.m_AttributeDesignators.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneAttributeDesignator());
+ getAttributeDesignators().push_back((*i)->cloneAttributeDesignator());
}
}
}
setResource(src.getResource());
if (src.getEvidence())
setEvidence(src.getEvidence()->cloneEvidence());
- VectorOf(Action) v=getActions();
for (vector<Action*>::const_iterator i=src.m_Actions.begin(); i!=src.m_Actions.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneAction());
+ getActions().push_back((*i)->cloneAction());
}
}
}
setIssueInstant(src.getIssueInstant());
if (src.getSignature())
setSignature(src.getSignature()->cloneSignature());
- VectorOf(RespondWith) v=getRespondWiths();
for (vector<RespondWith*>::const_iterator i=src.m_RespondWiths.begin(); i!=src.m_RespondWiths.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneRespondWith());
+ getRespondWiths().push_back((*i)->cloneRespondWith());
}
}
}
RequestAbstractTypeImpl::_clone(src);
if (src.getQuery())
setQuery(src.getQuery()->cloneQuery());
- VectorOf(AssertionIDReference) v=getAssertionIDReferences();
for (vector<AssertionIDReference*>::const_iterator i=src.m_AssertionIDReferences.begin(); i!=src.m_AssertionIDReferences.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneAssertionIDReference());
+ getAssertionIDReferences().push_back((*i)->cloneAssertionIDReference());
}
}
- VectorOf(AssertionArtifact) v2=getAssertionArtifacts();
for (vector<AssertionArtifact*>::const_iterator i=src.m_AssertionArtifacts.begin(); i!=src.m_AssertionArtifacts.end(); i++) {
if (*i) {
- v2.push_back((*i)->cloneAssertionArtifact());
+ getAssertionArtifacts().push_back((*i)->cloneAssertionArtifact());
}
}
}
m_StatusCode=nullptr;
m_pos_StatusCode=m_children.begin();
}
+
public:
virtual ~StatusCodeImpl() {
delete m_Value;
StatusDetailImpl(const StatusDetailImpl& src)
: AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
- VectorOf(XMLObject) v=getUnknownXMLObjects();
- for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i)
- v.push_back((*i)->clone());
+ for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i) {
+ if (*i) {
+ getUnknownXMLObjects().push_back((*i)->clone());
+ }
+ }
}
IMPL_XMLOBJECT_CLONE(StatusDetail);
m_pos_StatusDetail=m_pos_StatusMessage;
++m_pos_StatusDetail;
}
+
public:
virtual ~StatusImpl() {}
ResponseAbstractTypeImpl::_clone(src);
if (src.getStatus())
setStatus(src.getStatus()->cloneStatus());
- VectorOf(saml1::Assertion) v=getAssertions();
for (vector<saml1::Assertion*>::const_iterator i=src.m_Assertions.begin(); i!=src.m_Assertions.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneAssertion());
+ getAssertions().push_back((*i)->cloneAssertion());
}
}
}
void _clone(const EncryptedElementTypeImpl& src) {
if (src.getEncryptedData())
setEncryptedData(src.getEncryptedData()->cloneEncryptedData());
- VectorOf(EncryptedKey) v=getEncryptedKeys();
for (vector<EncryptedKey*>::const_iterator i=src.m_EncryptedKeys.begin(); i!=src.m_EncryptedKeys.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneEncryptedKey());
+ getEncryptedKeys().push_back((*i)->cloneEncryptedKey());
}
}
}
AudienceRestrictionImpl(const AudienceRestrictionImpl& src)
: AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
- VectorOf(Audience) v=getAudiences();
for (vector<Audience*>::const_iterator i=src.m_Audiences.begin(); i!=src.m_Audiences.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneAudience());
+ getAudiences().push_back((*i)->cloneAudience());
}
}
}
}
ProxyRestrictionImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
- : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
- m_Count=nullptr;
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType), m_Count(nullptr) {
}
ProxyRestrictionImpl(const ProxyRestrictionImpl& src)
- : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
+ : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src), m_Count(nullptr) {
setCount(src.m_Count);
- VectorOf(Audience) v=getAudiences();
for (vector<Audience*>::const_iterator i=src.m_Audiences.begin(); i!=src.m_Audiences.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneAudience());
+ getAudiences().push_back((*i)->cloneAudience());
}
}
}
m_pos_EncryptedID=m_pos_NameID;
++m_pos_EncryptedID;
}
+
public:
virtual ~DelegateImpl() {
XMLString::release(&m_ConfirmationMethod);
DelegationRestrictionTypeImpl(const DelegationRestrictionTypeImpl& src)
: AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
- VectorOf(Delegate) v=getDelegates();
for (vector<Delegate*>::const_iterator i=src.m_Delegates.begin(); i!=src.m_Delegates.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneDelegate());
+ getDelegates().push_back((*i)->cloneDelegate());
}
}
}
void init() {
m_NotBefore=m_NotOnOrAfter=nullptr;
}
+
public:
virtual ~ConditionsImpl() {
delete m_NotBefore;
virtual ~SubjectConfirmationDataImpl() {}
SubjectConfirmationDataImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
- : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
}
SubjectConfirmationDataImpl(const SubjectConfirmationDataImpl& src)
- : AbstractXMLObject(src), SubjectConfirmationDataTypeImpl(src), AnyElementImpl(src) {
+ : AbstractXMLObject(src), SubjectConfirmationDataTypeImpl(src), AnyElementImpl(src) {
}
void _clone(const SubjectConfirmationDataImpl& src) {
virtual ~KeyInfoConfirmationDataTypeImpl() {}
KeyInfoConfirmationDataTypeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
- : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
}
KeyInfoConfirmationDataTypeImpl(const KeyInfoConfirmationDataTypeImpl& src)
- : AbstractXMLObject(src), SubjectConfirmationDataTypeImpl(src), AbstractComplexElement(src),
- AbstractAttributeExtensibleXMLObject(src), AbstractDOMCachingXMLObject(src) {
+ : AbstractXMLObject(src), SubjectConfirmationDataTypeImpl(src), AbstractComplexElement(src),
+ AbstractAttributeExtensibleXMLObject(src), AbstractDOMCachingXMLObject(src) {
}
void _clone(const KeyInfoConfirmationDataTypeImpl& src) {
SubjectConfirmationDataTypeImpl::_clone(src);
- VectorOf(KeyInfo) v=getKeyInfos();
- for (vector<KeyInfo*>::const_iterator i=src.m_KeyInfos.begin(); i!=src.m_KeyInfos.end(); ++i)
- v.push_back((*i)->cloneKeyInfo());
+ for (vector<KeyInfo*>::const_iterator i=src.m_KeyInfos.begin(); i!=src.m_KeyInfos.end(); ++i) {
+ if (*i) {
+ getKeyInfos().push_back((*i)->cloneKeyInfo());
+ }
+ }
}
IMPL_XMLOBJECT_CLONE_EX(KeyInfoConfirmationDataType);
m_pos_SubjectConfirmationData=m_pos_EncryptedID;
++m_pos_SubjectConfirmationData;
}
+
public:
virtual ~SubjectConfirmationImpl() {
XMLString::release(&m_Method);
m_pos_EncryptedID=m_pos_NameID;
++m_pos_EncryptedID;
}
+
public:
virtual ~SubjectImpl() {}
setNameID(src.getNameID()->cloneNameID());
if (src.getEncryptedID())
setEncryptedID(src.getEncryptedID()->cloneEncryptedID());
- VectorOf(SubjectConfirmation) v=getSubjectConfirmations();
for (vector<SubjectConfirmation*>::const_iterator i=src.m_SubjectConfirmations.begin(); i!=src.m_SubjectConfirmations.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneSubjectConfirmation());
+ getSubjectConfirmations().push_back((*i)->cloneSubjectConfirmation());
}
}
}
void init() {
m_Address=m_DNSName=nullptr;
}
+
public:
virtual ~SubjectLocalityImpl() {
XMLString::release(&m_Address);
m_pos_AuthnContextDeclRef=m_pos_AuthnContextDecl;
++m_pos_AuthnContextDeclRef;
}
+
public:
virtual ~AuthnContextImpl() {}
setAuthnContextDecl(src.getAuthnContextDecl()->clone());
if (src.getAuthnContextDeclRef())
setAuthnContextDeclRef(src.getAuthnContextDeclRef()->cloneAuthnContextDeclRef());
- VectorOf(AuthenticatingAuthority) v=getAuthenticatingAuthoritys();
for (vector<AuthenticatingAuthority*>::const_iterator i=src.m_AuthenticatingAuthoritys.begin(); i!=src.m_AuthenticatingAuthoritys.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneAuthenticatingAuthority());
+ getAuthenticatingAuthoritys().push_back((*i)->cloneAuthenticatingAuthority());
}
}
}
m_pos_AuthnContext=m_pos_SubjectLocality;
++m_pos_AuthnContext;
}
+
public:
virtual ~AuthnStatementImpl() {
delete m_AuthnInstant;
}
ActionImpl(const ActionImpl& src)
- : AbstractXMLObject(src), AbstractSimpleElement(src), AbstractDOMCachingXMLObject(src) {
+ : AbstractXMLObject(src), AbstractSimpleElement(src), AbstractDOMCachingXMLObject(src), m_Namespace(nullptr) {
setNamespace(src.getNamespace());
}
m_children.push_back(nullptr);
m_pos_Evidence=m_children.begin();
}
+
public:
virtual ~AuthzDecisionStatementImpl() {
XMLString::release(&m_Resource);
setDecision(src.getDecision());
if (src.getEvidence())
setEvidence(src.getEvidence()->cloneEvidence());
- VectorOf(Action) v=getActions();
for (vector<Action*>::const_iterator i=src.m_Actions.begin(); i!=src.m_Actions.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneAction());
+ getActions().push_back((*i)->cloneAction());
}
}
}
void init() {
m_Name=m_NameFormat=m_FriendlyName=nullptr;
}
+
public:
virtual ~AttributeImpl() {
XMLString::release(&m_Name);
setName(src.getName());
setNameFormat(src.getNameFormat());
setFriendlyName(src.getFriendlyName());
- VectorOf(XMLObject) v=getAttributeValues();
for (vector<XMLObject*>::const_iterator i=src.m_AttributeValues.begin(); i!=src.m_AttributeValues.end(); i++) {
if (*i) {
- v.push_back((*i)->clone());
+ getAttributeValues().push_back((*i)->clone());
}
}
}
continue;
}
- getUnknownXMLObjects().push_back((*i)->clone());
+ if (*i) {
+ getUnknownXMLObjects().push_back((*i)->clone());
+ }
}
}
}
m_pos_Advice=m_pos_Conditions;
++m_pos_Advice;
}
+
public:
virtual ~AssertionImpl() {
XMLString::release(&m_ID);
ExtensionsImpl(const ExtensionsImpl& src)
: AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
- VectorOf(XMLObject) v=getUnknownXMLObjects();
- for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i)
- v.push_back((*i)->clone());
+ for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i) {
+ if (*i) {
+ getUnknownXMLObjects().push_back((*i)->clone());
+ }
+ }
}
IMPL_XMLOBJECT_CLONE(Extensions);
m_children.push_back(nullptr);
m_pos_StatusCode=m_children.begin();
}
+
public:
virtual ~StatusCodeImpl() {
XMLString::release(&m_Value);
}
StatusCodeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
- : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
- init();
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
+ init();
}
StatusCodeImpl(const StatusCodeImpl& src)
StatusDetailImpl(const StatusDetailImpl& src)
: AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
- VectorOf(XMLObject) v=getUnknownXMLObjects();
- for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i)
- v.push_back((*i)->clone());
+ for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i) {
+ if (*i) {
+ getUnknownXMLObjects().push_back((*i)->clone());
+ }
+ }
}
IMPL_XMLOBJECT_CLONE(StatusDetail);
m_pos_StatusDetail=m_pos_StatusMessage;
++m_pos_StatusDetail;
}
+
public:
virtual ~StatusImpl() { }
init();
}
- StatusImpl(const StatusImpl& src)
- : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
+ StatusImpl(const StatusImpl& src) : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
init();
if (src.getStatusCode())
setStatusCode(src.getStatusCode()->cloneStatusCode());
m_pos_Extensions=m_pos_Signature;
++m_pos_Extensions;
}
+
protected:
RequestAbstractTypeImpl() {
init();
}
+
public:
virtual ~RequestAbstractTypeImpl() {
XMLString::release(&m_ID);
void _clone(const AssertionIDRequestImpl& src) {
RequestAbstractTypeImpl::_clone(src);
- VectorOf(AssertionIDRef) v=getAssertionIDRefs();
for (vector<AssertionIDRef*>::const_iterator i=src.m_AssertionIDRefs.begin(); i!=src.m_AssertionIDRefs.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneAssertionIDRef());
+ getAssertionIDRefs().push_back((*i)->cloneAssertionIDRef());
}
}
}
m_pos_Subject = m_pos_Extensions;
++m_pos_Subject;
}
+
protected:
SubjectQueryImpl() {
init();
}
+
public:
virtual ~SubjectQueryImpl() { }
void init() {
m_Comparison=nullptr;
}
+
public:
virtual ~RequestedAuthnContextImpl() {
XMLString::release(&m_Comparison);
++m_pos_RequestedAuthnContext;
}
+
public:
virtual ~AuthnQueryImpl() {
XMLString::release(&m_SessionIndex);
m_Evidence=nullptr;
m_children.push_back(nullptr);
m_pos_Evidence=m_pos_Subject;
- ++m_pos_Evidence;
-
+ ++m_pos_Evidence;
}
+
public:
virtual ~AuthzDecisionQueryImpl() {
XMLString::release(&m_Resource);
m_SPNameQualifier=nullptr;
m_AllowCreate=XML_BOOL_NULL;
}
+
public:
- virtual ~NameIDPolicyImpl()
- {
+ virtual ~NameIDPolicyImpl() {
XMLString::release(&m_Format);
XMLString::release(&m_SPNameQualifier);
}
NameIDPolicyImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
- : AbstractXMLObject(nsURI, localName, prefix, schemaType)
- {
- init();
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
+ init();
}
NameIDPolicyImpl(const NameIDPolicyImpl& src)
init();
setFormat(src.getFormat());
setSPNameQualifier(src.getSPNameQualifier());
- AllowCreate(m_AllowCreate);
+ AllowCreate(src.m_AllowCreate);
}
IMPL_XMLOBJECT_CLONE(NameIDPolicy);
m_Name=nullptr;
m_Loc=nullptr;
}
+
public:
- virtual ~IDPEntryImpl()
- {
+ virtual ~IDPEntryImpl() {
XMLString::release(&m_ProviderID);
XMLString::release(&m_Name);
XMLString::release(&m_Loc);
}
IDPEntryImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
- : AbstractXMLObject(nsURI, localName, prefix, schemaType)
- {
- init();
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
+ init();
}
- IDPEntryImpl(const IDPEntryImpl& src)
- : AbstractXMLObject(src), AbstractSimpleElement(src), AbstractDOMCachingXMLObject(src) {
+ IDPEntryImpl(const IDPEntryImpl& src) : AbstractXMLObject(src), AbstractSimpleElement(src), AbstractDOMCachingXMLObject(src) {
init();
setProviderID(src.getProviderID());
setName(src.getName());
m_GetComplete=nullptr;
m_children.push_back(nullptr);
m_pos_GetComplete=m_children.begin();
-
}
+
public:
virtual ~IDPListImpl() { }
IDPListImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
- : AbstractXMLObject(nsURI, localName, prefix, schemaType)
- {
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
init();
}
init();
if (src.getGetComplete())
setGetComplete(src.getGetComplete()->cloneGetComplete());
- for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
+ for (vector<IDPEntry*>::const_iterator i=src.m_IDPEntrys.begin(); i!=src.m_IDPEntrys.end(); ++i) {
if (*i) {
- IDPEntry* entry=dynamic_cast<IDPEntry*>(*i);
- if (entry) {
- getIDPEntrys().push_back(entry->cloneIDPEntry());
- continue;
- }
+ getIDPEntrys().push_back((*i)->cloneIDPEntry());
}
}
}
m_IDPList=nullptr;
m_children.push_back(nullptr);
m_pos_IDPList=m_children.begin();
-
}
+
public:
virtual ~ScopingImpl() {
XMLString::release(&m_ProxyCount);
}
ScopingImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
- : AbstractXMLObject(nsURI, localName, prefix, schemaType)
- {
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
init();
}
ScopingImpl(const ScopingImpl& src)
: AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
init();
- setProxyCount(m_ProxyCount);
+ setProxyCount(src.m_ProxyCount);
if (src.getIDPList())
setIDPList(src.getIDPList()->cloneIDPList());
- for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
+ for (vector<RequesterID*>::const_iterator i=src.m_RequesterIDs.begin(); i!=src.m_RequesterIDs.end(); ++i) {
if (*i) {
- RequesterID* reqid =dynamic_cast<RequesterID*>(*i);
- if (reqid) {
- getRequesterIDs().push_back(reqid->cloneRequesterID());
- continue;
- }
+ getRequesterIDs().push_back((*i)->cloneRequesterID());
}
}
}
protected:
void marshallAttributes(DOMElement* domElement) const {
- MARSHALL_INTEGER_ATTRIB(ProxyCount,PROXYCOUNT,nullptr);
+ MARSHALL_INTEGER_ATTRIB(ProxyCount,PROXYCOUNT,nullptr);
}
void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
++m_pos_RequestedAuthnContext;
m_pos_Scoping=m_pos_RequestedAuthnContext;
++m_pos_Scoping;
-
}
+
public:
virtual ~AuthnRequestImpl() {
XMLString::release(&m_ProtocolBinding);
void _clone(const AuthnRequestImpl& src) {
RequestAbstractTypeImpl::_clone(src);
- ForceAuthn(m_ForceAuthn);
- IsPassive(m_IsPassive);
+ ForceAuthn(src.m_ForceAuthn);
+ IsPassive(src.m_IsPassive);
setProtocolBinding(src.getProtocolBinding());
- setAssertionConsumerServiceIndex(m_AssertionConsumerServiceIndex);
+ setAssertionConsumerServiceIndex(src.m_AssertionConsumerServiceIndex);
setAssertionConsumerServiceURL(src.getAssertionConsumerServiceURL());
- setAttributeConsumingServiceIndex(m_AttributeConsumingServiceIndex);
+ setAttributeConsumingServiceIndex(src.m_AttributeConsumingServiceIndex);
setProviderName(src.getProviderName());
if (src.getSubject())
setSubject(src.getSubject()->cloneSubject());
m_pos_Status=m_pos_Extensions;
++m_pos_Status;
}
+
protected:
StatusResponseTypeImpl() {
init();
}
+
public:
virtual ~StatusResponseTypeImpl() {
XMLString::release(&m_ID);
}
StatusResponseTypeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
- : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
init();
}
}
IMPL_XMLOBJECT_CLONE_EX(Response);
-
IMPL_TYPED_FOREIGN_CHILDREN(Assertion,saml2,m_children.end());
IMPL_TYPED_FOREIGN_CHILDREN(EncryptedAssertion,saml2,m_children.end());
m_pos_Artifact=m_pos_Extensions;
++m_pos_Artifact;
}
+
public:
virtual ~ArtifactResolveImpl() { }
m_pos_Payload=m_pos_Status;
++m_pos_Payload;
}
+
public:
virtual ~ArtifactResponseImpl() { }
void _clone(const ArtifactResponseImpl& src) {
StatusResponseTypeImpl::_clone(src);
if (src.getPayload())
- setPayload(getPayload()->clone());
+ setPayload(src.getPayload()->clone());
}
IMPL_XMLOBJECT_CLONE_EX(ArtifactResponse);
init();
if (src.getEncryptedData())
setEncryptedData(src.getEncryptedData()->cloneEncryptedData());
- VectorOf(xmlencryption::EncryptedKey) v=getEncryptedKeys();
for (vector<xmlencryption::EncryptedKey*>::const_iterator i=src.m_EncryptedKeys.begin(); i!=src.m_EncryptedKeys.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneEncryptedKey());
+ getEncryptedKeys().push_back((*i)->cloneEncryptedKey());
}
}
}
- IMPL_XMLOBJECT_CLONE(NewEncryptedID);
- EncryptedElementType* cloneEncryptedElementType() const {
- return cloneNewEncryptedID();
- }
-
+ IMPL_XMLOBJECT_CLONE2(NewEncryptedID,EncryptedElementType);
IMPL_TYPED_FOREIGN_CHILD(EncryptedData,xmlencryption);
IMPL_TYPED_FOREIGN_CHILDREN(EncryptedKey,xmlencryption,m_children.end());
++m_pos_NewEncryptedID;
m_pos_Terminate=m_pos_NewEncryptedID;
++m_pos_Terminate;
-
}
+
public:
virtual ~ManageNameIDRequestImpl() { }
++m_pos_NameID;
m_pos_EncryptedID=m_pos_NameID;
++m_pos_EncryptedID;
-
}
+
public:
virtual ~LogoutRequestImpl() {
XMLString::release(&m_Reason);
if (src.getEncryptedID())
setEncryptedID(src.getEncryptedID()->cloneEncryptedID());
- for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
+ for (vector<SessionIndex*>::const_iterator i=src.m_SessionIndexs.begin(); i!=src.m_SessionIndexs.end(); ++i) {
if (*i) {
- SessionIndex* si = dynamic_cast<SessionIndex*>(*i);
- if (si) {
- getSessionIndexs().push_back(si->cloneSessionIndex());
- continue;
- }
+ getSessionIndexs().push_back((*i)->cloneSessionIndex());
}
}
}
++m_pos_EncryptedID;
m_pos_NameIDPolicy=m_pos_EncryptedID;
++m_pos_NameIDPolicy;
-
}
+
public:
virtual ~NameIDMappingRequestImpl() { }
m_pos_EncryptedID=m_pos_NameID;
++m_pos_EncryptedID;
}
+
public:
virtual ~NameIDMappingResponseImpl() { }
void _clone(const NameIDMappingResponseImpl& src) {
StatusResponseTypeImpl::_clone(src);
if (src.getNameID())
- setNameID(getNameID()->cloneNameID());
+ setNameID(src.getNameID()->cloneNameID());
if (src.getEncryptedID())
- setEncryptedID(getEncryptedID()->cloneEncryptedID());
+ setEncryptedID(src.getEncryptedID()->cloneEncryptedID());
}
IMPL_XMLOBJECT_CLONE_EX(NameIDMappingResponse);
ExtensionsImpl(const ExtensionsImpl& src)
: AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
- VectorOf(XMLObject) v=getUnknownXMLObjects();
- for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i)
- v.push_back((*i)->clone());
+ for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i) {
+ if (*i) {
+ getUnknownXMLObjects().push_back((*i)->clone());
+ }
+ }
}
IMPL_XMLOBJECT_CLONE(Extensions);
m_pos_OrganizationURL=m_pos_OrganizationDisplayName;
++m_pos_OrganizationURL;
}
+
public:
virtual ~OrganizationImpl() {}
init();
if (src.getExtensions())
setExtensions(src.getExtensions()->cloneExtensions());
- VectorOf(OrganizationName) v=getOrganizationNames();
for (vector<OrganizationName*>::const_iterator i=src.m_OrganizationNames.begin(); i!=src.m_OrganizationNames.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneOrganizationName());
+ getOrganizationNames().push_back((*i)->cloneOrganizationName());
}
}
- VectorOf(OrganizationDisplayName) w=getOrganizationDisplayNames();
for (vector<OrganizationDisplayName*>::const_iterator j=src.m_OrganizationDisplayNames.begin(); j!=src.m_OrganizationDisplayNames.end(); j++) {
if (*j) {
- w.push_back((*j)->cloneOrganizationDisplayName());
+ getOrganizationDisplayNames().push_back((*j)->cloneOrganizationDisplayName());
}
}
- VectorOf(OrganizationURL) x=getOrganizationURLs();
for (vector<OrganizationURL*>::const_iterator k=src.m_OrganizationURLs.begin(); k!=src.m_OrganizationURLs.end(); k++) {
if (*k) {
- x.push_back((*k)->cloneOrganizationURL());
+ getOrganizationURLs().push_back((*k)->cloneOrganizationURL());
}
}
}
m_pos_TelephoneNumber=m_pos_SurName;
++m_pos_TelephoneNumber;
}
+
public:
virtual ~ContactPersonImpl() {
XMLString::release(&m_ContactType);
if (src.getSurName())
setSurName(src.getSurName()->cloneSurName());
- VectorOf(EmailAddress) v=getEmailAddresss();
for (vector<EmailAddress*>::const_iterator i=src.m_EmailAddresss.begin(); i!=src.m_EmailAddresss.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneEmailAddress());
+ getEmailAddresss().push_back((*i)->cloneEmailAddress());
}
}
- VectorOf(TelephoneNumber) w=getTelephoneNumbers();
for (vector<TelephoneNumber*>::const_iterator j=src.m_TelephoneNumbers.begin(); j!=src.m_TelephoneNumbers.end(); j++) {
if (*j) {
- w.push_back((*j)->cloneTelephoneNumber());
+ getTelephoneNumbers().push_back((*j)->cloneTelephoneNumber());
}
}
}
AdditionalMetadataLocationImpl(const AdditionalMetadataLocationImpl& src)
: AbstractXMLObject(src), AbstractSimpleElement(src), AbstractDOMCachingXMLObject(src) {
init();
+ setNamespace(src.getNamespace());
}
IMPL_XMLOBJECT_CLONE(AdditionalMetadataLocation);
m_children.push_back(nullptr);
m_pos_KeyInfo=m_children.begin();
}
+
public:
virtual ~KeyDescriptorImpl() {
XMLString::release(&m_Use);
setUse(src.getUse());
if (src.getKeyInfo())
setKeyInfo(src.getKeyInfo()->cloneKeyInfo());
- VectorOf(EncryptionMethod) v=getEncryptionMethods();
for (vector<EncryptionMethod*>::const_iterator i=src.m_EncryptionMethods.begin(); i!=src.m_EncryptionMethods.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneEncryptionMethod());
+ getEncryptionMethods().push_back((*i)->cloneEncryptionMethod());
}
}
}
setBinding(src.getBinding());
setLocation(src.getLocation());
setResponseLocation(src.getResponseLocation());
- VectorOf(XMLObject) v=getUnknownXMLObjects();
- for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i)
- v.push_back((*i)->clone());
+ for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i) {
+ if (*i) {
+ getUnknownXMLObjects().push_back((*i)->clone());
+ }
+ }
}
IMPL_XMLOBJECT_CLONE_EX(EndpointType);
if (src.getOrganization())
setOrganization(src.getOrganization()->cloneOrganization());
- VectorOf(KeyDescriptor) v=getKeyDescriptors();
for (vector<KeyDescriptor*>::const_iterator i=src.m_KeyDescriptors.begin(); i!=src.m_KeyDescriptors.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneKeyDescriptor());
+ getKeyDescriptors().push_back((*i)->cloneKeyDescriptor());
}
}
- VectorOf(ContactPerson) w=getContactPersons();
for (vector<ContactPerson*>::const_iterator j=src.m_ContactPersons.begin(); j!=src.m_ContactPersons.end(); j++) {
if (*j) {
- w.push_back((*j)->cloneContactPerson());
+ getContactPersons().push_back((*j)->cloneContactPerson());
}
}
}
void _clone(const RoleDescriptorTypeImpl& src) {
RoleDescriptorImpl::_clone(src);
- VectorOf(XMLObject) v=getUnknownXMLObjects();
- for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i)
- v.push_back((*i)->clone());
+ for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i) {
+ if (*i) {
+ getUnknownXMLObjects().push_back((*i)->clone());
+ }
+ }
}
IMPL_XMLOBJECT_CLONE_EX(RoleDescriptorType);
void _clone(const SSODescriptorTypeImpl& src) {
RoleDescriptorImpl::_clone(src);
- VectorOf(ArtifactResolutionService) v=getArtifactResolutionServices();
for (vector<ArtifactResolutionService*>::const_iterator i=src.m_ArtifactResolutionServices.begin(); i!=src.m_ArtifactResolutionServices.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneArtifactResolutionService());
+ getArtifactResolutionServices().push_back((*i)->cloneArtifactResolutionService());
}
}
- VectorOf(SingleLogoutService) w=getSingleLogoutServices();
for (vector<SingleLogoutService*>::const_iterator j=src.m_SingleLogoutServices.begin(); j!=src.m_SingleLogoutServices.end(); j++) {
if (*j) {
- w.push_back((*j)->cloneSingleLogoutService());
+ getSingleLogoutServices().push_back((*j)->cloneSingleLogoutService());
}
}
- VectorOf(ManageNameIDService) x=getManageNameIDServices();
for (vector<ManageNameIDService*>::const_iterator k=src.m_ManageNameIDServices.begin(); k!=src.m_ManageNameIDServices.end(); k++) {
if (*k) {
- x.push_back((*k)->cloneManageNameIDService());
+ getManageNameIDServices().push_back((*k)->cloneManageNameIDService());
}
}
- VectorOf(NameIDFormat) y=getNameIDFormats();
for (vector<NameIDFormat*>::const_iterator m=src.m_NameIDFormats.begin(); m!=src.m_NameIDFormats.end(); m++) {
if (*m) {
- y.push_back((*m)->cloneNameIDFormat());
+ getNameIDFormats().push_back((*m)->cloneNameIDFormat());
}
}
}
void _clone(const IDPSSODescriptorImpl& src) {
SSODescriptorTypeImpl::_clone(src);
WantAuthnRequestsSigned(src.m_WantAuthnRequestsSigned);
- VectorOf(SingleSignOnService) v=getSingleSignOnServices();
for (vector<SingleSignOnService*>::const_iterator i=src.m_SingleSignOnServices.begin(); i!=src.m_SingleSignOnServices.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneSingleSignOnService());
+ getSingleSignOnServices().push_back((*i)->cloneSingleSignOnService());
}
}
- VectorOf(NameIDMappingService) w=getNameIDMappingServices();
for (vector<NameIDMappingService*>::const_iterator j=src.m_NameIDMappingServices.begin(); j!=src.m_NameIDMappingServices.end(); j++) {
if (*j) {
- w.push_back((*j)->cloneNameIDMappingService());
+ getNameIDMappingServices().push_back((*j)->cloneNameIDMappingService());
}
}
- VectorOf(AssertionIDRequestService) x=getAssertionIDRequestServices();
for (vector<AssertionIDRequestService*>::const_iterator k=src.m_AssertionIDRequestServices.begin(); k!=src.m_AssertionIDRequestServices.end(); k++) {
if (*k) {
- x.push_back((*k)->cloneAssertionIDRequestService());
+ getAssertionIDRequestServices().push_back((*k)->cloneAssertionIDRequestService());
}
}
- VectorOf(AttributeProfile) y=getAttributeProfiles();
for (vector<AttributeProfile*>::const_iterator m=src.m_AttributeProfiles.begin(); m!=src.m_AttributeProfiles.end(); m++) {
if (*m) {
- y.push_back((*m)->cloneAttributeProfile());
+ getAttributeProfiles().push_back((*m)->cloneAttributeProfile());
}
}
- VectorOf(Attribute) z=getAttributes();
for (vector<Attribute*>::const_iterator n=src.m_Attributes.begin(); n!=src.m_Attributes.end(); n++) {
if (*n) {
- z.push_back((*n)->cloneAttribute());
+ getAttributes().push_back((*n)->cloneAttribute());
}
}
}
m_Name=m_NameFormat=m_FriendlyName=nullptr;
m_isRequired=XML_BOOL_NULL;
}
+
public:
virtual ~RequestedAttributeImpl() {
XMLString::release(&m_Name);
setNameFormat(src.getNameFormat());
setFriendlyName(src.getFriendlyName());
isRequired(src.m_isRequired);
- VectorOf(XMLObject) v=getAttributeValues();
for (vector<XMLObject*>::const_iterator i=src.m_AttributeValues.begin(); i!=src.m_AttributeValues.end(); i++) {
if (*i) {
- v.push_back((*i)->clone());
+ getAttributeValues().push_back((*i)->clone());
}
}
}
init();
setIndex(src.m_Index);
isDefault(src.m_isDefault);
- VectorOf(ServiceName) v=getServiceNames();
for (vector<ServiceName*>::const_iterator i=src.m_ServiceNames.begin(); i!=src.m_ServiceNames.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneServiceName());
+ getServiceNames().push_back((*i)->cloneServiceName());
}
}
- VectorOf(ServiceDescription) w=getServiceDescriptions();
for (vector<ServiceDescription*>::const_iterator j=src.m_ServiceDescriptions.begin(); j!=src.m_ServiceDescriptions.end(); j++) {
if (*j) {
- w.push_back((*j)->cloneServiceDescription());
+ getServiceDescriptions().push_back((*j)->cloneServiceDescription());
}
}
- VectorOf(RequestedAttribute) x=getRequestedAttributes();
for (vector<RequestedAttribute*>::const_iterator k=src.m_RequestedAttributes.begin(); k!=src.m_RequestedAttributes.end(); k++) {
if (*k) {
- x.push_back((*k)->cloneRequestedAttribute());
+ getRequestedAttributes().push_back((*k)->cloneRequestedAttribute());
}
}
}
SSODescriptorTypeImpl::_clone(src);
AuthnRequestsSigned(src.m_AuthnRequestsSigned);
WantAssertionsSigned(src.m_WantAssertionsSigned);
- VectorOf(AssertionConsumerService) v=getAssertionConsumerServices();
for (vector<AssertionConsumerService*>::const_iterator i=src.m_AssertionConsumerServices.begin(); i!=src.m_AssertionConsumerServices.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneAssertionConsumerService());
+ getAssertionConsumerServices().push_back((*i)->cloneAssertionConsumerService());
}
}
- VectorOf(AttributeConsumingService) w=getAttributeConsumingServices();
for (vector<AttributeConsumingService*>::const_iterator j=src.m_AttributeConsumingServices.begin(); j!=src.m_AttributeConsumingServices.end(); j++) {
if (*j) {
- w.push_back((*j)->cloneAttributeConsumingService());
+ getAttributeConsumingServices().push_back((*j)->cloneAttributeConsumingService());
}
}
}
void _clone(const AuthnAuthorityDescriptorImpl& src) {
RoleDescriptorImpl::_clone(src);
- VectorOf(AuthnQueryService) v=getAuthnQueryServices();
for (vector<AuthnQueryService*>::const_iterator i=src.m_AuthnQueryServices.begin(); i!=src.m_AuthnQueryServices.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneAuthnQueryService());
+ getAuthnQueryServices().push_back((*i)->cloneAuthnQueryService());
}
}
- VectorOf(AssertionIDRequestService) w=getAssertionIDRequestServices();
for (vector<AssertionIDRequestService*>::const_iterator j=src.m_AssertionIDRequestServices.begin(); j!=src.m_AssertionIDRequestServices.end(); j++) {
if (*j) {
- w.push_back((*j)->cloneAssertionIDRequestService());
+ getAssertionIDRequestServices().push_back((*j)->cloneAssertionIDRequestService());
}
}
- VectorOf(NameIDFormat) x=getNameIDFormats();
for (vector<NameIDFormat*>::const_iterator k=src.m_NameIDFormats.begin(); k!=src.m_NameIDFormats.end(); k++) {
if (*k) {
- x.push_back((*k)->cloneNameIDFormat());
+ getNameIDFormats().push_back((*k)->cloneNameIDFormat());
}
}
}
void _clone(const PDPDescriptorImpl& src) {
RoleDescriptorImpl::_clone(src);
- VectorOf(AuthzService) v=getAuthzServices();
for (vector<AuthzService*>::const_iterator i=src.m_AuthzServices.begin(); i!=src.m_AuthzServices.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneAuthzService());
+ getAuthzServices().push_back((*i)->cloneAuthzService());
}
}
- VectorOf(AssertionIDRequestService) w=getAssertionIDRequestServices();
for (vector<AssertionIDRequestService*>::const_iterator j=src.m_AssertionIDRequestServices.begin(); j!=src.m_AssertionIDRequestServices.end(); j++) {
if (*j) {
- w.push_back((*j)->cloneAssertionIDRequestService());
+ getAssertionIDRequestServices().push_back((*j)->cloneAssertionIDRequestService());
}
}
- VectorOf(NameIDFormat) x=getNameIDFormats();
for (vector<NameIDFormat*>::const_iterator k=src.m_NameIDFormats.begin(); k!=src.m_NameIDFormats.end(); k++) {
if (*k) {
- x.push_back((*k)->cloneNameIDFormat());
+ getNameIDFormats().push_back((*k)->cloneNameIDFormat());
}
}
}
void _clone(const AttributeAuthorityDescriptorImpl& src) {
RoleDescriptorImpl::_clone(src);
- VectorOf(AttributeService) v=getAttributeServices();
for (vector<AttributeService*>::const_iterator i=src.m_AttributeServices.begin(); i!=src.m_AttributeServices.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneAttributeService());
+ getAttributeServices().push_back((*i)->cloneAttributeService());
}
}
- VectorOf(AssertionIDRequestService) w=getAssertionIDRequestServices();
for (vector<AssertionIDRequestService*>::const_iterator j=src.m_AssertionIDRequestServices.begin(); j!=src.m_AssertionIDRequestServices.end(); j++) {
if (*j) {
- w.push_back((*j)->cloneAssertionIDRequestService());
+ getAssertionIDRequestServices().push_back((*j)->cloneAssertionIDRequestService());
}
}
- VectorOf(NameIDFormat) x=getNameIDFormats();
for (vector<NameIDFormat*>::const_iterator k=src.m_NameIDFormats.begin(); k!=src.m_NameIDFormats.end(); k++) {
if (*k) {
- x.push_back((*k)->cloneNameIDFormat());
+ getNameIDFormats().push_back((*k)->cloneNameIDFormat());
}
}
- VectorOf(AttributeProfile) y=getAttributeProfiles();
for (vector<AttributeProfile*>::const_iterator m=src.m_AttributeProfiles.begin(); m!=src.m_AttributeProfiles.end(); m++) {
if (*m) {
- y.push_back((*m)->cloneAttributeProfile());
+ getAttributeProfiles().push_back((*m)->cloneAttributeProfile());
}
}
- VectorOf(Attribute) z=getAttributes();
for (vector<Attribute*>::const_iterator n=src.m_Attributes.begin(); n!=src.m_Attributes.end(); n++) {
if (*n) {
- z.push_back((*n)->cloneAttribute());
+ getAttributes().push_back((*n)->cloneAttribute());
}
}
}
void _clone(const QueryDescriptorTypeImpl& src) {
RoleDescriptorImpl::_clone(src);
WantAssertionsSigned(src.m_WantAssertionsSigned);
- VectorOf(NameIDFormat) y=getNameIDFormats();
for (vector<NameIDFormat*>::const_iterator m=src.m_NameIDFormats.begin(); m!=src.m_NameIDFormats.end(); m++) {
if (*m) {
- y.push_back((*m)->cloneNameIDFormat());
+ getNameIDFormats().push_back((*m)->cloneNameIDFormat());
}
}
}
void _clone(const AttributeQueryDescriptorTypeImpl& src) {
QueryDescriptorTypeImpl::_clone(src);
- VectorOf(AttributeConsumingService) w=getAttributeConsumingServices();
for (vector<AttributeConsumingService*>::const_iterator j=src.m_AttributeConsumingServices.begin(); j!=src.m_AttributeConsumingServices.end(); j++) {
if (*j) {
- w.push_back((*j)->cloneAttributeConsumingService());
+ getAttributeConsumingServices().push_back((*j)->cloneAttributeConsumingService());
}
}
}
void _clone(const AuthzDecisionQueryDescriptorTypeImpl& src) {
QueryDescriptorTypeImpl::_clone(src);
- VectorOf(ActionNamespace) w=getActionNamespaces();
for (vector<ActionNamespace*>::const_iterator j=src.m_ActionNamespaces.begin(); j!=src.m_ActionNamespaces.end(); j++) {
if (*j) {
- w.push_back((*j)->cloneActionNamespace());
+ getActionNamespaces().push_back((*j)->cloneActionNamespace());
}
}
}
if (src.getExtensions())
setExtensions(src.getExtensions()->cloneExtensions());
- VectorOf(KeyDescriptor) v=getKeyDescriptors();
for (vector<KeyDescriptor*>::const_iterator i=src.m_KeyDescriptors.begin(); i!=src.m_KeyDescriptors.end(); i++) {
if (*i) {
- v.push_back((*i)->cloneKeyDescriptor());
+ getKeyDescriptors().push_back((*i)->cloneKeyDescriptor());
}
}
- VectorOf(AffiliateMember) w=getAffiliateMembers();
for (vector<AffiliateMember*>::const_iterator j=src.m_AffiliateMembers.begin(); j!=src.m_AffiliateMembers.end(); j++) {
if (*j) {
- w.push_back((*j)->cloneAffiliateMember());
+ getAffiliateMembers().push_back((*j)->cloneAffiliateMember());
}
}
}
}
}
- VectorOf(ContactPerson) v=getContactPersons();
for (vector<ContactPerson*>::const_iterator j=src.m_ContactPersons.begin(); j!=src.m_ContactPersons.end(); j++) {
if (*j) {
- v.push_back((*j)->cloneContactPerson());
+ getContactPersons().push_back((*j)->cloneContactPerson());
}
}
- VectorOf(AdditionalMetadataLocation) w=getAdditionalMetadataLocations();
for (vector<AdditionalMetadataLocation*>::const_iterator k=src.m_AdditionalMetadataLocations.begin(); k!=src.m_AdditionalMetadataLocations.end(); k++) {
if (*k) {
- w.push_back((*k)->cloneAdditionalMetadataLocation());
+ getAdditionalMetadataLocations().push_back((*k)->cloneAdditionalMetadataLocation());
}
}
}
}
DigestMethodImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
- : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
- m_Algorithm = nullptr;
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType), m_Algorithm(nullptr) {
}
DigestMethodImpl(const DigestMethodImpl& src)
- : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
+ : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src), m_Algorithm(nullptr) {
setAlgorithm(src.getAlgorithm());
- VectorOf(XMLObject) v=getUnknownXMLObjects();
- for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i)
- v.push_back((*i)->clone());
+ for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i) {
+ if (*i) {
+ getUnknownXMLObjects().push_back((*i)->clone());
+ }
+ }
}
IMPL_XMLOBJECT_CLONE(DigestMethod);
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
+ void init() {
+ m_Algorithm = m_MinKeySize = m_MaxKeySize = nullptr;
+ }
+
public:
virtual ~SigningMethodImpl() {
XMLString::release(&m_Algorithm);
}
SigningMethodImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
- : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
- m_Algorithm = nullptr;
- m_MinKeySize = nullptr;
- m_MaxKeySize = nullptr;
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
+ init();
}
SigningMethodImpl(const SigningMethodImpl& src)
: AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
+ init();
setAlgorithm(src.getAlgorithm());
setMinKeySize(src.m_MinKeySize);
setMaxKeySize(src.m_MaxKeySize);
- VectorOf(XMLObject) v=getUnknownXMLObjects();
- for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i)
- v.push_back((*i)->clone());
+ for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i) {
+ if (*i) {
+ getUnknownXMLObjects().push_back((*i)->clone());
+ }
+ }
}
IMPL_XMLOBJECT_CLONE(SigningMethod);
init();
}
- LogoImpl(const LogoImpl& src)
- : AbstractXMLObject(src), AbstractSimpleElement(src), AbstractDOMCachingXMLObject(src) {
+ LogoImpl(const LogoImpl& src) : AbstractXMLObject(src), AbstractSimpleElement(src), AbstractDOMCachingXMLObject(src) {
init();
setLang(src.getLang());
if (src.m_LangPrefix)
continue;
}
- getUnknownXMLObjects().push_back((*i)->clone());
+ if (*i) {
+ getUnknownXMLObjects().push_back((*i)->clone());
+ }
}
}
}
continue;
}
- getUnknownXMLObjects().push_back((*i)->clone());
+ if (*i) {
+ getUnknownXMLObjects().push_back((*i)->clone());
+ }
}
}
}