Add code for non-covariant build.

[shibboleth/cpp-xmltooling.git] / xmltooling / base.h

diff --git a/xmltooling/base.h b/xmltooling/base.h
index ef7bc53..6c6d359 100644 (file)
--- a/xmltooling/base.h
+++ b/xmltooling/base.h
@@ -312,6 +312,32 @@
         static const XMLCh LOCAL_NAME[]
 
 /**
+ * Begins the declaration of an XMLObject specialization with five base classes.
+ * Basic boilerplate includes a protected constructor, empty virtual destructor,
+ * and Unicode constants for the default associated element's name and prefix.
+ * 
+ * @param linkage   linkage specifier for the class
+ * @param cname     the name of the class to declare
+ * @param base      the first base class to derive from using public virtual inheritance
+ * @param base2     the second base class to derive from using public virtual inheritance
+ * @param base3     the third base class to derive from using public virtual inheritance
+ * @param base4     the fourth base class to derive from using public virtual inheritance
+ * @param base5     the fifth base class to derive from using public virtual inheritance
+ * @param desc      documentation comment for class
+ */
+#define BEGIN_XMLOBJECT5(linkage,cname,base,base2,base3,base4,base5,desc) \
+    XMLTOOLING_DOXYGEN(desc) \
+    class linkage cname : public virtual base, public virtual base2, public virtual base3, public virtual base4, public virtual base5 { \
+    protected: \
+        cname() {} \
+    public: \
+        virtual ~cname() {} \
+        XMLTOOLING_DOXYGEN(Type-specific clone method.) \
+        virtual cname* clone##cname() const=0; \
+        XMLTOOLING_DOXYGEN(Element local name) \
+        static const XMLCh LOCAL_NAME[]
+
+/**
  * Ends the declaration of an XMLObject specialization.
  */
 #define END_XMLOBJECT }
@@ -1082,9 +1108,9 @@
  */
 #define IMPL_XMLOBJECT_CLONE(cname) \
     cname* clone##cname() const { \
-        return clone(); \
+        return dynamic_cast<cname*>(clone()); \
     } \
-    cname* clone() const { \
+    xmltooling::XMLObject* clone() const { \
         std::auto_ptr<xmltooling::XMLObject> domClone(xmltooling::AbstractDOMCachingXMLObject::clone()); \
         cname##Impl* ret=dynamic_cast<cname##Impl*>(domClone.get()); \
         if (ret) { \
@@ -1134,7 +1160,9 @@
                 xmltooling::AbstractDOMCachingXMLObject(src) {} \
         IMPL_XMLOBJECT_CLONE(cname) \
     }
-    
+
+#ifdef HAVE_COVARIANT_RETURNS
+
 /**
  * Begins the declaration of an XMLObjectBuilder specialization.
  * Basic boilerplate includes an empty virtual destructor, and
@@ -1198,6 +1226,73 @@
         return new cname##Impl(nsURI,localName,prefix,schemaType); \
     }
 
+#else   /* !HAVE_COVARIANT_RETURNS */\r
+
+/**
+ * Begins the declaration of an XMLObjectBuilder specialization.
+ * Basic boilerplate includes an empty virtual destructor, and
+ * a default builder that defaults the element name.
+ * 
+ * @param linkage           linkage specifier for the class
+ * @param cname             the name of the XMLObject specialization
+ * @param namespaceURI      the XML namespace of the default associated element
+ * @param namespacePrefix   the XML namespace prefix of the default associated element
+ */
+#define BEGIN_XMLOBJECTBUILDER(linkage,cname,namespaceURI,namespacePrefix) \
+    XMLTOOLING_DOXYGEN(Builder for cname objects.) \
+    class linkage cname##Builder : public xmltooling::XMLObjectBuilder { \
+    public: \
+        virtual ~cname##Builder() {} \
+        XMLTOOLING_DOXYGEN(Default builder.) \
+        virtual xmltooling::XMLObject* buildObject() const { \
+            return buildObject(namespaceURI,cname::LOCAL_NAME,namespacePrefix); \
+        } \
+        XMLTOOLING_DOXYGEN(Builder that allows element/type override.) \
+        virtual xmltooling::XMLObject* buildObject( \
+            const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix=NULL, const xmltooling::QName* schemaType=NULL \
+            ) const
+
+/**
+ * Ends the declaration of an XMLObjectBuilder specialization.
+ */
+#define END_XMLOBJECTBUILDER }
+
+/**
+ * Declares a generic XMLObjectBuilder specialization.
+ * 
+ * @param linkage           linkage specifier for the class
+ * @param cname             the name of the XMLObject specialization
+ * @param namespaceURI      the XML namespace of the default associated element
+ * @param namespacePrefix   the XML namespace prefix of the default associated element
+ */
+ #define DECL_XMLOBJECTBUILDER(linkage,cname,namespaceURI,namespacePrefix) \
+    BEGIN_XMLOBJECTBUILDER(linkage,cname,namespaceURI,namespacePrefix); \
+    XMLTOOLING_DOXYGEN(Singleton builder.) \
+    static cname* build##cname() { \
+        const cname##Builder* b = dynamic_cast<const cname##Builder*>( \
+            XMLObjectBuilder::getBuilder(xmltooling::QName(namespaceURI,cname::LOCAL_NAME)) \
+            ); \
+        if (b) \
+            return dynamic_cast<cname*>(b->buildObject()); \
+        throw xmltooling::XMLObjectException("Unable to obtain typed builder for "#cname"."); \
+    } \
+    END_XMLOBJECTBUILDER
+
+/**
+ * Implements the standard XMLObjectBuilder specialization function. 
+ * 
+ * @param cname the name of the XMLObject specialization
+ */
+#define IMPL_XMLOBJECTBUILDER(cname) \
+    xmltooling::XMLObject* cname##Builder::buildObject( \
+        const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType \
+        ) const \
+    { \
+        return new cname##Impl(nsURI,localName,prefix,schemaType); \
+    }
+
+#endif  /* HAVE_COVARIANT_RETURNS */
+
 /**
  * Begins the declaration of a Schema Validator specialization.
  *