+ AbstractXMLObjectUnmarshaller::processAttribute(attribute);
+ }
+ };
+
+ class XMLTOOL_DLLLOCAL TransformsImpl : public virtual Transforms,
+ public AbstractComplexElement,
+ public AbstractDOMCachingXMLObject,
+ public AbstractValidatingXMLObject,
+ public AbstractXMLObjectMarshaller,
+ public AbstractXMLObjectUnmarshaller
+ {
+ public:
+ virtual ~TransformsImpl() {}
+
+ TransformsImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
+ }
+
+ TransformsImpl(const TransformsImpl& src)
+ : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
+ VectorOf(xmlsignature::Transform) v=getTransforms();
+ for (vector<xmlsignature::Transform*>::const_iterator i=src.m_Transforms.begin(); i!=src.m_Transforms.end(); i++) {
+ if (*i) {
+ v.push_back((*i)->cloneTransform());
+ }
+ }
+ }
+
+ IMPL_XMLOBJECT_CLONE(Transforms);
+ IMPL_TYPED_FOREIGN_CHILDREN(Transform,xmlsignature,m_children.end());
+
+ protected:
+ void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
+ PROC_TYPED_FOREIGN_CHILDREN(Transform,xmlsignature,XMLConstants::XMLSIG_NS,false);
+ AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
+ }
+ };
+
+ class XMLTOOL_DLLLOCAL CipherReferenceImpl : public virtual CipherReference,
+ public AbstractComplexElement,
+ public AbstractDOMCachingXMLObject,
+ public AbstractValidatingXMLObject,
+ public AbstractXMLObjectMarshaller,
+ public AbstractXMLObjectUnmarshaller
+ {
+ void init() {
+ m_URI=NULL;
+ m_Transforms=NULL;
+ m_children.push_back(NULL);
+ m_pos_Transforms=m_children.begin();
+ }
+ public:
+ virtual ~CipherReferenceImpl() {
+ XMLString::release(&m_URI);
+ }
+
+ CipherReferenceImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
+ init();
+ }
+
+ CipherReferenceImpl(const CipherReferenceImpl& src)
+ : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
+ init();
+ setURI(src.getURI());
+ if (src.getTransforms())
+ setTransforms(src.getTransforms()->cloneTransforms());
+ }
+
+ IMPL_XMLOBJECT_CLONE(CipherReference);
+ IMPL_STRING_ATTRIB(URI);
+ IMPL_TYPED_CHILD(Transforms);
+
+ protected:
+ void marshallAttributes(DOMElement* domElement) const {
+ MARSHALL_STRING_ATTRIB(URI,URI,NULL);
+ }
+
+ void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
+ PROC_TYPED_CHILD(Transforms,XMLConstants::XMLENC_NS,false);
+ AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
+ }
+
+ void processAttribute(const DOMAttr* attribute) {
+ PROC_STRING_ATTRIB(URI,URI,NULL);
+ AbstractXMLObjectUnmarshaller::processAttribute(attribute);
+ }
+ };
+
+ class XMLTOOL_DLLLOCAL CipherDataImpl : public virtual CipherData,
+ public AbstractComplexElement,
+ public AbstractDOMCachingXMLObject,
+ public AbstractValidatingXMLObject,
+ public AbstractXMLObjectMarshaller,
+ public AbstractXMLObjectUnmarshaller
+ {
+ void init() {
+ m_CipherValue=NULL;
+ m_CipherReference=NULL;
+ m_children.push_back(NULL);
+ m_children.push_back(NULL);
+ m_pos_CipherValue=m_children.begin();
+ m_pos_CipherReference=m_pos_CipherValue;
+ ++m_pos_CipherReference;
+ }
+ public:
+ virtual ~CipherDataImpl() {}
+
+ CipherDataImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
+ init();
+ }
+
+ CipherDataImpl(const CipherDataImpl& src)
+ : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
+ init();
+ if (src.getCipherValue())
+ setCipherValue(src.getCipherValue()->cloneCipherValue());
+ if (src.getCipherReference())
+ setCipherReference(src.getCipherReference()->cloneCipherReference());
+ }
+
+ IMPL_XMLOBJECT_CLONE(CipherData);
+ IMPL_TYPED_CHILD(CipherValue);
+ IMPL_TYPED_CHILD(CipherReference);
+
+ protected:
+ void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
+ PROC_TYPED_CHILD(CipherValue,XMLConstants::XMLENC_NS,false);
+ PROC_TYPED_CHILD(CipherReference,XMLConstants::XMLENC_NS,false);
+ AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
+ }
+ };
+
+ class XMLTOOL_DLLLOCAL EncryptionPropertyImpl : public virtual EncryptionProperty,
+ public AbstractElementProxy,
+ public AbstractAttributeExtensibleXMLObject,
+ public AbstractDOMCachingXMLObject,
+ public AbstractValidatingXMLObject,
+ public AbstractXMLObjectMarshaller,
+ public AbstractXMLObjectUnmarshaller
+ {
+ void init() {
+ m_Id=m_Target=NULL;
+ }
+ public:
+ virtual ~EncryptionPropertyImpl() {
+ XMLString::release(&m_Id);
+ XMLString::release(&m_Target);
+ }
+
+ EncryptionPropertyImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
+ init();
+ }
+
+ EncryptionPropertyImpl(const EncryptionPropertyImpl& src)
+ : AbstractXMLObject(src),
+ AbstractElementProxy(src),
+ AbstractAttributeExtensibleXMLObject(src),
+ AbstractDOMCachingXMLObject(src),
+ AbstractValidatingXMLObject(src) {
+ init();
+ setId(src.getId());
+ setTarget(src.getTarget());
+ for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
+ if (*i) {
+ getXMLObjects().push_back((*i)->clone());
+ }
+ }
+ }
+
+ IMPL_XMLOBJECT_CLONE(EncryptionProperty);
+ IMPL_STRING_ATTRIB(Id);
+ IMPL_STRING_ATTRIB(Target);
+
+ void setAttribute(QName& qualifiedName, const XMLCh* value) {
+ if (!qualifiedName.hasNamespaceURI()) {
+ if (XMLString::equals(qualifiedName.getLocalPart(),ID_ATTRIB_NAME))
+ setId(value);
+ else if (XMLString::equals(qualifiedName.getLocalPart(),TARGET_ATTRIB_NAME))
+ setTarget(value);
+ }
+ AbstractAttributeExtensibleXMLObject::setAttribute(qualifiedName, value);
+ }
+
+ protected:
+ void marshallAttributes(DOMElement* domElement) const {
+ MARSHALL_ID_ATTRIB(Id,ID,NULL);
+ MARSHALL_STRING_ATTRIB(Target,TARGET,NULL);
+
+ // Take care of wildcard.
+ for (map<QName,XMLCh*>::const_iterator i=m_attributeMap.begin(); i!=m_attributeMap.end(); i++) {
+ DOMAttr* attr=domElement->getOwnerDocument()->createAttributeNS(i->first.getNamespaceURI(),i->first.getLocalPart());
+ if (i->first.hasPrefix())
+ attr->setPrefix(i->first.getPrefix());
+ attr->setNodeValue(i->second);
+ domElement->setAttributeNode(attr);
+ }
+ }
+
+ void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
+ getXMLObjects().push_back(childXMLObject);
+ }
+
+ void processAttribute(const DOMAttr* attribute) {
+ PROC_ID_ATTRIB(Id,ID,NULL);
+ QName q(attribute->getNamespaceURI(),attribute->getLocalName(),attribute->getPrefix());
+ setAttribute(q,attribute->getNodeValue());
+ }
+ };
+
+ class XMLTOOL_DLLLOCAL EncryptionPropertiesImpl : public virtual EncryptionProperties,
+ public AbstractComplexElement,
+ public AbstractDOMCachingXMLObject,
+ public AbstractValidatingXMLObject,
+ public AbstractXMLObjectMarshaller,
+ public AbstractXMLObjectUnmarshaller
+ {
+ void init() {
+ m_Id=NULL;
+ }
+ public:
+ virtual ~EncryptionPropertiesImpl() {
+ XMLString::release(&m_Id);
+ }
+
+ EncryptionPropertiesImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
+ init();
+ }
+
+ EncryptionPropertiesImpl(const EncryptionPropertiesImpl& src)
+ : AbstractXMLObject(src),
+ AbstractDOMCachingXMLObject(src),
+ AbstractValidatingXMLObject(src) {
+ init();
+ setId(src.getId());
+ VectorOf(EncryptionProperty) v=getEncryptionPropertys();
+ for (vector<EncryptionProperty*>::const_iterator i=src.m_EncryptionPropertys.begin(); i!=src.m_EncryptionPropertys.end(); i++) {
+ if (*i) {
+ v.push_back((*i)->cloneEncryptionProperty());
+ }
+ }
+ }
+
+ IMPL_XMLOBJECT_CLONE(EncryptionProperties);
+ IMPL_STRING_ATTRIB(Id);
+ IMPL_TYPED_CHILDREN(EncryptionProperty,m_children.end());
+
+ protected:
+ void marshallAttributes(DOMElement* domElement) const {
+ MARSHALL_ID_ATTRIB(Id,ID,NULL);
+ }
+
+ void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
+ PROC_TYPED_CHILDREN(EncryptionProperty,XMLConstants::XMLENC_NS,false);
+ AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
+ }
+
+ void processAttribute(const DOMAttr* attribute) {
+ PROC_ID_ATTRIB(Id,ID,NULL);
+ AbstractXMLObjectUnmarshaller::processAttribute(attribute);
+ }
+ };
+
+ class XMLTOOL_DLLLOCAL ReferenceTypeImpl : public virtual ReferenceType,
+ public AbstractElementProxy,
+ public AbstractDOMCachingXMLObject,
+ public AbstractValidatingXMLObject,
+ public AbstractXMLObjectMarshaller,
+ public AbstractXMLObjectUnmarshaller
+ {
+ void init() {
+ m_URI=NULL;
+ }
+
+ protected:
+ ReferenceTypeImpl() {
+ init();
+ }
+
+ public:
+ virtual ~ReferenceTypeImpl() {
+ XMLString::release(&m_URI);
+ }
+
+ ReferenceTypeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
+ init();
+ }
+
+ ReferenceTypeImpl(const ReferenceTypeImpl& src)
+ : AbstractXMLObject(src),
+ AbstractElementProxy(src),
+ AbstractDOMCachingXMLObject(src),
+ AbstractValidatingXMLObject(src) {
+ init();
+ setURI(src.getURI());
+ for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
+ if (*i) {
+ getXMLObjects().push_back((*i)->clone());
+ }
+ }
+ }
+
+ IMPL_XMLOBJECT_CLONE(ReferenceType);
+ IMPL_STRING_ATTRIB(URI);
+
+ protected:
+ void marshallAttributes(DOMElement* domElement) const {
+ MARSHALL_STRING_ATTRIB(URI,URI,NULL);
+ }
+
+ void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
+ getXMLObjects().push_back(childXMLObject);
+ }
+
+ void processAttribute(const DOMAttr* attribute) {
+ PROC_STRING_ATTRIB(URI,URI,NULL);
+ AbstractXMLObjectUnmarshaller::processAttribute(attribute);
+ }
+ };
+
+ class XMLTOOL_DLLLOCAL DataReferenceImpl : public virtual DataReference, public ReferenceTypeImpl
+ {
+ public:
+ virtual ~DataReferenceImpl() {}
+
+ DataReferenceImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
+
+ DataReferenceImpl(const DataReferenceImpl& src) : AbstractXMLObject(src), ReferenceTypeImpl(src) {}
+
+ IMPL_XMLOBJECT_CLONE(DataReference);
+ ReferenceType* cloneReferenceType() const {
+ return new DataReferenceImpl(*this);
+ }
+ };
+
+ class XMLTOOL_DLLLOCAL KeyReferenceImpl : public virtual KeyReference, public ReferenceTypeImpl
+ {
+ public:
+ virtual ~KeyReferenceImpl() {}
+
+ KeyReferenceImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
+
+ KeyReferenceImpl(const KeyReferenceImpl& src) : AbstractXMLObject(src), ReferenceTypeImpl(src) {}
+
+ IMPL_XMLOBJECT_CLONE(KeyReference);
+ ReferenceType* cloneReferenceType() const {
+ return new KeyReferenceImpl(*this);
+ }
+ };
+
+ class XMLTOOL_DLLLOCAL ReferenceListImpl : public virtual ReferenceList,
+ public AbstractComplexElement,
+ public AbstractDOMCachingXMLObject,
+ public AbstractValidatingXMLObject,
+ public AbstractXMLObjectMarshaller,
+ public AbstractXMLObjectUnmarshaller
+ {
+ public:
+ virtual ~ReferenceListImpl() {}
+
+ ReferenceListImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
+ }
+
+ ReferenceListImpl(const ReferenceListImpl& src)
+ : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
+ for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
+ if (*i) {
+ DataReference* data=dynamic_cast<DataReference*>(*i);
+ if (data) {
+ getDataReferences().push_back(data->cloneDataReference());
+ continue;
+ }
+
+ KeyReference* key=dynamic_cast<KeyReference*>(*i);
+ if (key) {
+ getKeyReferences().push_back(key->cloneKeyReference());
+ continue;
+ }
+ }
+ }
+ }
+
+ IMPL_XMLOBJECT_CLONE(ReferenceList);
+ IMPL_TYPED_CHILDREN(DataReference,m_children.end());
+ IMPL_TYPED_CHILDREN(KeyReference,m_children.end());
+
+ protected:
+ void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
+ PROC_TYPED_CHILDREN(DataReference,XMLConstants::XMLENC_NS,false);
+ PROC_TYPED_CHILDREN(KeyReference,XMLConstants::XMLENC_NS,false);
+ AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
+ }
+ };
+
+ class XMLTOOL_DLLLOCAL EncryptedTypeImpl : public virtual EncryptedType,
+ public AbstractComplexElement,
+ public AbstractDOMCachingXMLObject,
+ public AbstractValidatingXMLObject,
+ public AbstractXMLObjectMarshaller,
+ public AbstractXMLObjectUnmarshaller
+ {
+ void init() {
+ m_Id=m_Type=m_MimeType=m_Encoding=NULL;
+ m_EncryptionMethod=NULL;
+ m_KeyInfo=NULL;
+ m_CipherData=NULL;
+ m_EncryptionProperties=NULL;
+ m_children.push_back(NULL);
+ m_children.push_back(NULL);
+ m_children.push_back(NULL);
+ m_children.push_back(NULL);
+ m_pos_EncryptionMethod=m_children.begin();
+ m_pos_KeyInfo=m_pos_EncryptionMethod;
+ ++m_pos_KeyInfo;
+ m_pos_CipherData=m_pos_KeyInfo;
+ ++m_pos_CipherData;
+ m_pos_EncryptionProperties=m_pos_CipherData;
+ ++m_pos_EncryptionProperties;
+ }
+ protected:
+ EncryptedTypeImpl() {
+ init();
+ }
+
+ public:
+ virtual ~EncryptedTypeImpl() {
+ XMLString::release(&m_Id);
+ XMLString::release(&m_Type);
+ XMLString::release(&m_MimeType);
+ XMLString::release(&m_Encoding);
+ }
+
+ EncryptedTypeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
+ init();
+ }
+
+ EncryptedTypeImpl(const EncryptedTypeImpl& src)
+ : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
+ init();
+ setId(src.getId());
+ setType(src.getType());
+ setMimeType(src.getMimeType());
+ setEncoding(src.getEncoding());
+ if (src.getEncryptionMethod())
+ setEncryptionMethod(src.getEncryptionMethod()->cloneEncryptionMethod());
+ if (src.getKeyInfo())
+ setKeyInfo(src.getKeyInfo()->cloneKeyInfo());
+ if (src.getCipherData())
+ setCipherData(src.getCipherData()->cloneCipherData());
+ if (src.getEncryptionProperties())
+ setEncryptionProperties(src.getEncryptionProperties()->cloneEncryptionProperties());
+ }
+
+ IMPL_XMLOBJECT_CLONE(EncryptedType);
+ IMPL_STRING_ATTRIB(Id);
+ IMPL_STRING_ATTRIB(Type);
+ IMPL_STRING_ATTRIB(MimeType);
+ IMPL_STRING_ATTRIB(Encoding);
+ IMPL_TYPED_CHILD(EncryptionMethod);
+ IMPL_TYPED_FOREIGN_CHILD(KeyInfo,xmlsignature);
+ IMPL_TYPED_CHILD(CipherData);
+ IMPL_TYPED_CHILD(EncryptionProperties);
+
+ protected:
+ void marshallAttributes(DOMElement* domElement) const {
+ MARSHALL_ID_ATTRIB(Id,ID,NULL);
+ MARSHALL_STRING_ATTRIB(Type,TYPE,NULL);
+ MARSHALL_STRING_ATTRIB(MimeType,MIMETYPE,NULL);
+ MARSHALL_STRING_ATTRIB(Encoding,ENCODING,NULL);
+ }
+
+ void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
+ PROC_TYPED_CHILD(EncryptionMethod,XMLConstants::XMLENC_NS,false);
+ PROC_TYPED_FOREIGN_CHILD(KeyInfo,xmlsignature,XMLConstants::XMLSIG_NS,false);
+ PROC_TYPED_CHILD(CipherData,XMLConstants::XMLENC_NS,false);
+ PROC_TYPED_CHILD(EncryptionProperties,XMLConstants::XMLENC_NS,false);
+ AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
+ }
+
+ void processAttribute(const DOMAttr* attribute) {
+ PROC_ID_ATTRIB(Id,ID,NULL);
+ PROC_STRING_ATTRIB(Type,TYPE,NULL);
+ PROC_STRING_ATTRIB(MimeType,MIMETYPE,NULL);
+ PROC_STRING_ATTRIB(Encoding,ENCODING,NULL);
+ AbstractXMLObjectUnmarshaller::processAttribute(attribute);
+ }
+ };
+
+ class XMLTOOL_DLLLOCAL EncryptedDataImpl : public virtual EncryptedData, public EncryptedTypeImpl
+ {
+ public:
+ virtual ~EncryptedDataImpl() {}
+
+ EncryptedDataImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
+
+ EncryptedDataImpl(const EncryptedDataImpl& src) : AbstractXMLObject(src), EncryptedTypeImpl(src) {}
+
+ IMPL_XMLOBJECT_CLONE(EncryptedData);
+ EncryptedType* cloneEncryptedType() const {
+ return new EncryptedDataImpl(*this);
+ }
+ };
+
+ class XMLTOOL_DLLLOCAL EncryptedKeyImpl : public virtual EncryptedKey, public EncryptedTypeImpl
+ {
+ void init() {
+ m_Recipient=NULL;
+ m_ReferenceList=NULL;
+ m_CarriedKeyName=NULL;
+ m_children.push_back(NULL);
+ m_children.push_back(NULL);
+ m_pos_ReferenceList=m_pos_EncryptionProperties;
+ ++m_pos_ReferenceList;
+ m_pos_CarriedKeyName=m_pos_ReferenceList;
+ ++m_pos_CarriedKeyName;
+ }
+
+ public:
+ virtual ~EncryptedKeyImpl() {
+ XMLString::release(&m_Recipient);
+ }
+
+ EncryptedKeyImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
+ init();
+ }
+
+ EncryptedKeyImpl(const EncryptedKeyImpl& src) : AbstractXMLObject(src), EncryptedTypeImpl(src) {
+ init();
+ }
+
+ IMPL_XMLOBJECT_CLONE(EncryptedKey);
+ EncryptedType* cloneEncryptedType() const {
+ return new EncryptedKeyImpl(*this);
+ }
+ IMPL_STRING_ATTRIB(Recipient);
+ IMPL_TYPED_CHILD(ReferenceList);
+ IMPL_TYPED_CHILD(CarriedKeyName);
+
+ protected:
+ void marshallAttributes(DOMElement* domElement) const {
+ MARSHALL_STRING_ATTRIB(Recipient,RECIPIENT,NULL);
+ EncryptedTypeImpl::marshallAttributes(domElement);
+ }
+
+ void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
+ PROC_TYPED_CHILD(ReferenceList,XMLConstants::XMLENC_NS,false);
+ PROC_TYPED_CHILD(CarriedKeyName,XMLConstants::XMLENC_NS,false);
+ EncryptedTypeImpl::processChildElement(childXMLObject,root);
+ }
+
+ void processAttribute(const DOMAttr* attribute) {
+ PROC_STRING_ATTRIB(Recipient,RECIPIENT,NULL);
+ EncryptedTypeImpl::processAttribute(attribute);