Shortcuts for unmarshalling in builder interface, adjusted tests

diff --git a/xmltooling/AbstractAttributeExtensibleXMLObject.h b/xmltooling/AbstractAttributeExtensibleXMLObject.h
index e5f716f..458204c 100644 (file)
--- a/xmltooling/AbstractAttributeExtensibleXMLObject.h
+++ b/xmltooling/AbstractAttributeExtensibleXMLObject.h
@@ -27,8 +27,6 @@
 #include <xmltooling/AbstractDOMCachingXMLObject.h>\r
 #include <xmltooling/AttributeExtensibleXMLObject.h>\r
 \r
-using namespace xercesc;\r
-\r
 #if defined (_MSC_VER)\r
     #pragma warning( push )\r
     #pragma warning( disable : 4250 4251 )\r

diff --git a/xmltooling/AbstractDOMCachingXMLObject.cpp b/xmltooling/AbstractDOMCachingXMLObject.cpp
index fb4c0f5..d97301d 100644 (file)
--- a/xmltooling/AbstractDOMCachingXMLObject.cpp
+++ b/xmltooling/AbstractDOMCachingXMLObject.cpp
@@ -127,9 +127,7 @@ XMLObject* AbstractDOMCachingXMLObject::clone() const
             throw UnmarshallingException("Unable to locate builder for cloned element.");\r
         }\r
         try {\r
-            auto_ptr<XMLObject> objCopy(b->buildObject(domCopy));\r
-            objCopy->unmarshall(domCopy, true);    // bind document\r
-            return objCopy.release();\r
+            return b->buildFromElement(domCopy,true); // bind document\r
         }\r
         catch (...) {\r
             domCopy->getOwnerDocument()->release();\r

diff --git a/xmltooling/AbstractElementProxy.h b/xmltooling/AbstractElementProxy.h
index ba122a4..14ea000 100644 (file)
--- a/xmltooling/AbstractElementProxy.h
+++ b/xmltooling/AbstractElementProxy.h
@@ -26,8 +26,6 @@
 #include <xmltooling/AbstractDOMCachingXMLObject.h>\r
 #include <xmltooling/ElementProxy.h>\r
 \r
-using namespace xercesc;\r
-\r
 #if defined (_MSC_VER)\r
     #pragma warning( push )\r
     #pragma warning( disable : 4250 4251 )\r

diff --git a/xmltooling/XMLObjectBuilder.h b/xmltooling/XMLObjectBuilder.h
index 0c9f069..4426401 100644 (file)
--- a/xmltooling/XMLObjectBuilder.h
+++ b/xmltooling/XMLObjectBuilder.h
@@ -24,12 +24,9 @@
 #define __xmltooling_xmlobjbuilder_h__\r
 \r
 #include <map>\r
-#include <xercesc/dom/DOM.hpp>\r
 #include <xmltooling/QName.h>\r
 #include <xmltooling/XMLObject.h>\r
 \r
-using namespace xercesc;\r
-\r
 #if defined (_MSC_VER)\r
     #pragma warning( push )\r
     #pragma warning( disable : 4250 4251 )\r
@@ -50,21 +47,58 @@ namespace xmltooling {
         /**\r
          * Creates an empty XMLObject.\r
          * \r
-         * @param e     a construction hint based on the eventual unmarshalling source\r
          * @return the empty XMLObject\r
          */\r
-        virtual XMLObject* buildObject(const DOMElement* e=NULL) const=0;\r
+        virtual XMLObject* buildObject() const=0;\r
+\r
+        /**\r
+         * Creates an unmarshalled XMLObject from a DOM Element.\r
+         * \r
+         * @param element       the unmarshalling source\r
+         * @param bindDocument  true iff the XMLObject should take ownership of the DOM Document\r
+         * @return the unmarshalled XMLObject\r
+         */\r
+        virtual XMLObject* buildFromElement(DOMElement* element, bool bindDocument=false) const {\r
+            std::auto_ptr<XMLObject> ret(buildObject());\r
+            ret->unmarshall(element,bindDocument);\r
+            return ret.release();\r
+        }\r
+\r
+        /**\r
+         * Creates an unmarshalled XMLObject from the root of a DOM Document.\r
+         * \r
+         * @param doc           the unmarshalling source\r
+         * @param bindDocument  true iff the XMLObject should take ownership of the DOM Document\r
+         * @return the unmarshalled XMLObject\r
+         */\r
+        virtual XMLObject* buildFromDocument(DOMDocument* doc, bool bindDocument=true) const {\r
+            return buildFromElement(doc->getDocumentElement(),bindDocument);\r
+        }\r
 \r
         /**\r
          * Creates an empty XMLObject using the default build method, if a builder can be found.\r
          * \r
          * @param key   the key used to locate a builder\r
-         * @param e     a construction hint based on the eventual unmarshalling source\r
          * @return  the empty object or NULL if no builder is available \r
          */\r
-        static XMLObject* buildObject(const QName& key, const DOMElement* e=NULL) {\r
+        static XMLObject* buildOne(const QName& key) {\r
             const XMLObjectBuilder* b=getBuilder(key);\r
-            return b ? b->buildObject(e) : NULL;\r
+            if (b)\r
+                return b->buildObject();\r
+            b=getDefaultBuilder();\r
+            return b ? b->buildObject() : NULL;\r
+        }\r
+\r
+        /**\r
+         * Creates an unmarshalled XMLObject using the default build method, if a builder can be found.\r
+         * \r
+         * @param element       the unmarshalling source\r
+         * @param bindDocument  true iff the new XMLObject should take ownership of the DOM Document\r
+         * @return  the unmarshalled object or NULL if no builder is available \r
+         */\r
+        static XMLObject* buildOneFromElement(DOMElement* element, bool bindDocument=false) {\r
+            const XMLObjectBuilder* b=getBuilder(element);\r
+            return b ? b->buildFromElement(element,bindDocument) : NULL;\r
         }\r
 \r
         /**\r
@@ -92,7 +126,7 @@ namespace xmltooling {
          * \r
          * @return the default builder or NULL\r
          */\r
-        static const XMLObjectBuilder* getDefaultBuilder(const DOMElement* element) {\r
+        static const XMLObjectBuilder* getDefaultBuilder() {\r
             return m_default;\r
         }\r
 \r

diff --git a/xmltooling/impl/UnknownElement.h b/xmltooling/impl/UnknownElement.h
index 7ac3103..bfc5b1a 100644 (file)
--- a/xmltooling/impl/UnknownElement.h
+++ b/xmltooling/impl/UnknownElement.h
@@ -68,7 +68,7 @@ namespace xmltooling {
     class XMLTOOL_DLLLOCAL UnknownElementBuilder : public XMLObjectBuilder\r
     {\r
     public:\r
-        XMLObject* buildObject(const DOMElement* e=NULL) const {\r
+        UnknownElementImpl* buildObject() const {\r
             return new UnknownElementImpl();\r
         }\r
     };\r

diff --git a/xmltooling/io/AbstractXMLObjectUnmarshaller.cpp b/xmltooling/io/AbstractXMLObjectUnmarshaller.cpp
index 701494b..797b035 100644 (file)
--- a/xmltooling/io/AbstractXMLObjectUnmarshaller.cpp
+++ b/xmltooling/io/AbstractXMLObjectUnmarshaller.cpp
@@ -43,6 +43,11 @@ XMLObject* AbstractXMLObjectUnmarshaller::unmarshall(DOMElement* element, bool b
     xmltooling::NDC ndc("unmarshall");\r
 #endif\r
 \r
+    if (!XMLString::equals(element->getNamespaceURI(),getElementQName().getNamespaceURI()) ||\r
+        !XMLString::equals(element->getLocalName(),getElementQName().getLocalPart())) {\r
+        throw UnmarshallingException("Unrecognized element supplied to implementation for unmarshalling.");\r
+    }\r
+\r
     if (XT_log.isDebugEnabled()) {\r
         auto_ptr_char dname(element->getNodeName());\r
         XT_log.debug("unmarshalling DOM element (%s)", dname.get());\r
@@ -159,8 +164,7 @@ void AbstractXMLObjectUnmarshaller::unmarshallChildElements(const DOMElement* do
             }\r
 \r
             // Retain ownership of the unmarshalled child until it's processed by the parent.\r
-            auto_ptr<XMLObject> childObject(builder->buildObject(static_cast<DOMElement*>(childNode)));\r
-            childObject->unmarshall(static_cast<DOMElement*>(childNode));\r
+            auto_ptr<XMLObject> childObject(builder->buildFromElement(static_cast<DOMElement*>(childNode)));\r
             processChildElement(childObject.get(), static_cast<DOMElement*>(childNode));\r
             childObject.release();\r
         }\r

diff --git a/xmltooling/signature/VerifyingContext.h b/xmltooling/signature/VerifyingContext.h
new file mode 100644 (file)
index 0000000..9dfe2cb
--- /dev/null
+++ b/xmltooling/signature/VerifyingContext.h
@@ -0,0 +1,55 @@
+/*\r
+ *  Copyright 2001-2006 Internet2\r
+ * \r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ *     http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ */\r
+\r
+/**\r
+ * @file VerifyingContext.h\r
+ * \r
+ * Interface to signature verification process supplied by a relying party \r
+ */\r
+\r
+#if !defined(__xmltooling_verctx_h__) && !defined(XMLTOOLING_NO_XMLSEC)\r
+#define __xmltooling_verctx_h__\r
+\r
+#include <xsec/dsig/DSIGSignature.hpp>\r
+\r
+namespace xmltooling {\r
+\r
+    /**\r
+     * Interface to signature verification process supplied by a relying party\r
+     */\r
+    class XMLTOOL_API VerifyingContext\r
+    {\r
+        MAKE_NONCOPYABLE(VerifyingContext);\r
+    public:\r
+        virtual ~VerifyingContext() {}\r
+\r
+        /**\r
+         * Given a native signature, asks the context to verify the signature\r
+         * in accordance with the relying party's requirements.\r
+         * \r
+         * @param sig   native signature object\r
+         * \r
+         * @throws SignatureException   raised if signature is invalid\r
+         */\r
+        virtual void verifySignature(DSIGSignature* sig) const=0;\r
+        \r
+    protected:\r
+        VerifyingContext() {}\r
+    };\r
+\r
+};\r
+\r
+#endif /* __xmltooling_verctx_h__ */\r

diff --git a/xmltooling/signature/impl/XMLSecSignature.h b/xmltooling/signature/impl/XMLSecSignature.h
index d97fd81..635b646 100644 (file)
--- a/xmltooling/signature/impl/XMLSecSignature.h
+++ b/xmltooling/signature/impl/XMLSecSignature.h
@@ -54,7 +54,6 @@ namespace xmltooling {
         // Getters\r
         const XMLCh* getCanonicalizationMethod() const { return m_c14n ? m_c14n : DSIGConstants::s_unicodeStrURIEXC_C14N_NOC; }\r
         const XMLCh* getSignatureAlgorithm() const { return m_sm ? m_sm : DSIGConstants::s_unicodeStrURIRSA_SHA1; }\r
-        DSIGKeyInfoList* getKeyInfo() const;\r
 \r
         // Setters\r
         void setCanonicalizationMethod(const XMLCh* c14n) { m_c14n = prepareForAssignment(m_c14n,c14n); }\r
@@ -72,7 +71,7 @@ namespace xmltooling {
     class XMLTOOL_DLLLOCAL XMLSecSignatureBuilder : public virtual XMLObjectBuilder\r
     {\r
     public:\r
-        XMLObject* buildObject(const DOMElement* e=NULL) const {\r
+        XMLSecSignatureImpl* buildObject() const {\r
             return new XMLSecSignatureImpl();\r
         }\r
     };\r

diff --git a/xmltoolingtest/ComplexXMLObjectTest.h b/xmltoolingtest/ComplexXMLObjectTest.h
index 82c23ec..de45855 100644 (file)
--- a/xmltoolingtest/ComplexXMLObjectTest.h
+++ b/xmltoolingtest/ComplexXMLObjectTest.h
@@ -43,7 +43,7 @@ public:
         TS_ASSERT(b!=NULL);\r
 \r
         auto_ptr<WildcardXMLObject> wcObject(\r
-            dynamic_cast<WildcardXMLObject*>(b->buildObject(doc->getDocumentElement())->unmarshall(doc->getDocumentElement(),true))\r
+            dynamic_cast<WildcardXMLObject*>(b->buildFromDocument(doc))\r
             );\r
         TS_ASSERT(wcObject.get()!=NULL);\r
 \r

diff --git a/xmltoolingtest/MarshallingTest.h b/xmltoolingtest/MarshallingTest.h
index 79dfaf1..13e07e9 100644 (file)
--- a/xmltoolingtest/MarshallingTest.h
+++ b/xmltoolingtest/MarshallingTest.h
@@ -35,7 +35,7 @@ public:
         TS_TRACE("testMarshallingWithAttributes");\r
 \r
         auto_ptr_XMLCh expected("Firefly");\r
-        auto_ptr<SimpleXMLObject> sxObject(dynamic_cast<SimpleXMLObject*>(XMLObjectBuilder::getBuilder(m_qname)->buildObject()));\r
+        auto_ptr<SimpleXMLObject> sxObject(dynamic_cast<SimpleXMLObject*>(XMLObjectBuilder::buildOne(m_qname)));\r
         TS_ASSERT(sxObject.get()!=NULL);\r
         sxObject->setId(expected.get());\r
         \r
@@ -54,7 +54,7 @@ public:
         TS_TRACE("testMarshallingWithElementContent");\r
 \r
         auto_ptr_XMLCh expected("Sample Content");\r
-        auto_ptr<SimpleXMLObject> sxObject(dynamic_cast<SimpleXMLObject*>(XMLObjectBuilder::getBuilder(m_qname)->buildObject()));\r
+        auto_ptr<SimpleXMLObject> sxObject(dynamic_cast<SimpleXMLObject*>(XMLObjectBuilder::buildOne(m_qname)));\r
         TS_ASSERT(sxObject.get()!=NULL);\r
         sxObject->setValue(expected.get());\r
         \r

diff --git a/xmltoolingtest/SignatureTest.h b/xmltoolingtest/SignatureTest.h
index 2582b15..5e02520 100644 (file)
--- a/xmltoolingtest/SignatureTest.h
+++ b/xmltoolingtest/SignatureTest.h
@@ -115,7 +115,7 @@ public:
         kids[1]->setValue(bar.get());\r
         \r
         // Append a Signature.\r
-        Signature* sig=dynamic_cast<Signature*>(XMLObjectBuilder::buildObject(QName(XMLConstants::XMLSIG_NS,Signature::LOCAL_NAME)));\r
+        Signature* sig=dynamic_cast<Signature*>(XMLObjectBuilder::buildOne(QName(XMLConstants::XMLSIG_NS,Signature::LOCAL_NAME)));\r
         sxObject->setSignature(sig);\r
         \r
         // Signing context for the whole document.\r
@@ -129,7 +129,7 @@ public:
 \r
         istringstream in(buf);\r
         DOMDocument* doc=nonvalidatingPool->parse(in);\r
-        auto_ptr<SimpleXMLObject> sxObject2(dynamic_cast<SimpleXMLObject*>(b->buildObject()->unmarshall(doc->getDocumentElement(),true)));\r
+        auto_ptr<SimpleXMLObject> sxObject2(dynamic_cast<SimpleXMLObject*>(b->buildFromDocument(doc)));\r
         TS_ASSERT(sxObject2.get()!=NULL);\r
         TS_ASSERT(sxObject2->getSignature()!=NULL);\r
         \r

diff --git a/xmltoolingtest/UnmarshallingTest.h b/xmltoolingtest/UnmarshallingTest.h
index cc7c25c..d4f41cc 100644 (file)
--- a/xmltoolingtest/UnmarshallingTest.h
+++ b/xmltoolingtest/UnmarshallingTest.h
@@ -66,7 +66,7 @@ public:
         TS_ASSERT(b!=NULL);\r
 \r
         auto_ptr<SimpleXMLObject> sxObject(\r
-            dynamic_cast<SimpleXMLObject*>(b->buildObject()->unmarshall(doc->getDocumentElement(),true))\r
+            dynamic_cast<SimpleXMLObject*>(b->buildFromDocument(doc))\r
             );\r
         TS_ASSERT(sxObject.get()!=NULL);\r
 \r
@@ -86,7 +86,7 @@ public:
         TS_ASSERT(b!=NULL);\r
 \r
         auto_ptr<SimpleXMLObject> sxObject(\r
-            dynamic_cast<SimpleXMLObject*>(b->buildObject()->unmarshall(doc->getDocumentElement(),true))\r
+            dynamic_cast<SimpleXMLObject*>(b->buildFromDocument(doc))\r
             );\r
         TS_ASSERT(sxObject.get()!=NULL);\r
 \r
@@ -106,7 +106,7 @@ public:
         TS_ASSERT(b!=NULL);\r
 \r
         auto_ptr<SimpleXMLObject> sxObject(\r
-            dynamic_cast<SimpleXMLObject*>(b->buildObject()->unmarshall(doc->getDocumentElement(),true))\r
+            dynamic_cast<SimpleXMLObject*>(b->buildFromDocument(doc))\r
             );\r
         TS_ASSERT(sxObject.get()!=NULL);\r
 \r
@@ -125,8 +125,7 @@ public:
         const XMLObjectBuilder* b = XMLObjectBuilder::getBuilder(doc->getDocumentElement());\r
         TS_ASSERT(b!=NULL);\r
 \r
-        auto_ptr<XMLObject> sxObject(b->buildObject());\r
-        TS_ASSERT_THROWS(sxObject->unmarshall(doc->getDocumentElement(),true),UnmarshallingException);\r
+        TS_ASSERT_THROWS(b->buildFromDocument(doc),UnmarshallingException);\r
         doc->release();\r
     }\r
 };\r

diff --git a/xmltoolingtest/XMLObjectBaseTestCase.h b/xmltoolingtest/XMLObjectBaseTestCase.h
index f36c032..873f227 100644 (file)
--- a/xmltoolingtest/XMLObjectBaseTestCase.h
+++ b/xmltoolingtest/XMLObjectBaseTestCase.h
@@ -145,7 +145,7 @@ private:
 class SimpleXMLObjectBuilder : public XMLObjectBuilder
 {
 public:
-    SimpleXMLObject* buildObject(const DOMElement* e=NULL) const {
+    SimpleXMLObject* buildObject() const {
         return new SimpleXMLObject();
     }
 };
@@ -213,8 +213,18 @@ public:
 class WildcardXMLObjectBuilder : public XMLObjectBuilder
 {
 public:
-    WildcardXMLObject* buildObject(const DOMElement* e=NULL) const {
-        return new WildcardXMLObject(e->getNamespaceURI(),e->getLocalName(),e->getPrefix());
+    WildcardXMLObject* buildObject() const {
+        throw XMLObjectException("Default build operation is unsupported.");
+    }
+
+    WildcardXMLObject* buildObject(const QName& q) const {
+        return new WildcardXMLObject(q.getNamespaceURI(),q.getLocalPart(),q.getPrefix());
+    }
+
+    WildcardXMLObject* buildFromElement(DOMElement* e, bool bindDocument=false) const {
+        auto_ptr<WildcardXMLObject> ret(new WildcardXMLObject(e->getNamespaceURI(),e->getLocalName(),e->getPrefix()));
+        ret->unmarshall(e,bindDocument);
+        return ret.release();
     }
 };
 

diff --git a/xmltoolingtest/xmltoolingtest.h b/xmltoolingtest/xmltoolingtest.h
index 50a66d3..84b52c1 100644 (file)
--- a/xmltoolingtest/xmltoolingtest.h
+++ b/xmltoolingtest/xmltoolingtest.h
@@ -79,7 +79,7 @@ public:
         const XMLObjectBuilder* b=XMLObjectBuilder::getBuilder(doc->getDocumentElement());\r
         TS_ASSERT(b!=NULL);\r
 \r
-        auto_ptr<XMLObject> xmlObject(b->buildObject(doc->getDocumentElement())->unmarshall(doc->getDocumentElement(),true)); // bind document\r
+        auto_ptr<XMLObject> xmlObject(b->buildFromDocument(doc)); // bind document\r
         TS_ASSERT(xmlObject.get()!=NULL);\r
 \r
         auto_ptr<XMLObject> clonedObject(xmlObject->clone());\r
@@ -107,7 +107,7 @@ public:
         const XMLObjectBuilder* b=XMLObjectBuilder::getBuilder(doc->getDocumentElement());\r
         TS_ASSERT(b!=NULL);\r
 \r
-        auto_ptr<XMLObject> xmlObject(b->buildObject(doc->getDocumentElement())->unmarshall(doc->getDocumentElement(),true)); // bind document\r
+        auto_ptr<XMLObject> xmlObject(b->buildFromDocument(doc)); // bind document\r
         TS_ASSERT(xmlObject.get()!=NULL);\r
 \r
         DOMDocument* newDoc=nonvalidatingPool->newDocument();\r