+ class XMLTOOL_DLLLOCAL RetrievalMethodImpl : public virtual RetrievalMethod,
+ public AbstractComplexElement,
+ public AbstractDOMCachingXMLObject,
+ public AbstractXMLObjectMarshaller,
+ public AbstractXMLObjectUnmarshaller
+ {
+ public:
+ virtual ~RetrievalMethodImpl() {
+ XMLString::release(&m_URI);
+ XMLString::release(&m_Type);
+ }
+
+ RetrievalMethodImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
+ init();
+ }
+
+ RetrievalMethodImpl(const RetrievalMethodImpl& src)
+ : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
+ init();
+ setURI(getURI());
+ setType(getType());
+ if (src.getTransforms())
+ setTransforms(src.getTransforms()->cloneTransforms());
+ }
+
+ void init() {
+ m_URI=m_Type=NULL;
+ m_Transforms=NULL;
+ m_children.push_back(NULL);
+ m_pos_Transforms=m_children.begin();
+ }
+
+ IMPL_XMLOBJECT_CLONE(RetrievalMethod);
+ IMPL_STRING_ATTRIB(URI);
+ IMPL_STRING_ATTRIB(Type);
+ IMPL_TYPED_CHILD(Transforms);
+
+ protected:
+ void marshallAttributes(DOMElement* domElement) const {
+ MARSHALL_STRING_ATTRIB(URI,URI,NULL);
+ MARSHALL_STRING_ATTRIB(Type,TYPE,NULL);
+ }
+
+ void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
+ PROC_TYPED_CHILD(Transforms,XMLConstants::XMLSIG_NS,false);
+ AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
+ }
+
+ void processAttribute(const DOMAttr* attribute) {
+ PROC_STRING_ATTRIB(URI,URI,NULL);
+ PROC_STRING_ATTRIB(Type,TYPE,NULL);
+ AbstractXMLObjectUnmarshaller::processAttribute(attribute);
+ }
+ };
+
+ class XMLTOOL_DLLLOCAL X509IssuerSerialImpl : public virtual X509IssuerSerial,
+ public AbstractComplexElement,
+ public AbstractDOMCachingXMLObject,
+ public AbstractXMLObjectMarshaller,
+ public AbstractXMLObjectUnmarshaller
+ {
+ public:
+ virtual ~X509IssuerSerialImpl() {}
+
+ X509IssuerSerialImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
+ init();
+ }
+
+ X509IssuerSerialImpl(const X509IssuerSerialImpl& src)
+ : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
+ init();
+ if (src.getX509IssuerName())
+ setX509IssuerName(src.getX509IssuerName()->cloneX509IssuerName());
+ if (src.getX509SerialNumber())
+ setX509SerialNumber(src.getX509SerialNumber()->cloneX509SerialNumber());
+ }
+
+ void init() {
+ m_X509IssuerName=NULL;
+ m_X509SerialNumber=NULL;
+ m_children.push_back(NULL);
+ m_children.push_back(NULL);
+ m_pos_X509IssuerName=m_children.begin();
+ m_pos_X509SerialNumber=m_pos_X509IssuerName;
+ ++m_pos_X509SerialNumber;
+ }
+
+ IMPL_XMLOBJECT_CLONE(X509IssuerSerial);
+ IMPL_TYPED_CHILD(X509IssuerName);
+ IMPL_TYPED_CHILD(X509SerialNumber);
+
+ protected:
+ void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
+ PROC_TYPED_CHILD(X509IssuerName,XMLConstants::XMLSIG_NS,false);
+ PROC_TYPED_CHILD(X509SerialNumber,XMLConstants::XMLSIG_NS,false);
+ AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
+ }
+ };
+
+ class XMLTOOL_DLLLOCAL X509DataImpl : public virtual X509Data,
+ public AbstractComplexElement,
+ public AbstractDOMCachingXMLObject,
+ public AbstractXMLObjectMarshaller,
+ public AbstractXMLObjectUnmarshaller
+ {
+ public:
+ virtual ~X509DataImpl() {}
+
+ X509DataImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
+ }
+
+ X509DataImpl(const X509DataImpl& src)
+ : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
+ for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
+ if (*i) {
+ X509Certificate* xcert=dynamic_cast<X509Certificate*>(*i);
+ if (xcert) {
+ getX509Certificates().push_back(xcert->cloneX509Certificate());
+ continue;
+ }
+
+ X509CRL* xcrl=dynamic_cast<X509CRL*>(*i);
+ if (xcrl) {
+ getX509CRLs().push_back(xcrl->cloneX509CRL());
+ continue;
+ }
+
+ X509SubjectName* xsn=dynamic_cast<X509SubjectName*>(*i);
+ if (xsn) {
+ getX509SubjectNames().push_back(xsn->cloneX509SubjectName());
+ continue;
+ }
+
+ X509IssuerSerial* xis=dynamic_cast<X509IssuerSerial*>(*i);
+ if (xis) {
+ getX509IssuerSerials().push_back(xis->cloneX509IssuerSerial());
+ continue;
+ }
+
+ X509SKI* xski=dynamic_cast<X509SKI*>(*i);
+ if (xski) {
+ getX509SKIs().push_back(xski->cloneX509SKI());
+ continue;
+ }
+
+ getOtherX509Datas().push_back((*i)->clone());
+ }
+ }
+ }
+
+ IMPL_XMLOBJECT_CLONE(X509Data);
+ IMPL_TYPED_CHILDREN(X509IssuerSerial,m_children.end());
+ IMPL_TYPED_CHILDREN(X509SKI,m_children.end());
+ IMPL_TYPED_CHILDREN(X509SubjectName,m_children.end());
+ IMPL_TYPED_CHILDREN(X509Certificate,m_children.end());
+ IMPL_TYPED_CHILDREN(X509CRL,m_children.end());
+ IMPL_XMLOBJECT_CHILDREN(OtherX509Data,m_children.end());
+
+ protected:
+ void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
+ PROC_TYPED_CHILDREN(X509IssuerSerial,XMLConstants::XMLSIG_NS,false);
+ PROC_TYPED_CHILDREN(X509SKI,XMLConstants::XMLSIG_NS,false);
+ PROC_TYPED_CHILDREN(X509SubjectName,XMLConstants::XMLSIG_NS,false);
+ PROC_TYPED_CHILDREN(X509Certificate,XMLConstants::XMLSIG_NS,false);
+ PROC_TYPED_CHILDREN(X509CRL,XMLConstants::XMLSIG_NS,false);
+
+ // Unknown child.
+ const XMLCh* nsURI=root->getNamespaceURI();
+ if (!XMLString::equals(nsURI,XMLConstants::XMLSIG_NS) && nsURI && *nsURI) {
+ getOtherX509Datas().push_back(childXMLObject);
+ return;
+ }
+
+ AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
+ }
+ };
+
+ class XMLTOOL_DLLLOCAL SPKIDataImpl : public virtual SPKIData,
+ public AbstractComplexElement,
+ public AbstractDOMCachingXMLObject,
+ public AbstractXMLObjectMarshaller,
+ public AbstractXMLObjectUnmarshaller
+ {
+ public:
+ virtual ~SPKIDataImpl() {}
+
+ SPKIDataImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
+ }
+
+ SPKIDataImpl(const SPKIDataImpl& src)
+ : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
+ VectorOfPairs(SPKISexp,XMLObject) v=getSPKISexps();
+ for (vector< pair<SPKISexp*,XMLObject*> >::const_iterator i=src.m_SPKISexps.begin(); i!=src.m_SPKISexps.end(); i++) {
+ if (i->first) {
+ v.push_back(make_pair(i->first->cloneSPKISexp(),(i->second ? i->second->clone() : (XMLObject*)NULL)));
+ }
+ }
+ }
+
+ IMPL_XMLOBJECT_CLONE(SPKIData);
+
+ private:
+ vector< pair<SPKISexp*,XMLObject*> > m_SPKISexps;
+
+ public:
+ VectorOfPairs(SPKISexp,XMLObject) getSPKISexps() {
+ return VectorOfPairs(SPKISexp,XMLObject)(this, m_SPKISexps, &m_children, m_children.end());
+ }
+
+ const vector< pair<SPKISexp*,XMLObject*> >& getSPKISexps() const {
+ return m_SPKISexps;
+ }
+
+ protected:
+ void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
+ if (XMLHelper::isNodeNamed(root,XMLConstants::XMLSIG_NS,SPKISexp::LOCAL_NAME)) {
+ SPKISexp* typesafe=dynamic_cast<SPKISexp*>(childXMLObject);
+ if (typesafe) {
+ getSPKISexps().push_back(make_pair(typesafe,(XMLObject*)NULL));
+ return;
+ }
+ }
+
+ // Unknown child (has to be paired with the last SPKISexp processed.
+ const XMLCh* nsURI=root->getNamespaceURI();
+ if (!XMLString::equals(nsURI,XMLConstants::XMLSIG_NS) && nsURI && *nsURI) {
+ // Update second half of pair in vector, and in master list.
+ if (!m_SPKISexps.empty() && m_SPKISexps.back().second==NULL) {
+ m_SPKISexps.back().second=childXMLObject;
+ m_children.back()=childXMLObject;
+ return;
+ }
+ else
+ throw UnmarshallingException("Extension element must follow ds:SPKISexp element.");
+ }
+
+ AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
+ }
+ };
+
+ class XMLTOOL_DLLLOCAL PGPDataImpl : public virtual PGPData,
+ public AbstractComplexElement,
+ public AbstractDOMCachingXMLObject,
+ public AbstractXMLObjectMarshaller,
+ public AbstractXMLObjectUnmarshaller
+ {
+ public:
+ virtual ~PGPDataImpl() {}
+
+ PGPDataImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
+ init();
+ }
+
+ PGPDataImpl(const PGPDataImpl& src)
+ : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
+ init();
+ if (src.getPGPKeyID())
+ setPGPKeyID(src.getPGPKeyID()->clonePGPKeyID());
+ if (src.getPGPKeyPacket())
+ setPGPKeyPacket(src.getPGPKeyPacket()->clonePGPKeyPacket());
+ VectorOf(XMLObject) v=getPGPDataExtensions();
+ for (vector<XMLObject*>::const_iterator i=src.m_PGPDataExtensions.begin(); i!=src.m_PGPDataExtensions.end(); i++) {
+ if (*i) {
+ v.push_back((*i)->clone());
+ }
+ }
+ }
+
+ void init() {
+ m_PGPKeyID=NULL;
+ m_PGPKeyPacket=NULL;
+ m_children.push_back(NULL);
+ m_children.push_back(NULL);
+ m_pos_PGPKeyID=m_children.begin();
+ m_pos_PGPKeyPacket=m_pos_PGPKeyID;
+ ++m_pos_PGPKeyPacket;
+ }
+
+ IMPL_XMLOBJECT_CLONE(PGPData);
+ IMPL_TYPED_CHILD(PGPKeyID);
+ IMPL_TYPED_CHILD(PGPKeyPacket);
+ IMPL_XMLOBJECT_CHILDREN(PGPDataExtension,m_children.end());
+
+ protected:
+ void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
+ PROC_TYPED_CHILD(PGPKeyID,XMLConstants::XMLSIG_NS,false);
+ PROC_TYPED_CHILD(PGPKeyPacket,XMLConstants::XMLSIG_NS,false);
+
+ // Unknown child.
+ const XMLCh* nsURI=root->getNamespaceURI();
+ if (!XMLString::equals(nsURI,XMLConstants::XMLSIG_NS) && nsURI && *nsURI) {
+ getPGPDataExtensions().push_back(childXMLObject);
+ return;
+ }
+
+ AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
+ }
+ };
+
+ class XMLTOOL_DLLLOCAL KeyInfoImpl : public virtual KeyInfo,
+ public AbstractComplexElement,