xmltooling/base.h

   1 /*
   2  *  Copyright 2001-2006 Internet2
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /**
  18  * @file base.h
  19  *
  20  * Base header file definitions
  21  * Must be included prior to including any other header
  22  */
  23
  24 #ifndef __xmltooling_base_h__
  25 #define __xmltooling_base_h__
  26
  27 #if defined (_MSC_VER) || defined(__BORLANDC__)
  28   #include <xmltooling/config_pub_win32.h>
  29 #else
  30   #include <xmltooling/config_pub.h>
  31 #endif
  32
  33 /**
  34  * @namespace xmltooling
  35  * Public namespace of XML Tooling library
  36  */
  37
  38 // Windows and GCC4 Symbol Visibility Macros
  39 #ifdef WIN32
  40   #define XMLTOOL_IMPORT __declspec(dllimport)
  41   #define XMLTOOL_EXPORT __declspec(dllexport)
  42   #define XMLTOOL_DLLLOCAL
  43   #define XMLTOOL_DLLPUBLIC
  44 #else
  45   #define XMLTOOL_IMPORT
  46   #ifdef GCC_HASCLASSVISIBILITY
  47     #define XMLTOOL_EXPORT __attribute__ ((visibility("default")))
  48     #define XMLTOOL_DLLLOCAL __attribute__ ((visibility("hidden")))
  49     #define XMLTOOL_DLLPUBLIC __attribute__ ((visibility("default")))
  50   #else
  51     #define XMLTOOL_EXPORT
  52     #define XMLTOOL_DLLLOCAL
  53     #define XMLTOOL_DLLPUBLIC
  54   #endif
  55 #endif
  56
  57 // Define XMLTOOL_API for DLL builds
  58 #ifdef XMLTOOLING_EXPORTS
  59   #define XMLTOOL_API XMLTOOL_EXPORT
  60 #else
  61   #define XMLTOOL_API XMLTOOL_IMPORT
  62 #endif
  63
  64 // Throwable classes must always be visible on GCC in all binaries
  65 #ifdef WIN32
  66   #define XMLTOOL_EXCEPTIONAPI(api) api
  67 #elif defined(GCC_HASCLASSVISIBILITY)
  68   #define XMLTOOL_EXCEPTIONAPI(api) XMLTOOL_EXPORT
  69 #else
  70   #define XMLTOOL_EXCEPTIONAPI(api)
  71 #endif
  72
  73 #ifndef NULL
  74 #define NULL    0
  75 #endif
  76
  77 #ifdef _MSC_VER
  78     #define XMLTOOLING_DOXYGEN(desc) /##** desc */
  79 #else
  80     #define XMLTOOLING_DOXYGEN(desc)
  81 #endif
  82
  83 /**
  84  * Blocks copy c'tor and assignment operator for a class.
  85  */
  86 #define MAKE_NONCOPYABLE(type) \
  87     private: \
  88         type(const type&); \
  89         type& operator=(const type&);
  90
  91 /**
  92  * Begins the declaration of an XMLObject specialization.
  93  * Basic boilerplate includes a protected constructor, empty virtual destructor,
  94  * and Unicode constants for the default associated element's name and prefix.
  95  *
  96  * @param cname the name of the class to declare
  97  * @param base  the base class to derive from using public virtual inheritance
  98  */
  99 #define BEGIN_XMLOBJECT(cname,base) \
 100     class XMLTOOL_API cname : public virtual base, public virtual ValidatingXMLObject { \
 101     protected: \
 102         cname() {} \
 103     public: \
 104         virtual ~cname() {} \
 105         XMLTOOLING_DOXYGEN(Type-specific clone method.) \
 106         virtual cname* clone##cname() const=0; \
 107         XMLTOOLING_DOXYGEN(Element prefix) \
 108         static const XMLCh PREFIX[]; \
 109         XMLTOOLING_DOXYGEN(Element local name) \
 110         static const XMLCh LOCAL_NAME[]
 111
 112 /**
 113  * Ends the declaration of an XMLObject specialization.
 114  */
 115 #define END_XMLOBJECT }
 116
 117 /**
 118  * Declares abstract get/set methods for a named XML attribute.
 119  *
 120  * @param proper    the proper name of the attribute
 121  * @param upcased   the upcased name of the attribute
 122  */
 123 #define DECL_XMLOBJECT_ATTRIB(proper,upcased) \
 124     XMLTOOLING_DOXYGEN(proper attribute name) \
 125     static const XMLCh upcased##_ATTRIB_NAME[]; \
 126     XMLTOOLING_DOXYGEN(Returns the proper attribute.) \
 127     virtual const XMLCh* get##proper() const=0; \
 128     XMLTOOLING_DOXYGEN(Sets the proper attribute.) \
 129     virtual void set##proper(const XMLCh* proper)=0
 130
 131 /**
 132  * Implements get/set methods and a private member for a named XML attribute.
 133  *
 134  * @param proper    the proper name of the attribute
 135  */
 136 #define IMPL_XMLOBJECT_ATTRIB(proper) \
 137     private: \
 138         XMLCh* m_##proper; \
 139     public: \
 140         const XMLCh* get##proper() const { \
 141             return m_##proper; \
 142         } \
 143         void set##proper(const XMLCh* proper) { \
 144             m_##proper = prepareForAssignment(m_##proper,proper); \
 145         }
 146
 147 /**
 148  * Implements cloning methods for an XMLObject specialization implementation class.
 149  *
 150  * @param cname    the name of the XMLObject specialization
 151  */
 152 #define IMPL_XMLOBJECT_CLONE(cname) \
 153     cname* clone##cname() const { \
 154         return clone(); \
 155     } \
 156     cname* clone() const { \
 157         auto_ptr<XMLObject> domClone(AbstractDOMCachingXMLObject::clone()); \
 158         cname##Impl* ret=dynamic_cast<cname##Impl*>(domClone.get()); \
 159         if (ret) { \
 160             domClone.release(); \
 161             return ret; \
 162         } \
 163         return new cname##Impl(*this); \
 164     }
 165
 166 /**
 167  * Begins the declaration of an XMLObjectBuilder specialization.
 168  * Basic boilerplate includes an empty virtual destructor, and
 169  * a default builder.
 170  *
 171  * @param cname the name of the XMLObject specialization
 172  */
 173 #define BEGIN_XMLOBJECTBUILDER(cname) \
 174     XMLTOOLING_DOXYGEN(Builder for cname objects.) \
 175     class XMLTOOL_API cname##Builder : public xmltooling::XMLObjectBuilder { \
 176     public: \
 177         virtual ~cname##Builder() {} \
 178         XMLTOOLING_DOXYGEN(Default builder.) \
 179         virtual cname* buildObject() const=0
 180
 181 /**
 182  * Ends the declaration of an XMLObjectBuilder specialization.
 183  */
 184 #define END_XMLOBJECTBUILDER }
 185
 186 /**
 187  * Begins the declaration of an XMLObjectBuilder specialization implementation class.
 188  *
 189  * @param cname         the name of the XMLObject specialization
 190  * @param namespaceURI  the XML namespace of the default associated element
 191  */
 192 #define BEGIN_XMLOBJECTBUILDERIMPL(cname,namespaceURI) \
 193     class XMLTOOL_DLLLOCAL cname##BuilderImpl : public cname##Builder { \
 194     public: \
 195         cname* buildObject( \
 196             const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix=NULL, const QName* schemaType=NULL\
 197             ) const; \
 198         cname* buildObject() const { \
 199             return buildObject(namespaceURI,cname::LOCAL_NAME,cname::PREFIX); \
 200         }
 201
 202 /**
 203  * Ends the declaration of an XMLObjectBuilder specialization implementation class.
 204  */
 205 #define END_XMLOBJECTBUILDERIMPL }
 206
 207 #include <utility>
 208
 209 namespace xmltooling {
 210
 211     /**
 212      * Template function for cloning a sequence of XMLObjects.
 213      * Invokes the clone() member on each element of the input sequence and adds the copy to
 214      * the output sequence. Order is preserved.
 215      *
 216      * @param in    input sequence to clone
 217      * @param out   output sequence to copy cloned pointers into
 218      */
 219     template<class InputSequence,class OutputSequence> void clone(const InputSequence& in, OutputSequence& out) {
 220         for (typename InputSequence::const_iterator i=in.begin(); i!=in.end(); i++) {
 221             if (*i)
 222                 out.push_back((*i)->clone());
 223             else
 224                 out.push_back(*i);
 225         }
 226     }
 227
 228     /**
 229      * Functor for cleaning up heap objects in containers.
 230      */
 231     template<class T> struct cleanup
 232     {
 233         /**
 234          * Function operator to delete an object.
 235          *
 236          * @param ptr   object to delete
 237          */
 238         void operator()(T* ptr) {delete ptr;}
 239
 240         /**
 241          * Function operator to delete an object stored as const.
 242          *
 243          * @param ptr   object to delete after casting away const
 244          */
 245         void operator()(const T* ptr) {delete const_cast<T*>(ptr);}
 246     };
 247
 248     /**
 249      * Functor for cleaning up heap objects in key/value containers.
 250      */
 251     template<class A,class B> struct cleanup_pair
 252     {
 253         /**
 254          * Function operator to delete an object.
 255          *
 256          * @param p   a pair in which the second component is the object to delete
 257          */
 258         void operator()(const std::pair<A,B*>& p) {delete p.second;}
 259     };
 260 };
 261
 262 #endif /* __xmltooling_base_h__ */