using namespace xmltooling;\r
using namespace std;\r
\r
-class _release : public unary_function<XMLCh*,void> {\r
-public:\r
- void operator()(pair<QName,XMLCh*> p) const {\r
- XMLString::release(&(p.second));\r
- }\r
-};\r
-\r
AbstractAttributeExtensibleXMLObject::~AbstractAttributeExtensibleXMLObject()\r
{\r
- for_each(m_attributeMap.begin(),m_attributeMap.end(),_release());\r
+ for (map<QName,XMLCh*>::iterator i=m_attributeMap.begin(); i!=m_attributeMap.end(); i++)\r
+ XMLString::release(&(i->second));\r
}\r
\r
AbstractAttributeExtensibleXMLObject::AbstractAttributeExtensibleXMLObject(const AbstractAttributeExtensibleXMLObject& src)\r
/**\r
* @file AbstractAttributeExtensibleXMLObject.h\r
* \r
- * An abstract implementation of an AttributeExtensibleXMLObject \r
+ * AbstractXMLObject mixin that implements AttributeExtensibleXMLObject\r
*/\r
\r
#ifndef __xmltooling_absattrextxmlobj_h__\r
namespace xmltooling {\r
\r
/**\r
- * An abstract implementation of an AttributeExtensibleXMLObject.\r
+ * AbstractXMLObject mixin that implements AttributeExtensibleXMLObject.\r
+ * Inherit from this class to add support for attribute wildcarding.\r
*/\r
class XMLTOOL_API AbstractAttributeExtensibleXMLObject : public virtual AttributeExtensibleXMLObject, public virtual AbstractXMLObject\r
{\r
*/\r
\r
/**\r
- * AbstractElementProxy.cpp\r
+ * AbstractChildlessElement.cpp\r
* \r
- * Extension of AbstractDOMCachingXMLObject that implements an ElementProxy. \r
+ * Extension of AbstractXMLObject that implements childlessness \r
*/\r
\r
#include "internal.h"\r
-#include "AbstractElementProxy.h"\r
+#include "AbstractChildlessElement.h"\r
\r
using namespace xmltooling;\r
using namespace std;\r
\r
-void AbstractElementProxy::setTextContent(const XMLCh* value)\r
-{\r
- m_value=prepareForAssignment(m_value,value);\r
-}\r
+// shared "empty" list of children for childless objects\r
\r
-ListOf(XMLObject) AbstractElementProxy::getXMLObjects()\r
-{\r
- return ListOf(XMLObject)(this,m_children,NULL,m_children.end());\r
-}\r
+list<XMLObject*> AbstractChildlessElement::m_no_children;\r
--- /dev/null
+/*\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 AbstractChildlessElement.h\r
+ * \r
+ * AbstractXMLObject mixin that blocks children\r
+ */\r
+\r
+#ifndef __xmltooling_absnokids_h__\r
+#define __xmltooling_absnokids_h__\r
+\r
+#include <xmltooling/AbstractXMLObject.h>\r
+\r
+#if defined (_MSC_VER)\r
+ #pragma warning( push )\r
+ #pragma warning( disable : 4250 4251 )\r
+#endif\r
+\r
+namespace xmltooling {\r
+\r
+ /**\r
+ * AbstractXMLObject mixin that blocks children.\r
+ * Inherit from this class to implement a childless element.\r
+ */\r
+ class XMLTOOL_API AbstractChildlessElement : public virtual AbstractXMLObject\r
+ {\r
+ public:\r
+ virtual ~AbstractChildlessElement() {}\r
+ \r
+ bool hasChildren() const {\r
+ return false;\r
+ }\r
+\r
+ const std::list<XMLObject*>& getOrderedChildren() const {\r
+ return m_no_children;\r
+ }\r
+\r
+ protected:\r
+ AbstractChildlessElement() {}\r
+ \r
+ /** Copy constructor. */\r
+ AbstractChildlessElement(const AbstractChildlessElement& src) {}\r
+\r
+ private:\r
+ static std::list<XMLObject*> m_no_children;\r
+ };\r
+ \r
+};\r
+\r
+#if defined (_MSC_VER)\r
+ #pragma warning( pop )\r
+#endif\r
+\r
+#endif /* __xmltooling_absnokids_h__ */\r
--- /dev/null
+/*
+* Copyright 2001-2006 Internet2
+ *
+* Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * AbstractComplexElement.cpp
+ *
+ * Implementation of AbstractComplexElement.
+ */
+
+#include "internal.h"
+#include "AbstractComplexElement.h"
+
+#include <algorithm>
+
+using namespace xmltooling;
+
+AbstractComplexElement::~AbstractComplexElement() {
+ std::for_each(m_children.begin(), m_children.end(), cleanup<XMLObject>());
+}
--- /dev/null
+/*\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 AbstractComplexElement.h\r
+ * \r
+ * AbstractXMLObject mixin that implements children\r
+ */\r
+\r
+#ifndef __xmltooling_abscomplexel_h__\r
+#define __xmltooling_abscomplexel_h__\r
+\r
+#include <xmltooling/AbstractXMLObject.h>\r
+\r
+#if defined (_MSC_VER)\r
+ #pragma warning( push )\r
+ #pragma warning( disable : 4250 4251 )\r
+#endif\r
+\r
+namespace xmltooling {\r
+\r
+ /**\r
+ * AbstractXMLObject mixin that implements children.\r
+ * Inherit from this class to implement an element with child objects.\r
+ * No unprotected access to them is supplied here.\r
+ */\r
+ class XMLTOOL_API AbstractComplexElement : public virtual AbstractXMLObject\r
+ {\r
+ public:\r
+ virtual ~AbstractComplexElement();\r
+ \r
+ bool hasChildren() const {\r
+ return !m_children.empty();\r
+ }\r
+\r
+ const std::list<XMLObject*>& getOrderedChildren() const {\r
+ return m_children;\r
+ }\r
+\r
+ protected:\r
+ AbstractComplexElement() {}\r
+ \r
+ /** Copy constructor. */\r
+ AbstractComplexElement(const AbstractComplexElement& src) {}\r
+\r
+ /**\r
+ * Underlying list of child objects.\r
+ * Manages the lifetime of the children.\r
+ */\r
+ std::list<XMLObject*> m_children;\r
+ };\r
+ \r
+};\r
+\r
+#if defined (_MSC_VER)\r
+ #pragma warning( pop )\r
+#endif\r
+\r
+#endif /* __xmltooling_abscomplexel_h__ */\r
"releasing cached DOM representation for children with propagation set to %s",\r
propagateRelease ? "true" : "false"\r
);\r
- for_each(m_children.begin(),m_children.end(),bind2nd(_release(),propagateRelease));\r
+ const list<XMLObject*>& children=getOrderedChildren();\r
+ for_each(children.begin(),children.end(),bind2nd(_release(),propagateRelease));\r
}\r
}\r
\r
/**\r
* @file AbstractDOMCachingXMLObject.h\r
* \r
- * Extension of AbstractXMLObject that adds DOM caching methods\r
+ * AbstractXMLObject mixin that implements DOM caching\r
*/\r
\r
#if !defined(__xmltooling_abstractdomxmlobj_h__)\r
namespace xmltooling {\r
\r
/**\r
- * Extension of AbstractXMLObject that adds DOM caching methods\r
+ * AbstractXMLObject mixin that implements DOM caching.\r
+ * Inherit from this class to implement standard DOM caching behavior.\r
*/\r
class XMLTOOL_API AbstractDOMCachingXMLObject : public virtual AbstractXMLObject\r
{\r
/**\r
* @file AbstractElementProxy.h\r
* \r
- * An abstract implementation of an ElementProxy \r
+ * AbstractXMLObject mixin that implements an open content model \r
*/\r
\r
#ifndef __xmltooling_abseleproxy_h__\r
#define __xmltooling_abseleproxy_h__\r
\r
-#include <xmltooling/AbstractXMLObject.h>\r
+#include <xmltooling/AbstractComplexElement.h>\r
+#include <xmltooling/AbstractSimpleElement.h>\r
#include <xmltooling/ElementProxy.h>\r
\r
#if defined (_MSC_VER)\r
namespace xmltooling {\r
\r
/**\r
- * An abstract implementation of an ExtensibleXMLObject.\r
+ * AbstractXMLObject mixin that implements an open content model.\r
+ * Inherit from this class to merge both simple and complex content\r
+ * and expose the underlying child collection in read/write mode.\r
*/\r
- class XMLTOOL_API AbstractElementProxy : public virtual ElementProxy, public virtual AbstractXMLObject\r
+ class XMLTOOL_API AbstractElementProxy\r
+ : public virtual ElementProxy, public AbstractSimpleElement, public AbstractComplexElement\r
{\r
public:\r
virtual ~AbstractElementProxy() {}\r
\r
- virtual const XMLCh* getTextContent() const {\r
- return m_value;\r
+ virtual ListOf(XMLObject) getXMLObjects() {\r
+ return ListOf(XMLObject)(this,m_children,NULL,m_children.end());\r
}\r
- \r
- virtual void setTextContent(const XMLCh* value);\r
- \r
- virtual ListOf(XMLObject) getXMLObjects();\r
\r
virtual const std::list<XMLObject*>& getXMLObjects() const {\r
return m_children;\r
}\r
\r
protected:\r
- AbstractElementProxy() : m_value(NULL) {}\r
+ AbstractElementProxy() {}\r
\r
/** Copy constructor. */\r
AbstractElementProxy(const AbstractElementProxy& src)\r
- : AbstractXMLObject(src), m_value(XMLString::replicate(src.m_value)) {}\r
-\r
- private:\r
- XMLCh* m_value;\r
+ : AbstractXMLObject(src), AbstractSimpleElement(src) {}\r
};\r
\r
};\r
--- /dev/null
+/*\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 AbstractSimpleElement.h\r
+ * \r
+ * AbstractXMLObject mixin that implements a simple string-based content model \r
+ */\r
+\r
+#ifndef __xmltooling_abssimpleel_h__\r
+#define __xmltooling_abssimpleel_h__\r
+\r
+#include <xmltooling/AbstractXMLObject.h>\r
+#include <xmltooling/SimpleElement.h>\r
+\r
+#if defined (_MSC_VER)\r
+ #pragma warning( push )\r
+ #pragma warning( disable : 4250 4251 )\r
+#endif\r
+\r
+namespace xmltooling {\r
+\r
+ /**\r
+ * AbstractXMLObject mixin that implements a simple string-based content model.\r
+ * Inherit from this class to support string-based element content.\r
+ */\r
+ class XMLTOOL_API AbstractSimpleElement : public virtual SimpleElement, public virtual AbstractXMLObject\r
+ {\r
+ public:\r
+ virtual ~AbstractSimpleElement() {\r
+ XMLString::release(&m_value);\r
+ }\r
+ \r
+ virtual const XMLCh* getTextContent() const {\r
+ return m_value;\r
+ }\r
+ \r
+ virtual void setTextContent(const XMLCh* value) {\r
+ m_value=prepareForAssignment(m_value,value);\r
+ }\r
+ \r
+ protected:\r
+ AbstractSimpleElement() : m_value(NULL) {}\r
+ \r
+ /** Copy constructor. */\r
+ AbstractSimpleElement(const AbstractSimpleElement& src)\r
+ : AbstractXMLObject(src), m_value(XMLString::replicate(src.m_value)) {}\r
+\r
+ private:\r
+ XMLCh* m_value;\r
+ };\r
+ \r
+};\r
+\r
+#if defined (_MSC_VER)\r
+ #pragma warning( pop )\r
+#endif\r
+\r
+#endif /* __xmltooling_abssimpleel_h__ */\r
using namespace xmltooling;
-AbstractXMLObject::~AbstractXMLObject() {
- delete m_typeQname;
- std::for_each(m_children.begin(), m_children.end(), cleanup<XMLObject>());
-}
-
AbstractXMLObject::AbstractXMLObject(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
: m_log(&log4cpp::Category::getInstance(XMLTOOLING_LOGCAT".XMLObject")),
m_parent(NULL), m_elementQname(nsURI, localName, prefix), m_typeQname(NULL)
m_typeQname=new QName(*src.m_typeQname);
}
-XMLObject* AbstractXMLObject::prepareForAssignment(XMLObject* oldValue, XMLObject* newValue) {
+XMLCh* AbstractXMLObject::prepareForAssignment(XMLCh* oldValue, const XMLCh* newValue)
+{
+ XMLCh* newString = XMLString::replicate(newValue);
+ XMLString::trim(newString);
+ if (!XMLString::equals(oldValue,newValue)) {
+ releaseThisandParentDOM();
+ XMLString::release(&oldValue);
+ return newString;
+ }
+ XMLString::release(&newString);
+ return oldValue;
+}
+XMLObject* AbstractXMLObject::prepareForAssignment(XMLObject* oldValue, XMLObject* newValue)
+{
if (newValue && newValue->hasParent())
throw XMLObjectException("child XMLObject cannot be added - it is already the child of another XMLObject");
\r
/**\r
* An abstract implementation of XMLObject.\r
+ * This is the primary concrete base class, and supplies basic namespace,\r
+ * type, and parent handling. Most implementation classes should not\r
+ * directly inherit from this class, but rather from the various mixins\r
+ * that supply the rest of the XMLObject interface, as required.\r
*/\r
class XMLTOOL_API AbstractXMLObject : public virtual XMLObject\r
{\r
public:\r
- virtual ~AbstractXMLObject();\r
+ virtual ~AbstractXMLObject() {\r
+ delete m_typeQname;\r
+ }\r
\r
const QName& getElementQName() const {\r
return m_elementQname;\r
m_parent = parent;\r
}\r
\r
- bool hasChildren() const {\r
- return !m_children.empty();\r
- }\r
-\r
- const std::list<XMLObject*>& getOrderedChildren() const {\r
- return m_children;\r
- }\r
-\r
protected:\r
/**\r
* Constructor\r
* \r
* @return the value that should be assigned\r
*/\r
- XMLCh* prepareForAssignment(XMLCh* oldValue, const XMLCh* newValue) {\r
- XMLCh* newString = XMLString::replicate(newValue);\r
- XMLString::trim(newString);\r
- if (!XMLString::equals(oldValue,newValue)) {\r
- releaseThisandParentDOM();\r
- XMLString::release(&oldValue);\r
- return newString;\r
- }\r
- XMLString::release(&newString);\r
- return oldValue; \r
- }\r
+ XMLCh* prepareForAssignment(XMLCh* oldValue, const XMLCh* newValue);\r
\r
/**\r
* A helper function for derived classes, for assignment of (singleton) XML objects.\r
XMLObject* prepareForAssignment(XMLObject* oldValue, XMLObject* newValue);\r
\r
/**\r
- * Underlying list of child objects.\r
- * Manages the lifetime of the children.\r
- */\r
- std::list<XMLObject*> m_children;\r
-\r
- /**\r
* Set of namespaces associated with the object.\r
*/\r
mutable std::set<Namespace> m_namespaces;\r
#if !defined(__xmltooling_eleproxy_h__)\r
#define __xmltooling_eleproxy_h__\r
\r
+#include <xmltooling/SimpleElement.h>\r
#include <xmltooling/XMLObject.h>\r
#include <xmltooling/util/XMLObjectChildrenList.h>\r
\r
/**\r
* An XMLObject with an open content model.\r
*/\r
- class XMLTOOL_API ElementProxy : public virtual XMLObject\r
+ class XMLTOOL_API ElementProxy : public virtual SimpleElement\r
{\r
public:\r
ElementProxy() {}\r
virtual ~ElementProxy() {}\r
\r
/**\r
- * Gets the text content of the object\r
- * \r
- * @return the text content, or NULL\r
- */\r
- virtual const XMLCh* getTextContent() const=0;\r
- \r
- /**\r
- * Sets (or clears) the text content of the object \r
- * \r
- * @param value value to set, or NULL to clear\r
- */\r
- virtual void setTextContent(const XMLCh* value)=0;\r
-\r
- /**\r
* Gets a mutable list of child objects\r
* \r
* @return mutable list of child objects\r
libxmltoolinginclude_HEADERS = \
AbstractAttributeExtensibleXMLObject.h \
+ AbstractChildlessElement.h \
+ AbstractComplexElement.h \
AbstractDOMCachingXMLObject.h \
AbstractElementProxy.h \
+ AbstractSimpleElement.h \
AbstractXMLObject.h \
AttributeExtensibleXMLObject.h \
base.h \
ILockable.h \
Namespace.h \
QName.h \
+ SimpleElement.h \
unicode.h \
version.h \
XMLObject.h \
libxmltooling_la_SOURCES = \
AbstractAttributeExtensibleXMLObject.cpp \
+ AbstractChildlessElement.cpp \
+ AbstractComplexElement.cpp \
AbstractDOMCachingXMLObject.cpp \
- AbstractElementProxy.cpp \
AbstractXMLObject.cpp \
exceptions.cpp \
Namespace.cpp \
--- /dev/null
+/*\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 SimpleElement.h\r
+ * \r
+ * An XMLObject with a simple content model. \r
+ */\r
+\r
+#ifndef __xmltooling_simpleel_h__\r
+#define __xmltooling_simpleel_h__\r
+\r
+#include <xmltooling/XMLObject.h>\r
+#include <xmltooling/util/XMLObjectChildrenList.h>\r
+\r
+using namespace xercesc;\r
+\r
+namespace xmltooling {\r
+\r
+ /**\r
+ * An XMLObject with a simple content model.\r
+ */\r
+ class XMLTOOL_API SimpleElement : public virtual XMLObject\r
+ {\r
+ public:\r
+ SimpleElement() {}\r
+ virtual ~SimpleElement() {}\r
+ \r
+ /**\r
+ * Gets the text content of the object\r
+ * \r
+ * @return the text content, or NULL\r
+ */\r
+ virtual const XMLCh* getTextContent() const=0;\r
+ \r
+ /**\r
+ * Sets (or clears) the text content of the object \r
+ * \r
+ * @param value value to set, or NULL to clear\r
+ */\r
+ virtual void setTextContent(const XMLCh* value)=0;\r
+ };\r
+ \r
+};\r
+\r
+#endif /* __xmltooling_simpleel_h__ */\r
}
/**
- * Creates an empty XMLObject using the default build method, if a builder can be found.
- *
- * @param key the element key used to locate a builder
- * @return the empty object or NULL if no builder is available
- */
- static XMLObject* buildOne(const QName& key) {
- const XMLObjectBuilder* b=getBuilder(key);
- if (b)
- return b->buildFromQName(key);
- b=getDefaultBuilder();
- return b ? b->buildFromQName(key) : NULL;
- }
-
- /**
* Creates an unmarshalled XMLObject using the default build method, if a builder can be found.
*
* @param element the unmarshalling source
void XMLToolingInternalConfig::term()
{
XMLObjectBuilder::destroyBuilders();
+ Validator::destroyValidators();
+ XMLToolingException::deregisterFactories();
for (vector<void*>::reverse_iterator i=m_libhandles.rbegin(); i!=m_libhandles.rend(); i++) {
#if defined(WIN32)
}
/**
- * Declares abstract get/set methods for named XML element content.
+ * Declares aliased get/set methods for named XML element content.
*
* @param proper the proper name to label the element's content
*/
#define DECL_XMLOBJECT_CONTENT(proper) \
XMLTOOLING_DOXYGEN(Returns proper.) \
- virtual const XMLCh* get##proper() const=0; \
- XMLTOOLING_DOXYGEN(Sets proper.) \
- virtual void set##proper(const XMLCh* proper)=0
+ const XMLCh* get##proper() const { \
+ return getTextContent(); \
+ } \
+ XMLTOOLING_DOXYGEN(Sets or clears proper.) \
+ void set##proper(const XMLCh* proper) { \
+ setTextContent(proper); \
+ }
/**
- * Implements get/set methods and a private member for named XML element content.
- *
- * @param proper the proper name to label the element's content
+ * Implements marshalling/unmarshalling for element content.
*/
-#define IMPL_XMLOBJECT_CONTENT(proper) \
- private: \
- XMLCh* m_##proper; \
- public: \
- const XMLCh* get##proper() const { \
- return m_##proper; \
- } \
- void set##proper(const XMLCh* proper) { \
- m_##proper = prepareForAssignment(m_##proper,proper); \
- } \
+#define IMPL_XMLOBJECT_CONTENT \
protected: \
void marshallElementContent(DOMElement* domElement) const { \
- if(get##proper()) { \
- domElement->appendChild(domElement->getOwnerDocument()->createTextNode(get##proper())); \
+ if(getTextContent()) { \
+ domElement->appendChild(domElement->getOwnerDocument()->createTextNode(getTextContent())); \
} \
} \
void processElementContent(const XMLCh* elementContent) { \
- set##proper(elementContent); \
+ setTextContent(elementContent); \
}
* @param desc documentation for class
*/
#define DECL_XMLOBJECT_SIMPLE(linkage,cname,proper,desc) \
- BEGIN_XMLOBJECT(linkage,cname,xmltooling::XMLObject,desc); \
+ BEGIN_XMLOBJECT(linkage,cname,xmltooling::SimpleElement,desc); \
DECL_XMLOBJECT_CONTENT(proper); \
END_XMLOBJECT
*
* @param linkage linkage specifier for the class
* @param cname the name of the XMLObject specialization
- * @param proper the proper name to label the element's content
*/
-#define DECL_XMLOBJECTIMPL_SIMPLE(linkage,cname,proper) \
+#define DECL_XMLOBJECTIMPL_SIMPLE(linkage,cname) \
class linkage cname##Impl \
: public cname, \
+ public xmltooling::AbstractSimpleElement, \
+ public xmltooling::AbstractChildlessElement, \
public xmltooling::AbstractDOMCachingXMLObject, \
public xmltooling::AbstractValidatingXMLObject, \
public xmltooling::AbstractXMLObjectMarshaller, \
public: \
virtual ~cname##Impl() {} \
cname##Impl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType) \
- : xmltooling::AbstractXMLObject(nsURI, localName, prefix, schemaType), m_##proper(NULL) { \
+ : xmltooling::AbstractXMLObject(nsURI, localName, prefix, schemaType) { \
} \
cname##Impl(const cname##Impl& src) \
: xmltooling::AbstractXMLObject(src), \
+ xmltooling::AbstractSimpleElement(src), \
xmltooling::AbstractDOMCachingXMLObject(src), \
- xmltooling::AbstractValidatingXMLObject(src), \
- m_##proper(XMLString::replicate(src.m_##proper)) { \
- } \
+ xmltooling::AbstractValidatingXMLObject(src) {} \
IMPL_XMLOBJECT_CLONE(cname) \
- IMPL_XMLOBJECT_CONTENT(proper) \
+ IMPL_XMLOBJECT_CONTENT \
}
/**
*
* @param linkage linkage specifier for the class
* @param cname the name of the XMLObject specialization
- * @param proper the proper name to label the element's content
*/
-#define XMLOBJECTVALIDATOR_SIMPLE(linkage,cname,proper) \
+#define XMLOBJECTVALIDATOR_SIMPLE(linkage,cname) \
BEGIN_XMLOBJECTVALIDATOR(linkage,cname); \
- XMLOBJECTVALIDATOR_REQUIRE(cname,proper); \
+ XMLOBJECTVALIDATOR_REQUIRE(cname,TextContent); \
END_XMLOBJECTVALIDATOR
#include <utility>
* @param name the exception class name
* @param ns the exception class C++ namespace
*/
-#define REGISTER_EXCEPTION_FACTORY(name,ns) XMLToolingException::registerFactory(#ns".."#name,name##Factory)
+#define REGISTER_EXCEPTION_FACTORY(name,ns) XMLToolingException::registerFactory(#ns"::"#name,name##Factory)
#if defined (_MSC_VER)
#pragma warning( push )
m_factoryMap.erase(exceptionClass);
}
+ /**
+ * Unregisters all factories.
+ */
+ static void deregisterFactories() {
+ m_factoryMap.clear();
+ }
+
private:
typedef std::map<std::string,ExceptionFactory*> ExceptionFactoryMap;
static ExceptionFactoryMap m_factoryMap;
#if !defined(__xmltooling_unkelement_h__)\r
#define __xmltooling_unkelement_h__\r
\r
+#include <xmltooling/AbstractChildlessElement.h>\r
#include <xmltooling/exceptions.h>\r
#include <xmltooling/XMLObjectBuilder.h>\r
#include <xmltooling/io/AbstractXMLObjectMarshaller.h>\r
namespace xmltooling {\r
\r
/// @cond off\r
- class XMLTOOL_DLLLOCAL UnknownElementImpl : public AbstractDOMCachingXMLObject\r
+ class XMLTOOL_DLLLOCAL UnknownElementImpl : public AbstractChildlessElement, public AbstractDOMCachingXMLObject\r
{\r
public:\r
UnknownElementImpl(const XMLCh* namespaceURI=NULL, const XMLCh* elementLocalName=NULL, const XMLCh* namespacePrefix=NULL)\r
#include <xmltooling/ElementProxy.h>
#include <xmltooling/exceptions.h>
+#include <xmltooling/SimpleElement.h>
#include <xmltooling/XMLObjectBuilder.h>
#include <xmltooling/util/XMLConstants.h>
#include <xmltooling/validation/ValidatingXMLObject.h>
static const XMLCh TYPE_NAME[];
END_XMLOBJECT;
- BEGIN_XMLOBJECT(XMLTOOL_API,KeyValue,xmltooling::XMLObject,XML Digital Signature version 20020212 KeyValue element);
+ BEGIN_XMLOBJECT(XMLTOOL_API,KeyValue,xmltooling::SimpleElement,XML Digital Signature version 20020212 KeyValue element);
DECL_XMLOBJECT_CHILD(DSAKeyValue);
DECL_XMLOBJECT_CHILD(RSAKeyValue);
DECL_XMLOBJECT_CHILD(XMLObject);
- DECL_XMLOBJECT_CONTENT(TextContent);
/** KeyValueType local name */
static const XMLCh TYPE_NAME[];
END_XMLOBJECT;
static const XMLCh TYPE_NAME[];
END_XMLOBJECT;
- BEGIN_XMLOBJECT(XMLTOOL_API,KeyInfo,xmltooling::ElementProxy,XML Digital Signature version 20020212 KeyInfo element);
+ BEGIN_XMLOBJECT(XMLTOOL_API,KeyInfo,xmltooling::XMLObject,XML Digital Signature version 20020212 KeyInfo element);
DECL_XMLOBJECT_ATTRIB(Id,ID);
DECL_XMLOBJECT_CHILDREN(X509Data);
DECL_XMLOBJECT_CHILDREN(KeyName);
DECL_XMLOBJECT_CHILDREN(MgmtData);
DECL_XMLOBJECT_CHILDREN(PGPData);
DECL_XMLOBJECT_CHILDREN(SPKIData);
+ DECL_XMLOBJECT_CHILDREN(XMLObject);
/** KeyInfoType local name */
static const XMLCh TYPE_NAME[];
END_XMLOBJECT;
DECL_XMLSIGOBJECTBUILDER(KeyInfo);
#ifdef XMLTOOLING_DECLARE_VALIDATORS
- XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,KeyName,Name);
- XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,MgmtData,Data);
- XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,Modulus,Value);
- XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,Exponent,Value);
- XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,Seed,Value);
- XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,PgenCounter,Value);
- XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,P,Value);
- XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,Q,Value);
- XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,G,Value);
- XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,Y,Value);
- XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,J,Value);
- XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,XPath,Expression);
- XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,X509IssuerName,Name);
- XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,X509SerialNumber,SerialNumber);
- XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,X509SKI,Value);
- XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,X509SubjectName,Name);
- XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,X509Certificate,Value);
- XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,X509CRL,Value);
- XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,SPKISexp,Value);
- XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,PGPKeyID,ID);
- XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,PGPKeyPacket,Packet);
+ XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,KeyName);
+ XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,MgmtData);
+ XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,Modulus);
+ XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,Exponent);
+ XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,Seed);
+ XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,PgenCounter);
+ XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,P);
+ XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,Q);
+ XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,G);
+ XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,Y);
+ XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,J);
+ XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,XPath);
+ XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,X509IssuerName);
+ XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,X509SerialNumber);
+ XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,X509SKI);
+ XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,X509SubjectName);
+ XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,X509Certificate);
+ XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,X509CRL);
+ XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,SPKISexp);
+ XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,PGPKeyID);
+ XMLOBJECTVALIDATOR_SIMPLE(XMLTOOL_DLLLOCAL,PGPKeyPacket);
BEGIN_XMLOBJECTVALIDATOR(XMLTOOL_DLLLOCAL,RSAKeyValue);
XMLOBJECTVALIDATOR_REQUIRE(RSAKeyValue,Modulus);
*/
#include "internal.h"
+#include "AbstractChildlessElement.h"
+#include "AbstractComplexElement.h"
#include "AbstractElementProxy.h"
+#include "AbstractSimpleElement.h"
#include "exceptions.h"
#include "io/AbstractXMLObjectMarshaller.h"
#include "io/AbstractXMLObjectUnmarshaller.h"
namespace xmlsignature {
class XMLTOOL_DLLLOCAL DSAKeyValueImpl : public DSAKeyValue,
+ public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
};
class XMLTOOL_DLLLOCAL RSAKeyValueImpl : public RSAKeyValue,
+ public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
};
class XMLTOOL_DLLLOCAL KeyValueImpl : public KeyValue,
+ public AbstractSimpleElement,
+ public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
}
KeyValueImpl(const KeyValueImpl& src)
- : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
+ : AbstractXMLObject(src), AbstractSimpleElement(src),
+ AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
init();
if (src.getDSAKeyValue())
setDSAKeyValue(src.getDSAKeyValue()->cloneDSAKeyValue());
setRSAKeyValue(src.getRSAKeyValue()->cloneRSAKeyValue());
if (src.getXMLObject())
setXMLObject(src.getXMLObject()->clone());
- setTextContent(src.getTextContent());
}
void init() {
- m_TextContent=NULL;
m_DSAKeyValue=NULL;
m_RSAKeyValue=NULL;
m_XMLObject=NULL;
IMPL_XMLOBJECT_CHILD(DSAKeyValue);
IMPL_XMLOBJECT_CHILD(RSAKeyValue);
IMPL_XMLOBJECT_CHILD(XMLObject);
- IMPL_XMLOBJECT_CONTENT(TextContent);
+ IMPL_XMLOBJECT_CONTENT;
protected:
void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
public AbstractXMLObjectUnmarshaller
{
public:
- virtual ~TransformImpl() {}
+ virtual ~TransformImpl() {
+ XMLString::release(&m_Algorithm);
+ }
TransformImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
: AbstractXMLObject(nsURI, localName, prefix, schemaType), m_Algorithm(NULL) {
IMPL_XMLOBJECT_CLONE(Transform);
IMPL_XMLOBJECT_ATTRIB(Algorithm);
IMPL_XMLOBJECT_CHILDREN(XPath,m_children.end());
+ IMPL_XMLOBJECT_CONTENT;
protected:
void marshallAttributes(DOMElement* domElement) const {
MARSHALL_XMLOBJECT_ATTRIB(Algorithm,ALGORITHM,NULL);
}
- void marshallElementContent(DOMElement* domElement) const {
- if(getTextContent()) {
- domElement->appendChild(domElement->getOwnerDocument()->createTextNode(getTextContent()));
- }
- }
-
- void processElementContent(const XMLCh* elementContent) {
- setTextContent(elementContent);
- }
-
void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
PROC_XMLOBJECT_CHILDREN(XPath,XMLConstants::XMLSIG_NS);
};
class XMLTOOL_DLLLOCAL TransformsImpl : public Transforms,
+ public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
};
class XMLTOOL_DLLLOCAL RetrievalMethodImpl : public RetrievalMethod,
+ public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
public:
- virtual ~RetrievalMethodImpl() {}
+ 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) {
};
class XMLTOOL_DLLLOCAL X509IssuerSerialImpl : public X509IssuerSerial,
+ public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
};
class XMLTOOL_DLLLOCAL X509DataImpl : public X509Data,
+ public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
};
class XMLTOOL_DLLLOCAL SPKIDataImpl : public SPKIData,
+ public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
};
class XMLTOOL_DLLLOCAL PGPDataImpl : public PGPData,
+ public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
};
class XMLTOOL_DLLLOCAL KeyInfoImpl : public KeyInfo,
+ public AbstractComplexElement,
+ public AbstractSimpleElement,
public AbstractDOMCachingXMLObject,
- public AbstractElementProxy,
public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
public:
- virtual ~KeyInfoImpl() {}
+ virtual ~KeyInfoImpl() {
+ XMLString::release(&m_Id);
+ }
KeyInfoImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
: AbstractXMLObject(nsURI, localName, prefix, schemaType), m_Id(NULL) {
}
KeyInfoImpl(const KeyInfoImpl& src)
- : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractElementProxy(src),
- AbstractValidatingXMLObject(src), m_Id(XMLString::replicate(src.m_Id)) {
+ : AbstractXMLObject(src),
+ AbstractDOMCachingXMLObject(src),
+ AbstractSimpleElement(src),
+ AbstractValidatingXMLObject(src),
+ m_Id(XMLString::replicate(src.m_Id)) {
+
for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
if (*i) {
X509Data* xd=dynamic_cast<X509Data*>(*i);
IMPL_XMLOBJECT_CHILDREN(MgmtData,m_children.end());
IMPL_XMLOBJECT_CHILDREN(SPKIData,m_children.end());
IMPL_XMLOBJECT_CHILDREN(PGPData,m_children.end());
+ IMPL_XMLOBJECT_CHILDREN(XMLObject,m_children.end());
+ IMPL_XMLOBJECT_CONTENT;
protected:
void marshallAttributes(DOMElement* domElement) const {
MARSHALL_XMLOBJECT_ID_ATTRIB(Id,ID,NULL);
}
- void marshallElementContent(DOMElement* domElement) const {
- if(getTextContent()) {
- domElement->appendChild(domElement->getOwnerDocument()->createTextNode(getTextContent()));
- }
- }
-
- void processElementContent(const XMLCh* elementContent) {
- setTextContent(elementContent);
- }
-
void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
PROC_XMLOBJECT_CHILDREN(X509Data,XMLConstants::XMLSIG_NS);
PROC_XMLOBJECT_CHILDREN(KeyName,XMLConstants::XMLSIG_NS);
}
};
- DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,KeyName,Name);
- DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,MgmtData,Data);
- DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Modulus,Value);
- DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Exponent,Value);
- DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Seed,Value);
- DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,PgenCounter,Value);
- DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,P,Value);
- DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Q,Value);
- DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,G,Value);
- DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Y,Value);
- DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,J,Value);
- DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,XPath,Expression);
- DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509IssuerName,Name);
- DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509SerialNumber,SerialNumber);
- DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509SKI,Value);
- DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509SubjectName,Name);
- DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509Certificate,Value);
- DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509CRL,Value);
- DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,SPKISexp,Value);
- DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,PGPKeyID,ID);
- DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,PGPKeyPacket,Packet);
+ DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,KeyName);
+ DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,MgmtData);
+ DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Modulus);
+ DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Exponent);
+ DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Seed);
+ DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,PgenCounter);
+ DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,P);
+ DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Q);
+ DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,G);
+ DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Y);
+ DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,J);
+ DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,XPath);
+ DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509IssuerName);
+ DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509SerialNumber);
+ DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509SKI);
+ DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509SubjectName);
+ DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509Certificate);
+ DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509CRL);
+ DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,SPKISexp);
+ DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,PGPKeyID);
+ DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,PGPKeyPacket);
};
#if defined (_MSC_VER)
}\r
\r
if (validateDescendants && hasChildren()) {\r
- for_each(m_children.begin(),m_children.end(),bind2nd(_validate(),validateDescendants));\r
+ const list<XMLObject*>& children=getOrderedChildren();\r
+ for_each(children.begin(),children.end(),bind2nd(_validate(),validateDescendants));\r
}\r
}\r
>\r
</File>\r
<File\r
- RelativePath=".\AbstractDOMCachingXMLObject.cpp"\r
+ RelativePath=".\AbstractChildlessElement.cpp"\r
>\r
</File>\r
<File\r
- RelativePath=".\AbstractElementProxy.cpp"\r
+ RelativePath=".\AbstractComplexElement.cpp"\r
+ >\r
+ </File>\r
+ <File\r
+ RelativePath=".\AbstractDOMCachingXMLObject.cpp"\r
>\r
</File>\r
<File\r
>\r
</File>\r
<File\r
+ RelativePath=".\AbstractChildlessElement.h"\r
+ >\r
+ </File>\r
+ <File\r
+ RelativePath=".\AbstractComplexElement.h"\r
+ >\r
+ </File>\r
+ <File\r
RelativePath=".\AbstractDOMCachingXMLObject.h"\r
>\r
</File>\r
>\r
</File>\r
<File\r
+ RelativePath=".\AbstractSimpleElement.h"\r
+ >\r
+ </File>\r
+ <File\r
RelativePath=".\AbstractXMLObject.h"\r
>\r
</File>\r
>\r
</File>\r
<File\r
+ RelativePath=".\SimpleElement.h"\r
+ >\r
+ </File>\r
+ <File\r
RelativePath=".\unicode.h"\r
>\r
</File>\r
params(1,"OpenSSLCryptoProvider::getRandom - OpenSSL random not properly initialised"));\r
\r
string buf=e7.toString();\r
- TS_TRACE(buf.c_str());\r
auto_ptr<XMLToolingException> ptr(XMLToolingException::fromString(buf.c_str()));\r
TS_ASSERT(typeid(*ptr)==typeid(MarshallingException));\r
TS_ASSERT(!strcmp(ptr->what(),"Foo is a bar."));\r
--- /dev/null
+/*\r
+ * Copyright 2001-2005 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
+#include "XMLObjectBaseTestCase.h"\r
+\r
+#include <fstream>\r
+#include <xmltooling/signature/KeyInfo.h>\r
+\r
+class KeyInfoTest : public CxxTest::TestSuite {\r
+public:\r
+ KeyInfoTest() {}\r
+\r
+ void setUp() {\r
+ XMLObjectBuilder::registerDefaultBuilder(new AnyElementBuilder());\r
+ }\r
+\r
+ void tearDown() {\r
+ XMLObjectBuilder::deregisterDefaultBuilder();\r
+ }\r
+\r
+ void testKeyInfo1() {\r
+ TS_TRACE("testKeyInfo1");\r
+\r
+ string path=data_path + "KeyInfo1.xml";\r
+ ifstream fs(path.c_str());\r
+ DOMDocument* doc=validatingPool->parse(fs);\r
+ TS_ASSERT(doc!=NULL);\r
+\r
+ const XMLObjectBuilder* b = XMLObjectBuilder::getBuilder(doc->getDocumentElement());\r
+ TS_ASSERT(b!=NULL);\r
+\r
+ auto_ptr<KeyInfo> kiObject(\r
+ dynamic_cast<KeyInfo*>(b->buildFromDocument(doc))\r
+ );\r
+ TS_ASSERT(kiObject.get()!=NULL);\r
+ TSM_ASSERT_EQUALS("Number of child elements was not expected value",\r
+ 3, kiObject->getOrderedChildren().size());\r
+ TSM_ASSERT_EQUALS("Number of child elements was not expected value",\r
+ 1, kiObject->getKeyValues().size());\r
+ TSM_ASSERT_EQUALS("Number of child elements was not expected value",\r
+ 1, kiObject->getX509Datas().front()->getX509Certificates().size());\r
+\r
+ auto_ptr_XMLCh expected("Public Key for CN=xmldap.org, OU=Domain Control Validated, O=xmldap.org");\r
+ TSM_ASSERT_SAME_DATA("KeyName was not expected value",\r
+ expected.get(), kiObject->getKeyNames().front()->getName(), XMLString::stringLen(expected.get()));\r
+ }\r
+\r
+};\r
xmltoolingtest_h = \
ComplexXMLObjectTest.h \
ExceptionTest.h \
+ KeyInfoTest.h \
MarshallingTest.h \
UnmarshallingTest.h \
xmltoolingtest.h \
#include <fstream>\r
\r
class MarshallingTest : public CxxTest::TestSuite {\r
- QName m_qname;\r
- QName m_qtype;\r
public:\r
- MarshallingTest() : m_qname(SimpleXMLObject::NAMESPACE,SimpleXMLObject::LOCAL_NAME,SimpleXMLObject::NAMESPACE_PREFIX),\r
- m_qtype(SimpleXMLObject::NAMESPACE,SimpleXMLObject::TYPE_NAME,SimpleXMLObject::NAMESPACE_PREFIX) {}\r
-\r
void setUp() {\r
- XMLObjectBuilder::registerBuilder(m_qname, new SimpleXMLObjectBuilder());\r
- XMLObjectBuilder::registerBuilder(m_qtype, new SimpleXMLObjectBuilder());\r
+ QName qname(SimpleXMLObject::NAMESPACE,SimpleXMLObject::LOCAL_NAME);\r
+ QName qtype(SimpleXMLObject::NAMESPACE,SimpleXMLObject::TYPE_NAME);\r
+ XMLObjectBuilder::registerBuilder(qname, new SimpleXMLObjectBuilder());\r
+ XMLObjectBuilder::registerBuilder(qtype, new SimpleXMLObjectBuilder());\r
}\r
\r
void tearDown() {\r
- XMLObjectBuilder::deregisterBuilder(m_qname);\r
- XMLObjectBuilder::deregisterBuilder(m_qtype);\r
+ QName qname(SimpleXMLObject::NAMESPACE,SimpleXMLObject::LOCAL_NAME);\r
+ QName qtype(SimpleXMLObject::NAMESPACE,SimpleXMLObject::TYPE_NAME);\r
+ XMLObjectBuilder::deregisterBuilder(qname);\r
+ XMLObjectBuilder::deregisterBuilder(qtype);\r
}\r
\r
void testMarshallingWithAttributes() {\r
TS_TRACE("testMarshallingWithAttributes");\r
\r
- auto_ptr_XMLCh expected("Firefly");\r
- auto_ptr<SimpleXMLObject> sxObject(dynamic_cast<SimpleXMLObject*>(XMLObjectBuilder::buildOne(m_qname)));\r
+ QName qname(SimpleXMLObject::NAMESPACE,SimpleXMLObject::LOCAL_NAME);\r
+ const SimpleXMLObjectBuilder* b=dynamic_cast<const SimpleXMLObjectBuilder*>(XMLObjectBuilder::getBuilder(qname));\r
+ auto_ptr<SimpleXMLObject> sxObject(b->buildObject());\r
TS_ASSERT(sxObject.get()!=NULL);\r
+ auto_ptr_XMLCh expected("Firefly");\r
sxObject->setId(expected.get());\r
\r
DOMElement* rootElement = sxObject->marshall();\r
void testMarshallingWithElementContent() {\r
TS_TRACE("testMarshallingWithElementContent");\r
\r
- auto_ptr_XMLCh expected("Sample Content");\r
- auto_ptr<SimpleXMLObject> sxObject(dynamic_cast<SimpleXMLObject*>(XMLObjectBuilder::buildOne(m_qname)));\r
+ QName qname(SimpleXMLObject::NAMESPACE,SimpleXMLObject::LOCAL_NAME);\r
+ const SimpleXMLObjectBuilder* b=dynamic_cast<const SimpleXMLObjectBuilder*>(XMLObjectBuilder::getBuilder(qname));\r
+ auto_ptr<SimpleXMLObject> sxObject(b->buildObject());\r
TS_ASSERT(sxObject.get()!=NULL);\r
+ auto_ptr_XMLCh expected("Sample Content");\r
sxObject->setValue(expected.get());\r
\r
DOMElement* rootElement = sxObject->marshall();\r
void testMarshallingWithChildElements() {\r
TS_TRACE("testMarshallingWithChildElements");\r
\r
- const SimpleXMLObjectBuilder* b=dynamic_cast<const SimpleXMLObjectBuilder*>(XMLObjectBuilder::getBuilder(m_qname));\r
+ QName qname(SimpleXMLObject::NAMESPACE,SimpleXMLObject::LOCAL_NAME);\r
+ const SimpleXMLObjectBuilder* b=dynamic_cast<const SimpleXMLObjectBuilder*>(XMLObjectBuilder::getBuilder(qname));\r
TS_ASSERT(b!=NULL);\r
\r
auto_ptr<SimpleXMLObject> sxObject(b->buildObject());\r
kids.erase(kids.begin()+1);\r
TS_ASSERT_SAME_DATA(kids.back()->getValue(), bar.get(), XMLString::stringLen(bar.get()));\r
\r
- kids.push_back(b->buildObject(SimpleXMLObject::NAMESPACE,SimpleXMLObject::DERIVED_NAME,SimpleXMLObject::NAMESPACE_PREFIX,&m_qtype));\r
+ QName qtype(SimpleXMLObject::NAMESPACE,SimpleXMLObject::TYPE_NAME,SimpleXMLObject::NAMESPACE_PREFIX);\r
+ kids.push_back(\r
+ b->buildObject(SimpleXMLObject::NAMESPACE,SimpleXMLObject::DERIVED_NAME,SimpleXMLObject::NAMESPACE_PREFIX,&qtype)\r
+ );\r
kids.back()->setValue(baz.get());\r
\r
DOMElement* rootElement = sxObject->marshall();\r
};\r
\r
class SignatureTest : public CxxTest::TestSuite {\r
- QName m_qname;\r
- QName m_qtype;\r
public:\r
- SignatureTest() : m_qname(SimpleXMLObject::NAMESPACE,SimpleXMLObject::LOCAL_NAME,SimpleXMLObject::NAMESPACE_PREFIX),\r
- m_qtype(SimpleXMLObject::NAMESPACE,SimpleXMLObject::TYPE_NAME,SimpleXMLObject::NAMESPACE_PREFIX) {}\r
-\r
void setUp() {\r
- XMLObjectBuilder::registerBuilder(m_qname, new SimpleXMLObjectBuilder());\r
- XMLObjectBuilder::registerBuilder(m_qtype, new SimpleXMLObjectBuilder());\r
+ QName qname(SimpleXMLObject::NAMESPACE,SimpleXMLObject::LOCAL_NAME);\r
+ QName qtype(SimpleXMLObject::NAMESPACE,SimpleXMLObject::TYPE_NAME);\r
+ XMLObjectBuilder::registerBuilder(qname, new SimpleXMLObjectBuilder());\r
+ XMLObjectBuilder::registerBuilder(qtype, new SimpleXMLObjectBuilder());\r
}\r
\r
void tearDown() {\r
- XMLObjectBuilder::deregisterBuilder(m_qname);\r
- XMLObjectBuilder::deregisterBuilder(m_qtype);\r
+ QName qname(SimpleXMLObject::NAMESPACE,SimpleXMLObject::LOCAL_NAME);\r
+ QName qtype(SimpleXMLObject::NAMESPACE,SimpleXMLObject::TYPE_NAME);\r
+ XMLObjectBuilder::deregisterBuilder(qname);\r
+ XMLObjectBuilder::deregisterBuilder(qtype);\r
}\r
\r
void testSignature() {\r
TS_TRACE("testSignature");\r
\r
- const SimpleXMLObjectBuilder* b=dynamic_cast<const SimpleXMLObjectBuilder*>(XMLObjectBuilder::getBuilder(m_qname));\r
+ QName qname(SimpleXMLObject::NAMESPACE,SimpleXMLObject::LOCAL_NAME);\r
+ const SimpleXMLObjectBuilder* b=dynamic_cast<const SimpleXMLObjectBuilder*>(XMLObjectBuilder::getBuilder(qname));\r
TS_ASSERT(b!=NULL);\r
\r
auto_ptr<SimpleXMLObject> sxObject(b->buildObject());\r
kids[1]->setValue(bar.get());\r
\r
// Append a Signature.\r
- Signature* sig=dynamic_cast<Signature*>(XMLObjectBuilder::buildOne(QName(XMLConstants::XMLSIG_NS,Signature::LOCAL_NAME)));\r
+ const SignatureBuilder* sigb=dynamic_cast<const SignatureBuilder*>(XMLObjectBuilder::getBuilder(QName(XMLConstants::XMLSIG_NS,Signature::LOCAL_NAME)));\r
+ Signature* sig=sigb->buildObject();\r
sxObject->setSignature(sig);\r
\r
// Signing context for the whole document.\r
};\r
\r
class UnmarshallingTest : public CxxTest::TestSuite {\r
- QName m_qname;\r
- QName m_qtype;\r
public:\r
- UnmarshallingTest() : m_qname(SimpleXMLObject::NAMESPACE,SimpleXMLObject::LOCAL_NAME,SimpleXMLObject::NAMESPACE_PREFIX),\r
- m_qtype(SimpleXMLObject::NAMESPACE,SimpleXMLObject::TYPE_NAME,SimpleXMLObject::NAMESPACE_PREFIX) {}\r
-\r
void setUp() {\r
- XMLObjectBuilder::registerBuilder(m_qname, new SimpleXMLObjectBuilder());\r
- XMLObjectBuilder::registerBuilder(m_qtype, new SimpleXMLObjectBuilder());\r
+ QName qname(SimpleXMLObject::NAMESPACE,SimpleXMLObject::LOCAL_NAME);\r
+ QName qtype(SimpleXMLObject::NAMESPACE,SimpleXMLObject::TYPE_NAME);\r
+ XMLObjectBuilder::registerBuilder(qname, new SimpleXMLObjectBuilder());\r
+ XMLObjectBuilder::registerBuilder(qtype, new SimpleXMLObjectBuilder());\r
}\r
\r
void tearDown() {\r
- XMLObjectBuilder::deregisterBuilder(m_qname);\r
- XMLObjectBuilder::deregisterBuilder(m_qtype);\r
+ QName qname(SimpleXMLObject::NAMESPACE,SimpleXMLObject::LOCAL_NAME);\r
+ QName qtype(SimpleXMLObject::NAMESPACE,SimpleXMLObject::TYPE_NAME);\r
+ XMLObjectBuilder::deregisterBuilder(qname);\r
+ XMLObjectBuilder::deregisterBuilder(qtype);\r
}\r
\r
void testUnmarshallingWithAttributes() {\r
\r
VectorOf(SimpleXMLObject) kids=sxObject->getSimpleXMLObjects();\r
TSM_ASSERT_EQUALS("Number of child elements was not expected value", 3, kids.size());\r
- TSM_ASSERT_EQUALS("Child's schema type was not expected value", m_qtype, *(kids.back()->getSchemaType()));\r
+ QName qtype(SimpleXMLObject::NAMESPACE,SimpleXMLObject::TYPE_NAME);\r
+ TSM_ASSERT_EQUALS("Child's schema type was not expected value", qtype, *(kids.back()->getSchemaType()));\r
}\r
\r
void testUnmarshallingWithClone() {\r
\r
VectorOf(SimpleXMLObject) kids=clonedObject->getSimpleXMLObjects();\r
TSM_ASSERT_EQUALS("Number of child elements was not expected value", 3, kids.size());\r
- TSM_ASSERT_EQUALS("Child's schema type was not expected value", m_qtype, *(kids.back()->getSchemaType()));\r
+ QName qtype(SimpleXMLObject::NAMESPACE,SimpleXMLObject::TYPE_NAME);\r
+ TSM_ASSERT_EQUALS("Child's schema type was not expected value", qtype, *(kids.back()->getSchemaType()));\r
}\r
\r
void testUnmarshallingWithUnknownChild() {\r
*/
#include <cxxtest/TestSuite.h>
+#include <xmltooling/AbstractComplexElement.h>
#include <xmltooling/ElementProxy.h>
#include <xmltooling/exceptions.h>
#include <xmltooling/XMLObjectBuilder.h>
#pragma warning( disable : 4250 4251 )
#endif
-class SimpleXMLObject : public AbstractDOMCachingXMLObject, public AbstractXMLObjectMarshaller, public AbstractXMLObjectUnmarshaller
+class SimpleXMLObject
+ : public AbstractComplexElement,
+ public AbstractDOMCachingXMLObject,
+ public AbstractXMLObjectMarshaller,
+ public AbstractXMLObjectUnmarshaller
{
protected:
SimpleXMLObject(const SimpleXMLObject& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src),
--- /dev/null
+<ds:KeyInfo xmlns:ds="http://www.w3.org/2000/09/xmldsig#"><ds:KeyName>Public Key for CN=xmldap.org, OU=Domain Control Validated, O=xmldap.org</ds:KeyName><ds:KeyValue><ds:RSAKeyValue><ds:Modulus>ANCxWwHKKOzwCtsbZUhhzQjXcyKHA7zrl8UqoCyu7haKzrEmI7udl7B6L+zxgnmVRz4zsw1PJsVYUt9zG6ABC+P7Xtx46Tk/h5gO6hWL4XBzFUuKwsMRZ0RB0sAv6iQtz6TCyH47OBSJSN24h7e/viUQ0ZtKYsJo/r8BHrnoiJk1</ds:Modulus><ds:Exponent>AQAB</ds:Exponent></ds:RSAKeyValue></ds:KeyValue><ds:X509Data><ds:X509Certificate>MIIEYTCCA8qgAwIBAgIDPbIoMA0GCSqGSIb3DQEBBQUAMIHsMQswCQYDVQQGEwJVUzEQMA4GA1UECBMHQXJpem9uYTETMBEGA1UEBxMKU2NvdHRzZGFsZTElMCMGA1UEChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEwMC4GA1UECxMnaHR0cDovL3d3dy5zdGFyZmllbGR0ZWNoLmNvbS9yZXBvc2l0b3J5MTEwLwYDVQQDEyhTdGFyZmllbGQgU2VjdXJlIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MSowKAYJKoZIhvcNAQkBFhtwcmFjdGljZXNAc3RhcmZpZWxkdGVjaC5jb20wHhcNMDYwMzI5MjAwNzIxWhcNMDcwMzI5MjAwNzIxWjBNMRMwEQYDVQQKEwp4bWxkYXAub3JnMSEwHwYDVQQLExhEb21haW4gQ29udHJvbCBWYWxpZGF0ZWQxEzARBgNVBAMTCnhtbGRhcC5vcmcwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBANCxWwHKKOzwCtsbZUhhzQjXcyKHA7zrl8UqoCyu7haKzrEmI7udl7B6L+zxgnmVRz4zsw1PJsVYUt9zG6ABC+P7Xtx46Tk/h5gO6hWL4XBzFUuKwsMRZ0RB0sAv6iQtz6TCyH47OBSJSN24h7e/viUQ0ZtKYsJo/r8BHrnoiJk1AgMBAAGjggGtMIIBqTAJBgNVHRMEAjAAMAsGA1UdDwQEAwIFoDAdBgNVHSUEFjAUBggrBgEFBQcDAQYIKwYBBQUHAwIwVgYDVR0fBE8wTTBLoEmgR4ZFaHR0cDovL2NlcnRpZmljYXRlcy5zdGFyZmllbGR0ZWNoLmNvbS9yZXBvc2l0b3J5L3N0YXJmaWVsZGlzc3VpbmcuY3JsME8GA1UdIARIMEYwRAYLYIZIAYb4RQEHFwMwNTAzBggrBgEFBQcCARYnaHR0cDovL3d3dy5zdGFyZmllbGR0ZWNoLmNvbS9yZXBvc2l0b3J5MIGGBggrBgEFBQcBAQR6MHgwKQYIKwYBBQUHMAGGHWh0dHA6Ly9vY3NwLnN0YXJmaWVsZHRlY2guY29tMEsGCCsGAQUFBzAChj9odHRwOi8vY2VydGlmaWNhdGVzLnN0YXJmaWVsZHRlY2guY29tL3JlcG9zaXRvcnkvc2ZfaXNzdWluZy5jcnQwHQYDVR0OBBYEFMcfOhkD6X5rEFFGmj1aV4Rg7Nr9MB8GA1UdIwQYMBaAFKxV3rfqE+v8mGjiU2Ae8SU+jO7nMA0GCSqGSIb3DQEBBQUAA4GBAB0qT6gCXzgWua2P9/CPqsbXztwJAMPVx2zyAVYuZwgThsEmg53EhpqhUFz6DssNFzIxGT8vMrOMJs0hgndBTtWVfdJbrhbgtdc7/Zp10WO/6ioX3lIzJq+un2MA9Rdwk3QQyHCH9baYgHbcPEOj3N+dk2nzCzK34IbPpjYzE7H0</ds:X509Certificate></ds:X509Data></ds:KeyInfo>
#include <xmltooling/XMLToolingConfig.h>\r
#include <xmltooling/util/ParserPool.h>\r
\r
+//#define XMLTOOLINGTEST_LEAKCHECK\r
+\r
ParserPool* validatingPool=NULL;\r
ParserPool* nonvalidatingPool=NULL;\r
std::string data_path = "../xmltoolingtest/data/";\r
>\r
</File>\r
<File\r
+ RelativePath=".\KeyInfoTest.cpp"\r
+ >\r
+ </File>\r
+ <File\r
RelativePath=".\MarshallingTest.cpp"\r
>\r
</File>\r
>\r
<Tool\r
Name="VCCustomBuildTool"\r
- CommandLine="\perl\bin\perl.exe -w \cxxtest\cxxtestgen.pl --part --have-eh --have-std --abort-on-fail -o "$(InputName)".cpp "$(InputPath)""\r
+ CommandLine="\perl\bin\perl.exe -w \cxxtest\cxxtestgen.pl --part --have-eh --have-std --abort-on-fail -o "$(InputName)".cpp "$(InputPath)"
"\r
Outputs=""$(InputName)".cpp"\r
/>\r
</FileConfiguration>\r
>\r
<Tool\r
Name="VCCustomBuildTool"\r
- CommandLine="\perl\bin\perl.exe -w \cxxtest\cxxtestgen.pl --part --have-eh --have-std --abort-on-fail -o "$(InputName)".cpp "$(InputPath)""\r
+ CommandLine="\perl\bin\perl.exe -w \cxxtest\cxxtestgen.pl --part --have-eh --have-std --abort-on-fail -o "$(InputName)".cpp "$(InputPath)"
"\r
Outputs=""$(InputName)".cpp"\r
/>\r
</FileConfiguration>\r
>\r
<Tool\r
Name="VCCustomBuildTool"\r
+ CommandLine="\perl\bin\perl.exe -w \cxxtest\cxxtestgen.pl --part --have-eh --have-std --abort-on-fail -o "$(InputName)".cpp "$(InputPath)"
"\r
+ Outputs=""$(InputName)".cpp"\r
+ />\r
+ </FileConfiguration>\r
+ <FileConfiguration\r
+ Name="Release|Win32"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
+ CommandLine="\perl\bin\perl.exe -w \cxxtest\cxxtestgen.pl --part --have-eh --have-std --abort-on-fail -o "$(InputName)".cpp "$(InputPath)"
"\r
+ Outputs=""$(InputName)".cpp"\r
+ />\r
+ </FileConfiguration>\r
+ </File>\r
+ <File\r
+ RelativePath=".\KeyInfoTest.h"\r
+ >\r
+ <FileConfiguration\r
+ Name="Debug|Win32"\r
+ >\r
+ <Tool\r
+ Name="VCCustomBuildTool"\r
CommandLine="\perl\bin\perl.exe -w \cxxtest\cxxtestgen.pl --part --have-eh --have-std --abort-on-fail -o "$(InputName)".cpp "$(InputPath)""\r
Outputs=""$(InputName)".cpp"\r
/>\r
projects / shibboleth / xmltooling.git / commitdiff