2 * Copyright 2001-2006 Internet2
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
20 * Base header file definitions
21 * Must be included prior to including any other header
24 #ifndef __xmltooling_base_h__
25 #define __xmltooling_base_h__
27 #if defined (_MSC_VER) || defined(__BORLANDC__)
28 #include <xmltooling/config_pub_win32.h>
30 #include <xmltooling/config_pub.h>
34 * @namespace xmltooling
35 * Public namespace of XML Tooling library
38 // Windows and GCC4 Symbol Visibility Macros
40 #define XMLTOOL_IMPORT __declspec(dllimport)
41 #define XMLTOOL_EXPORT __declspec(dllexport)
42 #define XMLTOOL_DLLLOCAL
43 #define XMLTOOL_DLLPUBLIC
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")))
51 #define XMLTOOL_EXPORT
52 #define XMLTOOL_DLLLOCAL
53 #define XMLTOOL_DLLPUBLIC
57 // Define XMLTOOL_API for DLL builds
58 #ifdef XMLTOOLING_EXPORTS
59 #define XMLTOOL_API XMLTOOL_EXPORT
61 #define XMLTOOL_API XMLTOOL_IMPORT
64 // Throwable classes must always be visible on GCC in all binaries
66 #define XMLTOOL_EXCEPTIONAPI(api) api
67 #elif defined(GCC_HASCLASSVISIBILITY)
68 #define XMLTOOL_EXCEPTIONAPI(api) XMLTOOL_EXPORT
70 #define XMLTOOL_EXCEPTIONAPI(api)
78 * Blocks copy c'tor and assignment operator for a class.
80 #define MAKE_NONCOPYABLE(type) \
83 type& operator=(const type&);
86 * Begins the declaration of an XMLObject specialization.
87 * Basic boilerplate includes a protected constructor, empty virtual destructor,
88 * and Unicode constants for the default associated element's name and prefix.
90 * @param cname the name of the class to declare
91 * @param base the base class to derive from using public virtual inheritance
93 #define BEGIN_XMLOBJECT(cname,base) \
94 class XMLTOOL_API cname : public virtual base, public virtual ValidatingXMLObject { \
99 /##** Type-specific clone method. */ \
100 virtual cname* clone##cname() const=0; \
101 /##** Element prefix */ \
102 static const XMLCh PREFIX[]; \
103 /##** Element local name */ \
104 static const XMLCh LOCAL_NAME[]
107 * Ends the declaration of an XMLObject specialization.
109 #define END_XMLOBJECT }
112 * Declares abstract get/set methods for a named XML attribute.
114 * @param proper the proper name of the attribute
115 * @param upcased the upcased name of the attribute
117 #define DECL_XMLOBJECT_ATTRIB(proper,upcased) \
118 /##** proper attribute name */ \
119 static const XMLCh upcased##_ATTRIB_NAME[]; \
120 /##** Returns the proper attribute. */ \
121 virtual const XMLCh* get##proper() const=0; \
122 /##** Sets the proper attribute. */ \
123 virtual void set##proper(const XMLCh* proper)=0
126 * Implements get/set methods and a private member for a named XML attribute.
128 * @param proper the proper name of the attribute
130 #define IMPL_XMLOBJECT_ATTRIB(proper) \
134 const XMLCh* get##proper() const { \
137 void set##proper(const XMLCh* proper) { \
138 m_##proper = prepareForAssignment(m_##proper,proper); \
142 * Implements cloning methods for an XMLObject specialization implementation class.
144 * @param cname the name of the XMLObject specialization
146 #define IMPL_XMLOBJECT_CLONE(cname) \
147 cname* clone##cname() const { \
150 cname* clone() const { \
151 auto_ptr<XMLObject> domClone(AbstractDOMCachingXMLObject::clone()); \
152 cname##Impl* ret=dynamic_cast<cname##Impl*>(domClone.get()); \
154 domClone.release(); \
157 return new cname##Impl(*this); \
161 * Begins the declaration of an XMLObjectBuilder specialization.
162 * Basic boilerplate includes an empty virtual destructor, and
165 * @param cname the name of the XMLObject specialization
167 #define BEGIN_XMLOBJECTBUILDER(cname) \
168 /##** Builder for cname objects. */ \
169 class XMLTOOL_API cname##Builder : public xmltooling::XMLObjectBuilder { \
171 virtual ~cname##Builder() {} \
172 /##** Default builder. */ \
173 virtual cname* buildObject() const=0
176 * Ends the declaration of an XMLObjectBuilder specialization.
178 #define END_XMLOBJECTBUILDER }
181 * Begins the declaration of an XMLObjectBuilder specialization implementation class.
183 * @param cname the name of the XMLObject specialization
184 * @param namespaceURI the XML namespace of the default associated element
186 #define BEGIN_XMLOBJECTBUILDERIMPL(cname,namespaceURI) \
187 class XMLTOOL_DLLLOCAL cname##BuilderImpl : public cname##Builder { \
189 cname* buildObject( \
190 const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix=NULL, const QName* schemaType=NULL\
192 cname* buildObject() const { \
193 return buildObject(namespaceURI,cname::LOCAL_NAME,cname::PREFIX); \
197 * Ends the declaration of an XMLObjectBuilder specialization implementation class.
199 #define END_XMLOBJECTBUILDERIMPL }
203 namespace xmltooling {
206 * Template function for cloning a sequence of XMLObjects.
207 * Invokes the clone() member on each element of the input sequence and adds the copy to
208 * the output sequence. Order is preserved.
210 * @param in input sequence to clone
211 * @param out output sequence to copy cloned pointers into
213 template<class InputSequence,class OutputSequence> void clone(const InputSequence& in, OutputSequence& out) {
214 for (typename InputSequence::const_iterator i=in.begin(); i!=in.end(); i++) {
216 out.push_back((*i)->clone());
223 * Functor for cleaning up heap objects in containers.
225 template<class T> struct cleanup
228 * Function operator to delete an object.
230 * @param ptr object to delete
232 void operator()(T* ptr) {delete ptr;}
235 * Function operator to delete an object stored as const.
237 * @param ptr object to delete after casting away const
239 void operator()(const T* ptr) {delete const_cast<T*>(ptr);}
243 * Functor for cleaning up heap objects in key/value containers.
245 template<class A,class B> struct cleanup_pair
248 * Function operator to delete an object.
250 * @param p a pair in which the second component is the object to delete
252 void operator()(const std::pair<A,B*>& p) {delete p.second;}
256 #endif /* __xmltooling_base_h__ */