X-Git-Url: http://www.project-moonshot.org/gitweb/?a=blobdiff_plain;f=xmltooling%2Fbase.h;h=228640d0ab3b18ab82727bfd5fb06999f25b4f3c;hb=c61580d5c20b1af1c8c7e30f8811aae322c30de2;hp=9809d52dedcc0e7509dbd8c8bc7d107ab68fb318;hpb=59a03fbcf66dd9323f5549f6747edaf210e95e25;p=shibboleth%2Fcpp-xmltooling.git diff --git a/xmltooling/base.h b/xmltooling/base.h index 9809d52..228640d 100644 --- a/xmltooling/base.h +++ b/xmltooling/base.h @@ -30,11 +30,6 @@ #include #endif -/** - * @namespace xmltooling - * Public namespace of XML Tooling library - */ - // Windows and GCC4 Symbol Visibility Macros #ifdef WIN32 #define XMLTOOL_IMPORT __declspec(dllimport) @@ -159,9 +154,70 @@ {chLatin_##a, chLatin_##b, chLatin_##c, chLatin_##d, chLatin_##e, chLatin_##f, chLatin_##g, chLatin_##h, chLatin_##i, \ chLatin_##j, chLatin_##k, chLatin_##l, chLatin_##m, chLatin_##n, chLatin_##o, chLatin_##p, chLatin_##q, chLatin_##r, \ chLatin_##s, chLatin_##t, chLatin_##u, chLatin_##v, chLatin_##w, chLatin_##x, chLatin_##y, chLatin_##z, chNull} +#define UNICODE_LITERAL_27(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,aa) \ + {chLatin_##a, chLatin_##b, chLatin_##c, chLatin_##d, chLatin_##e, chLatin_##f, chLatin_##g, chLatin_##h, chLatin_##i, \ + chLatin_##j, chLatin_##k, chLatin_##l, chLatin_##m, chLatin_##n, chLatin_##o, chLatin_##p, chLatin_##q, chLatin_##r, \ + chLatin_##s, chLatin_##t, chLatin_##u, chLatin_##v, chLatin_##w, chLatin_##x, chLatin_##y, chLatin_##z, \ + chLatin_##aa, chNull} +#define UNICODE_LITERAL_28(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,aa,bb) \ + {chLatin_##a, chLatin_##b, chLatin_##c, chLatin_##d, chLatin_##e, chLatin_##f, chLatin_##g, chLatin_##h, chLatin_##i, \ + chLatin_##j, chLatin_##k, chLatin_##l, chLatin_##m, chLatin_##n, chLatin_##o, chLatin_##p, chLatin_##q, chLatin_##r, \ + chLatin_##s, chLatin_##t, chLatin_##u, chLatin_##v, chLatin_##w, chLatin_##x, chLatin_##y, chLatin_##z, \ + chLatin_##aa, chLatin_##bb, chNull} +#define UNICODE_LITERAL_29(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,aa,bb,cc) \ + {chLatin_##a, chLatin_##b, chLatin_##c, chLatin_##d, chLatin_##e, chLatin_##f, chLatin_##g, chLatin_##h, chLatin_##i, \ + chLatin_##j, chLatin_##k, chLatin_##l, chLatin_##m, chLatin_##n, chLatin_##o, chLatin_##p, chLatin_##q, chLatin_##r, \ + chLatin_##s, chLatin_##t, chLatin_##u, chLatin_##v, chLatin_##w, chLatin_##x, chLatin_##y, chLatin_##z, \ + chLatin_##aa, chLatin_##bb, chLatin_##cc, chNull} +#define UNICODE_LITERAL_30(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,aa,bb,cc,dd) \ + {chLatin_##a, chLatin_##b, chLatin_##c, chLatin_##d, chLatin_##e, chLatin_##f, chLatin_##g, chLatin_##h, chLatin_##i, \ + chLatin_##j, chLatin_##k, chLatin_##l, chLatin_##m, chLatin_##n, chLatin_##o, chLatin_##p, chLatin_##q, chLatin_##r, \ + chLatin_##s, chLatin_##t, chLatin_##u, chLatin_##v, chLatin_##w, chLatin_##x, chLatin_##y, chLatin_##z, \ + chLatin_##aa, chLatin_##bb, chLatin_##cc, chLatin_##dd, chNull} +#define UNICODE_LITERAL_31(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,aa,bb,cc,dd,ee) \ + {chLatin_##a, chLatin_##b, chLatin_##c, chLatin_##d, chLatin_##e, chLatin_##f, chLatin_##g, chLatin_##h, chLatin_##i, \ + chLatin_##j, chLatin_##k, chLatin_##l, chLatin_##m, chLatin_##n, chLatin_##o, chLatin_##p, chLatin_##q, chLatin_##r, \ + chLatin_##s, chLatin_##t, chLatin_##u, chLatin_##v, chLatin_##w, chLatin_##x, chLatin_##y, chLatin_##z, \ + chLatin_##aa, chLatin_##bb, chLatin_##cc, chLatin_##dd, chLatin_##ee, chNull} +#define UNICODE_LITERAL_32(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,aa,bb,cc,dd,ee,ff) \ + {chLatin_##a, chLatin_##b, chLatin_##c, chLatin_##d, chLatin_##e, chLatin_##f, chLatin_##g, chLatin_##h, chLatin_##i, \ + chLatin_##j, chLatin_##k, chLatin_##l, chLatin_##m, chLatin_##n, chLatin_##o, chLatin_##p, chLatin_##q, chLatin_##r, \ + chLatin_##s, chLatin_##t, chLatin_##u, chLatin_##v, chLatin_##w, chLatin_##x, chLatin_##y, chLatin_##z, \ + chLatin_##aa, chLatin_##bb, chLatin_##cc, chLatin_##dd, chLatin_##ee, chLatin_##ff, chNull} +#define UNICODE_LITERAL_33(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,aa,bb,cc,dd,ee,ff,gg) \ + {chLatin_##a, chLatin_##b, chLatin_##c, chLatin_##d, chLatin_##e, chLatin_##f, chLatin_##g, chLatin_##h, chLatin_##i, \ + chLatin_##j, chLatin_##k, chLatin_##l, chLatin_##m, chLatin_##n, chLatin_##o, chLatin_##p, chLatin_##q, chLatin_##r, \ + chLatin_##s, chLatin_##t, chLatin_##u, chLatin_##v, chLatin_##w, chLatin_##x, chLatin_##y, chLatin_##z, \ + chLatin_##aa, chLatin_##bb, chLatin_##cc, chLatin_##dd, chLatin_##ee, chLatin_##ff, chLatin_##gg, chNull} +#define UNICODE_LITERAL_34(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,aa,bb,cc,dd,ee,ff,gg,hh) \ + {chLatin_##a, chLatin_##b, chLatin_##c, chLatin_##d, chLatin_##e, chLatin_##f, chLatin_##g, chLatin_##h, chLatin_##i, \ + chLatin_##j, chLatin_##k, chLatin_##l, chLatin_##m, chLatin_##n, chLatin_##o, chLatin_##p, chLatin_##q, chLatin_##r, \ + chLatin_##s, chLatin_##t, chLatin_##u, chLatin_##v, chLatin_##w, chLatin_##x, chLatin_##y, chLatin_##z, \ + chLatin_##aa, chLatin_##bb, chLatin_##cc, chLatin_##dd, chLatin_##ee, chLatin_##ff, chLatin_##gg, chLatin_##hh, chNull} #endif /* DOXYGEN_SKIP */ /** + * Begins the declaration of an XMLObject specialization for an abstract element/type. + * 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 base class to derive from using public virtual inheritance + * @param desc documentation comment for class + */ +#define DECL_XMLOBJECT_ABSTRACT(linkage,cname,base,desc) \ + XMLTOOLING_DOXYGEN(desc) \ + class linkage cname : public virtual base { \ + protected: \ + cname() {} \ + public: \ + virtual ~cname() {} \ + XMLTOOLING_DOXYGEN(Element local name) \ + static const XMLCh LOCAL_NAME[]; \ + } + +/** * Begins the declaration of an XMLObject specialization. * Basic boilerplate includes a protected constructor, empty virtual destructor, * and Unicode constants for the default associated element's name and prefix. @@ -169,9 +225,83 @@ * @param linkage linkage specifier for the class * @param cname the name of the class to declare * @param base the base class to derive from using public virtual inheritance + * @param desc documentation comment for class */ -#define BEGIN_XMLOBJECT(linkage,cname,base) \ - class linkage cname : public virtual base, public virtual ValidatingXMLObject { \ +#define BEGIN_XMLOBJECT(linkage,cname,base,desc) \ + XMLTOOLING_DOXYGEN(desc) \ + class linkage cname : public virtual base { \ + 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[] + +/** + * Begins the declaration of an XMLObject specialization with two 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 desc documentation comment for class + */ +#define BEGIN_XMLOBJECT2(linkage,cname,base,base2,desc) \ + XMLTOOLING_DOXYGEN(desc) \ + class linkage cname : public virtual base, public virtual base2 { \ + 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[] + +/** + * Begins the declaration of an XMLObject specialization with three 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 desc documentation comment for class + */ +#define BEGIN_XMLOBJECT3(linkage,cname,base,base2,base3,desc) \ + XMLTOOLING_DOXYGEN(desc) \ + class linkage cname : public virtual base, public virtual base2, public virtual base3 { \ + 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[] + +/** + * Begins the declaration of an XMLObject specialization with four 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 desc documentation comment for class + */ +#define BEGIN_XMLOBJECT4(linkage,cname,base,base2,base3,base4,desc) \ + XMLTOOLING_DOXYGEN(desc) \ + class linkage cname : public virtual base, public virtual base2, public virtual base3, public virtual base4 { \ protected: \ cname() {} \ public: \ @@ -187,42 +317,247 @@ #define END_XMLOBJECT } /** - * Declares abstract get/set methods for a named XML attribute. + * Declares abstract get/set methods for a typed XML attribute. * * @param proper the proper name of the attribute * @param upcased the upcased name of the attribute + * @param type the attribute's data type */ -#define DECL_XMLOBJECT_ATTRIB(proper,upcased) \ +#define DECL_XMLOBJECT_ATTRIB(proper,upcased,type) \ public: \ XMLTOOLING_DOXYGEN(proper attribute name) \ static const XMLCh upcased##_ATTRIB_NAME[]; \ XMLTOOLING_DOXYGEN(Returns the proper attribute.) \ - virtual const XMLCh* get##proper() const=0; \ + virtual const type* get##proper() const=0; \ XMLTOOLING_DOXYGEN(Sets the proper attribute.) \ - virtual void set##proper(const XMLCh* proper)=0 + virtual void set##proper(const type* proper)=0 /** - * Implements get/set methods and a private member for a named XML attribute. + * Declares abstract get/set methods for a string XML attribute. * * @param proper the proper name of the attribute + * @param upcased the upcased name of the attribute */ -#define IMPL_XMLOBJECT_ATTRIB(proper) \ - private: \ - XMLCh* m_##proper; \ +#define DECL_STRING_ATTRIB(proper,upcased) \ + DECL_XMLOBJECT_ATTRIB(proper,upcased,XMLCh) + +/** + * Declares abstract get/set methods for a string XML attribute. + * + * @param proper the proper name of the attribute + * @param upcased the upcased name of the attribute + */ +#define DECL_DATETIME_ATTRIB(proper,upcased) \ + DECL_XMLOBJECT_ATTRIB(proper,upcased,xmltooling::DateTime); \ + XMLTOOLING_DOXYGEN(Returns the proper attribute in epoch form.) \ + virtual time_t get##proper##Epoch() const=0; \ + XMLTOOLING_DOXYGEN(Sets the proper attribute.) \ + virtual void set##proper(time_t proper)=0; \ + XMLTOOLING_DOXYGEN(Sets the proper attribute.) \ + virtual void set##proper(const XMLCh* proper)=0 + +/** + * Declares abstract get/set methods for an integer XML attribute. + * + * @param proper the proper name of the attribute + * @param upcased the upcased name of the attribute + */ +#define DECL_INTEGER_ATTRIB(proper,upcased) \ public: \ - const XMLCh* get##proper() const { \ + XMLTOOLING_DOXYGEN(proper attribute name) \ + static const XMLCh upcased##_ATTRIB_NAME[]; \ + XMLTOOLING_DOXYGEN(Returns the proper attribute after a NULL indicator.) \ + virtual std::pair get##proper() const=0; \ + XMLTOOLING_DOXYGEN(Sets the proper attribute using a string value.) \ + virtual void set##proper(const XMLCh* proper)=0; \ + XMLTOOLING_DOXYGEN(Sets the proper attribute.) \ + virtual void set##proper(int proper)=0 + +/** + * Declares abstract get/set methods for a boolean XML attribute. + * + * @param proper the proper name of the attribute + * @param upcased the upcased name of the attribute + * @param def the default/presumed value, if no explicit value has been set + */ +#define DECL_BOOLEAN_ATTRIB(proper,upcased,def) \ + public: \ + XMLTOOLING_DOXYGEN(proper attribute name) \ + static const XMLCh upcased##_ATTRIB_NAME[]; \ + XMLTOOLING_DOXYGEN(Returns the proper attribute or def if not set.) \ + bool proper() const { \ + switch (get##proper()) { \ + case xmltooling::XMLConstants::XML_BOOL_TRUE: \ + case xmltooling::XMLConstants::XML_BOOL_ONE: \ + return true; \ + case xmltooling::XMLConstants::XML_BOOL_FALSE: \ + case xmltooling::XMLConstants::XML_BOOL_ZERO: \ + return false; \ + default: \ + return def; \ + } \ + } \ + XMLTOOLING_DOXYGEN(Returns the proper attribute as an explicit enumerated value.) \ + virtual xmltooling::XMLConstants::xmltooling_bool_t get##proper() const=0; \ + XMLTOOLING_DOXYGEN(Sets the proper attribute using an enumerated value.) \ + virtual void proper(xmltooling::XMLConstants::xmltooling_bool_t value)=0; \ + XMLTOOLING_DOXYGEN(Sets the proper attribute.) \ + void proper(bool value) { \ + proper(value ? xmltooling::XMLConstants::XML_BOOL_ONE : xmltooling::XMLConstants::XML_BOOL_ZERO); \ + } \ + XMLTOOLING_DOXYGEN(Sets the proper attribute using a string constant.) \ + void set##proper(const XMLCh* value) { \ + if (value) { \ + switch (*value) { \ + case chLatin_t: \ + proper(xmltooling::XMLConstants::XML_BOOL_TRUE); \ + break; \ + case chLatin_f: \ + proper(xmltooling::XMLConstants::XML_BOOL_FALSE); \ + break; \ + case chDigit_1: \ + proper(xmltooling::XMLConstants::XML_BOOL_ONE); \ + break; \ + case chDigit_0: \ + proper(xmltooling::XMLConstants::XML_BOOL_ZERO); \ + break; \ + default: \ + proper(xmltooling::XMLConstants::XML_BOOL_NULL); \ + } \ + } \ + else \ + proper(xmltooling::XMLConstants::XML_BOOL_NULL); \ + } + +/** + * Implements get/set methods and a private member for a typed XML attribute. + * + * @param proper the proper name of the attribute + * @param type the attribute's data type + */ +#define IMPL_XMLOBJECT_ATTRIB(proper,type) \ + protected: \ + type* m_##proper; \ + public: \ + const type* get##proper() const { \ return m_##proper; \ } \ + void set##proper(const type* proper) { \ + m_##proper = prepareForAssignment(m_##proper,proper); \ + } + +/** + * Implements get/set methods and a private member for a string XML attribute. + * + * @param proper the proper name of the attribute + */ +#define IMPL_STRING_ATTRIB(proper) \ + IMPL_XMLOBJECT_ATTRIB(proper,XMLCh) + +/** + * Implements get/set methods and a private member for a string XML attribute, + * plus a getXMLID override. + * + * @param proper the proper name of the attribute + */ +#define IMPL_ID_ATTRIB(proper) \ + IMPL_XMLOBJECT_ATTRIB(proper,XMLCh) \ + const XMLCh* getXMLID() const { \ + return m_##proper; \ + } + +/** + * Implements get/set methods and a private member for a DateTime XML attribute. + * + * @param proper the proper name of the attribute + * @param fallback epoch to return when attribute is NULL + */ +#define IMPL_DATETIME_ATTRIB(proper,fallback) \ + protected: \ + DateTime* m_##proper; \ + time_t m_##proper##Epoch; \ + public: \ + const DateTime* get##proper() const { \ + return m_##proper; \ + } \ + time_t get##proper##Epoch() const { \ + return m_##proper ? m_##proper##Epoch : fallback; \ + } \ + void set##proper(const DateTime* proper) { \ + m_##proper = prepareForAssignment(m_##proper,proper); \ + if (m_##proper) \ + m_##proper##Epoch=m_##proper->getEpoch(); \ + } \ + void set##proper(time_t proper) { \ + m_##proper = prepareForAssignment(m_##proper,proper); \ + m_##proper##Epoch = proper; \ + } \ void set##proper(const XMLCh* proper) { \ m_##proper = prepareForAssignment(m_##proper,proper); \ + if (m_##proper) \ + m_##proper##Epoch=m_##proper->getEpoch(); \ } /** + * Implements get/set methods and a private member for an integer XML attribute. + * + * @param proper the proper name of the attribute + */ +#define IMPL_INTEGER_ATTRIB(proper) \ + protected: \ + XMLCh* m_##proper; \ + public: \ + pair get##proper() const { \ + return make_pair((m_##proper!=NULL),(m_##proper!=NULL ? XMLString::parseInt(m_##proper): 0)); \ + } \ + void set##proper(const XMLCh* proper) { \ + m_##proper = prepareForAssignment(m_##proper,proper); \ + } \ + void set##proper(int proper) { \ + char buf##proper[64]; \ + sprintf(buf##proper,"%d",proper); \ + auto_ptr_XMLCh wide##proper(buf##proper); \ + set##proper(wide##proper.get()); \ + } + +/** + * Implements get/set methods and a private member for a boolean XML attribute. + * + * @param proper the proper name of the attribute + */ +#define IMPL_BOOLEAN_ATTRIB(proper) \ + protected: \ + XMLConstants::xmltooling_bool_t m_##proper; \ + public: \ + XMLConstants::xmltooling_bool_t get##proper() const { \ + return m_##proper; \ + } \ + void proper(XMLConstants::xmltooling_bool_t value) { \ + if (m_##proper != value) { \ + releaseThisandParentDOM(); \ + m_##proper = value; \ + } \ + } + +/** + * Declares abstract get/set methods for a typed XML child object in a foreign namespace. + * + * @param proper the proper name of the child type + * @param ns the C++ namespace for the type + */ +#define DECL_TYPED_FOREIGN_CHILD(proper,ns) \ + public: \ + XMLTOOLING_DOXYGEN(Returns the proper child.) \ + virtual ns::proper* get##proper() const=0; \ + XMLTOOLING_DOXYGEN(Sets the proper child.) \ + virtual void set##proper(ns::proper* child)=0 + +/** * Declares abstract get/set methods for a typed XML child object. * * @param proper the proper name of the child type */ -#define DECL_XMLOBJECT_CHILD(proper) \ +#define DECL_TYPED_CHILD(proper) \ public: \ XMLTOOLING_DOXYGEN(Returns the proper child.) \ virtual proper* get##proper() const=0; \ @@ -230,14 +565,27 @@ virtual void set##proper(proper* child)=0 /** + * Declares abstract get/set methods for a generic XML child object. + * + * @param proper the proper name of the child + */ +#define DECL_XMLOBJECT_CHILD(proper) \ + public: \ + XMLTOOLING_DOXYGEN(Returns the proper child.) \ + virtual xmltooling::XMLObject* get##proper() const=0; \ + XMLTOOLING_DOXYGEN(Sets the proper child.) \ + virtual void set##proper(xmltooling::XMLObject* child)=0 + + +/** * Implements get/set methods and a private list iterator member for a typed XML child object. * * @param proper the proper name of the child type */ -#define IMPL_XMLOBJECT_CHILD(proper) \ - private: \ +#define IMPL_TYPED_CHILD(proper) \ + protected: \ proper* m_##proper; \ - std::list::iterator m_pos_##proper; \ + std::list::iterator m_pos_##proper; \ public: \ proper* get##proper() const { \ return m_##proper; \ @@ -248,11 +596,49 @@ } /** + * Implements get/set methods and a private list iterator member for + * a typed XML child object in a foreign namespace + * + * @param proper the proper name of the child type + * @param ns the C++ namespace for the type + */ +#define IMPL_TYPED_FOREIGN_CHILD(proper,ns) \ + protected: \ + ns::proper* m_##proper; \ + std::list::iterator m_pos_##proper; \ + public: \ + ns::proper* get##proper() const { \ + return m_##proper; \ + } \ + void set##proper(ns::proper* child) { \ + prepareForAssignment(m_##proper,child); \ + *m_pos_##proper = m_##proper = child; \ + } + +/** + * Implements get/set methods and a private list iterator member for a generic XML child object. + * + * @param proper the proper name of the child + */ +#define IMPL_XMLOBJECT_CHILD(proper) \ + protected: \ + xmltooling::XMLObject* m_##proper; \ + std::list::iterator m_pos_##proper; \ + public: \ + xmltooling::XMLObject* get##proper() const { \ + return m_##proper; \ + } \ + void set##proper(xmltooling::XMLObject* child) { \ + prepareForAssignment(m_##proper,child); \ + *m_pos_##proper = m_##proper = child; \ + } + +/** * Declares abstract get/set methods for a typed XML child collection. * * @param proper the proper name of the child type */ -#define DECL_XMLOBJECT_CHILDREN(proper) \ +#define DECL_TYPED_CHILDREN(proper) \ public: \ XMLTOOLING_DOXYGEN(Returns modifiable proper collection.) \ virtual VectorOf(proper) get##proper##s()=0; \ @@ -260,13 +646,38 @@ virtual const std::vector& get##proper##s() const=0 /** + * Declares abstract get/set methods for a typed XML child collection in a foreign namespace. + * + * @param proper the proper name of the child type + * @param ns the C++ namespace for the type + */ +#define DECL_TYPED_FOREIGN_CHILDREN(proper,ns) \ + public: \ + XMLTOOLING_DOXYGEN(Returns modifiable proper collection.) \ + virtual VectorOf(ns::proper) get##proper##s()=0; \ + XMLTOOLING_DOXYGEN(Returns reference to immutable proper collection.) \ + virtual const std::vector& get##proper##s() const=0 + +/** + * Declares abstract get/set methods for a generic XML child collection. + * + * @param proper the proper name of the child + */ +#define DECL_XMLOBJECT_CHILDREN(proper) \ + public: \ + XMLTOOLING_DOXYGEN(Returns modifiable proper collection.) \ + virtual VectorOf(xmltooling::XMLObject) get##proper##s()=0; \ + XMLTOOLING_DOXYGEN(Returns reference to immutable proper collection.) \ + virtual const std::vector& get##proper##s() const=0 + +/** * Implements get method and a private vector member for a typed XML child collection. * * @param proper the proper name of the child type * @param fence insertion fence for new objects of the child collection in backing list */ -#define IMPL_XMLOBJECT_CHILDREN(proper,fence) \ - private: \ +#define IMPL_TYPED_CHILDREN(proper,fence) \ + protected: \ std::vector m_##proper##s; \ public: \ VectorOf(proper) get##proper##s() { \ @@ -277,13 +688,207 @@ } /** + * Implements get method and a private vector member for a typed XML child collection + * in a foreign namespace. + * + * @param proper the proper name of the child type + * @param ns the C++ namespace for the type + * @param fence insertion fence for new objects of the child collection in backing list + */ +#define IMPL_TYPED_FOREIGN_CHILDREN(proper,ns,fence) \ + protected: \ + std::vector m_##proper##s; \ + public: \ + VectorOf(ns::proper) get##proper##s() { \ + return VectorOf(ns::proper)(this, m_##proper##s, &m_children, fence); \ + } \ + const std::vector& get##proper##s() const { \ + return m_##proper##s; \ + } + +/** + * Implements get method and a private vector member for a generic XML child collection. + * + * @param proper the proper name of the child + * @param fence insertion fence for new objects of the child collection in backing list + */ +#define IMPL_XMLOBJECT_CHILDREN(proper,fence) \ + protected: \ + std::vector m_##proper##s; \ + public: \ + VectorOf(xmltooling::XMLObject) get##proper##s() { \ + return VectorOf(xmltooling::XMLObject)(this, m_##proper##s, &m_children, fence); \ + } \ + const std::vector& get##proper##s() const { \ + return m_##proper##s; \ + } + +/** + * Implements marshalling for a string attribute + * + * @param proper the proper name of the attribute + * @param ucase the upcased name of the attribute + * @param namespaceURI the XML namespace of the attribute + */ +#define MARSHALL_STRING_ATTRIB(proper,ucase,namespaceURI) \ + if (m_##proper) { \ + domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, m_##proper); \ + } + +/** + * Implements marshalling for a DateTime attribute + * + * @param proper the proper name of the attribute + * @param ucase the upcased name of the attribute + * @param namespaceURI the XML namespace of the attribute + */ +#define MARSHALL_DATETIME_ATTRIB(proper,ucase,namespaceURI) \ + if (m_##proper) { \ + domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, m_##proper->getRawData()); \ + } + +/** + * Implements marshalling for an integer attribute + * + * @param proper the proper name of the attribute + * @param ucase the upcased name of the attribute + * @param namespaceURI the XML namespace of the attribute + */ +#define MARSHALL_INTEGER_ATTRIB(proper,ucase,namespaceURI) \ + if (m_##proper) { \ + domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, m_##proper); \ + } + +/** + * Implements marshalling for a boolean attribute + * + * @param proper the proper name of the attribute + * @param ucase the upcased name of the attribute + * @param namespaceURI the XML namespace of the attribute + */ +#define MARSHALL_BOOLEAN_ATTRIB(proper,ucase,namespaceURI) \ + switch (m_##proper) { \ + case XMLConstants::XML_BOOL_TRUE: \ + domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, XMLConstants::XML_TRUE); \ + break; \ + case XMLConstants::XML_BOOL_ONE: \ + domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, XMLConstants::XML_ONE); \ + break; \ + case XMLConstants::XML_BOOL_FALSE: \ + domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, XMLConstants::XML_FALSE); \ + break; \ + case XMLConstants::XML_BOOL_ZERO: \ + domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, XMLConstants::XML_ZERO); \ + break; \ + case XMLConstants::XML_BOOL_NULL: \ + break; \ + } + +/** + * Implements marshalling for a QName attribute + * + * @param proper the proper name of the attribute + * @param ucase the upcased name of the attribute + * @param namespaceURI the XML namespace of the attribute + */ +#define MARSHALL_QNAME_ATTRIB(proper,ucase,namespaceURI) \ + if (m_##proper) { \ + auto_ptr_XMLCh qstr(m_##proper->toString().c_str()); \ + domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, qstr.get()); \ + } + +/** + * Implements marshalling for an ID attribute + * + * @param proper the proper name of the attribute + * @param ucase the upcased name of the attribute + * @param namespaceURI the XML namespace of the attribute + */ +#define MARSHALL_ID_ATTRIB(proper,ucase,namespaceURI) \ + if (m_##proper) { \ + domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, m_##proper); \ + domElement->setIdAttributeNS(namespaceURI, ucase##_ATTRIB_NAME); \ + } + +/** + * Implements unmarshalling process branch for a string attribute + * + * @param proper the proper name of the attribute + * @param ucase the upcased name of the attribute + * @param namespaceURI the XML namespace of the attribute + */ +#define PROC_STRING_ATTRIB(proper,ucase,namespaceURI) \ + if (xmltooling::XMLHelper::isNodeNamed(attribute, namespaceURI, ucase##_ATTRIB_NAME)) { \ + set##proper(attribute->getValue()); \ + return; \ + } + +/** + * Implements unmarshalling process branch for an ID attribute + * + * @param proper the proper name of the attribute + * @param ucase the upcased name of the attribute + * @param namespaceURI the XML namespace of the attribute + */ +#define PROC_ID_ATTRIB(proper,ucase,namespaceURI) \ + if (xmltooling::XMLHelper::isNodeNamed(attribute, namespaceURI, ucase##_ATTRIB_NAME)) { \ + set##proper(attribute->getValue()); \ + attribute->getOwnerElement()->setIdAttributeNode(attribute); \ + return; \ + } + +/** + * Implements unmarshalling process branch for a DateTime attribute + * + * @param proper the proper name of the attribute + * @param ucase the upcased name of the attribute + * @param namespaceURI the XML namespace of the attribute + */ +#define PROC_DATETIME_ATTRIB(proper,ucase,namespaceURI) \ + PROC_STRING_ATTRIB(proper,ucase,namespaceURI) + +/** + * Implements unmarshalling process branch for a DateTime attribute + * + * @param proper the proper name of the attribute + * @param ucase the upcased name of the attribute + * @param namespaceURI the XML namespace of the attribute + */ +#define PROC_QNAME_ATTRIB(proper,ucase,namespaceURI) \ + if (xmltooling::XMLHelper::isNodeNamed(attribute, namespaceURI, ucase##_ATTRIB_NAME)) { \ + set##proper(XMLHelper::getAttributeValueAsQName(attribute)); \ + return; \ + } + +/** + * Implements unmarshalling process branch for an integer attribute + * + * @param proper the proper name of the attribute + * @param ucase the upcased name of the attribute + * @param namespaceURI the XML namespace of the attribute + */ +#define PROC_INTEGER_ATTRIB(proper,ucase,namespaceURI) \ + PROC_STRING_ATTRIB(proper,ucase,namespaceURI) + +/** + * Implements unmarshalling process branch for a boolean attribute + * + * @param proper the proper name of the attribute + * @param ucase the upcased name of the attribute + * @param namespaceURI the XML namespace of the attribute + */ +#define PROC_BOOLEAN_ATTRIB(proper,ucase,namespaceURI) \ + PROC_STRING_ATTRIB(proper,ucase,namespaceURI) + +/** * Implements unmarshalling process branch for typed child collection element * * @param proper the proper name of the child type * @param namespaceURI the XML namespace of the child element + * @param force bypass use of hint and just cast down to check child */ -#define PROC_XMLOBJECT_CHILDREN(proper,namespaceURI) \ - if (XMLHelper::isNodeNamed(root,namespaceURI,proper::LOCAL_NAME)) { \ +#define PROC_TYPED_CHILDREN(proper,namespaceURI,force) \ + if (force || xmltooling::XMLHelper::isNodeNamed(root,namespaceURI,proper::LOCAL_NAME)) { \ proper* typesafe=dynamic_cast(childXMLObject); \ if (typesafe) { \ get##proper##s().push_back(typesafe); \ @@ -292,13 +897,32 @@ } /** + * Implements unmarshalling process branch for typed child collection element + * in a foreign namespace. + * + * @param proper the proper name of the child type + * @param ns the C++ namespace for the type + * @param namespaceURI the XML namespace of the child element + * @param force bypass use of hint and just cast down to check child + */ +#define PROC_TYPED_FOREIGN_CHILDREN(proper,ns,namespaceURI,force) \ + if (force || xmltooling::XMLHelper::isNodeNamed(root,namespaceURI,ns::proper::LOCAL_NAME)) { \ + ns::proper* typesafe=dynamic_cast(childXMLObject); \ + if (typesafe) { \ + get##proper##s().push_back(typesafe); \ + return; \ + } \ + } + +/** * Implements unmarshalling process branch for typed child singleton element * * @param proper the proper name of the child type * @param namespaceURI the XML namespace of the child element + * @param force bypass use of hint and just cast down to check child */ -#define PROC_XMLOBJECT_CHILD(proper,namespaceURI) \ - if (XMLHelper::isNodeNamed(root,namespaceURI,proper::LOCAL_NAME)) { \ +#define PROC_TYPED_CHILD(proper,namespaceURI,force) \ + if (force || xmltooling::XMLHelper::isNodeNamed(root,namespaceURI,proper::LOCAL_NAME)) { \ proper* typesafe=dynamic_cast(childXMLObject); \ if (typesafe) { \ set##proper(typesafe); \ @@ -307,39 +931,84 @@ } /** - * Declares abstract get/set methods for named XML element content. + * Implements unmarshalling process branch for typed child singleton element + * in a foreign namespace. + * + * @param proper the proper name of the child type + * @param ns the C++ namespace for the type + * @param namespaceURI the XML namespace of the child element + * @param force bypass use of hint and just cast down to check child + */ +#define PROC_TYPED_FOREIGN_CHILD(proper,ns,namespaceURI,force) \ + if (force || xmltooling::XMLHelper::isNodeNamed(root,namespaceURI,ns::proper::LOCAL_NAME)) { \ + ns::proper* typesafe=dynamic_cast(childXMLObject); \ + if (typesafe) { \ + set##proper(typesafe); \ + return; \ + } \ + } + +/** + * Implements unmarshalling process branch for a generic child singleton element + * + * @param proper the proper name of the child type + * @param namespaceURI the XML namespace of the child element + */ +#define PROC_XMLOBJECT_CHILD(proper,namespaceURI) \ + if (xmltooling::XMLHelper::isNodeNamed(root,namespaceURI,proper::LOCAL_NAME)) { \ + set##proper(childXMLObject); \ + return; \ + } + +/** + * 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. + * Declares aliased get/set methods for named integer XML element content. * * @param proper the proper name to label the element's 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 DECL_INTEGER_CONTENT(proper) \ + XMLTOOLING_DOXYGEN(Returns proper in integer form after a NULL indicator.) \ + std::pair get##proper() const { \ + return std::make_pair((getTextContent()!=NULL), (getTextContent()!=NULL ? XMLString::parseInt(getTextContent()) : NULL)); \ + } \ + XMLTOOLING_DOXYGEN(Sets proper.) \ + void set##proper(int proper) { \ + char buf[64]; \ + sprintf(buf,"%d",proper); \ + xmltooling::auto_ptr_XMLCh widebuf(buf); \ + setTextContent(widebuf.get()); \ + } \ + XMLTOOLING_DOXYGEN(Sets or clears proper.) \ + void set##proper(const XMLCh* proper) { \ + setTextContent(proper); \ + } + +/** + * Implements marshalling/unmarshalling for element content. + */ +#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); \ } @@ -353,7 +1022,7 @@ return clone(); \ } \ cname* clone() const { \ - auto_ptr domClone(AbstractDOMCachingXMLObject::clone()); \ + std::auto_ptr domClone(xmltooling::AbstractDOMCachingXMLObject::clone()); \ cname##Impl* ret=dynamic_cast(domClone.get()); \ if (ret) { \ domClone.release(); \ @@ -369,10 +1038,10 @@ * @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 + * @param desc documentation for class */ #define DECL_XMLOBJECT_SIMPLE(linkage,cname,proper,desc) \ - XMLTOOLING_DOXYGEN(desc) \ - BEGIN_XMLOBJECT(linkage,cname,XMLObject); \ + BEGIN_XMLOBJECT(linkage,cname,xmltooling::SimpleElement,desc); \ DECL_XMLOBJECT_CONTENT(proper); \ END_XMLOBJECT @@ -382,29 +1051,27 @@ * * @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 AbstractDOMCachingXMLObject, \ - public AbstractValidatingXMLObject, \ - public AbstractXMLObjectMarshaller, \ - public AbstractXMLObjectUnmarshaller \ + : public virtual cname, \ + public xmltooling::AbstractSimpleElement, \ + public xmltooling::AbstractChildlessElement, \ + public xmltooling::AbstractDOMCachingXMLObject, \ + public xmltooling::AbstractXMLObjectMarshaller, \ + public xmltooling::AbstractXMLObjectUnmarshaller \ { \ public: \ virtual ~cname##Impl() {} \ cname##Impl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType) \ - : AbstractXMLObject(nsURI, localName, prefix, schemaType), m_##proper(NULL) { \ + : xmltooling::AbstractXMLObject(nsURI, localName, prefix, schemaType) { \ } \ cname##Impl(const cname##Impl& src) \ - : AbstractXMLObject(src), \ - AbstractDOMCachingXMLObject(src), \ - AbstractValidatingXMLObject(src), \ - m_##proper(XMLString::replicate(src.m_##proper)) { \ - } \ + : xmltooling::AbstractXMLObject(src), \ + xmltooling::AbstractSimpleElement(src), \ + xmltooling::AbstractDOMCachingXMLObject(src) {} \ IMPL_XMLOBJECT_CLONE(cname) \ - IMPL_XMLOBJECT_CONTENT(proper) \ + IMPL_XMLOBJECT_CONTENT \ } /** @@ -426,8 +1093,9 @@ virtual cname* buildObject() const { \ return buildObject(namespaceURI,cname::LOCAL_NAME,namespacePrefix); \ } \ + XMLTOOLING_DOXYGEN(Builder that allows element/type override.) \ virtual cname* buildObject( \ - const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix=NULL, const QName* schemaType=NULL \ + const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix=NULL, const xmltooling::QName* schemaType=NULL \ ) const /** @@ -445,6 +1113,15 @@ */ #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( \ + XMLObjectBuilder::getBuilder(xmltooling::QName(namespaceURI,cname::LOCAL_NAME)) \ + ); \ + if (b) \ + return b->buildObject(); \ + throw xmltooling::XMLObjectException("Unable to obtain typed builder for "#cname"."); \ + } \ END_XMLOBJECTBUILDER /** @@ -467,17 +1144,31 @@ * @param cname the base name of the Validator specialization */ #define BEGIN_XMLOBJECTVALIDATOR(linkage,cname) \ - class linkage cname##SchemaValidator : public Validator \ + class linkage cname##SchemaValidator : public xmltooling::Validator \ { \ public: \ virtual ~cname##SchemaValidator() {} \ - virtual cname##SchemaValidator* clone() const { \ - return new cname##SchemaValidator(); \ - } \ - virtual void validate(const XMLObject* xmlObject) const { \ + virtual void validate(const xmltooling::XMLObject* xmlObject) const { \ const cname* ptr=dynamic_cast(xmlObject); \ if (!ptr) \ - throw ValidationException(#cname"SchemaValidator: unsupported object type ($1).",xmltooling::params(1,typeid(xmlObject).name())) + throw xmltooling::ValidationException(#cname"SchemaValidator: unsupported object type ($1).",xmltooling::params(1,typeid(xmlObject).name())) + +/** + * Begins the declaration of a Schema Validator specialization subclass. + * + * @param linkage linkage specifier for the class + * @param cname the base name of the Validator specialization + * @param base base class for the validator + */ + #define BEGIN_XMLOBJECTVALIDATOR_SUB(linkage,cname,base) \ + class linkage cname##SchemaValidator : public base##SchemaValidator \ + { \ + public: \ + virtual ~cname##SchemaValidator() {} \ + virtual void validate(const xmltooling::XMLObject* xmlObject) const { \ + const cname* ptr=dynamic_cast(xmlObject); \ + if (!ptr) \ + throw xmltooling::ValidationException(#cname"SchemaValidator: unsupported object type ($1).",xmltooling::params(1,typeid(xmlObject).name())) /** * Ends the declaration of a Validator specialization. @@ -492,7 +1183,7 @@ #define XMLOBJECTVALIDATOR_CHECKTYPE(cname) \ const cname* ptr=dynamic_cast(xmlObject); \ if (!ptr) \ - throw ValidationException(#cname"SchemaValidator: unsupported object type ($1).",xmltooling::params(1,typeid(xmlObject).name())) + throw xmltooling::ValidationException(#cname"SchemaValidator: unsupported object type ($1).",xmltooling::params(1,typeid(xmlObject).name())) /** * Validator code that checks for a required attribute, content, or singleton. @@ -502,7 +1193,17 @@ */ #define XMLOBJECTVALIDATOR_REQUIRE(cname,proper) \ if (!ptr->get##proper()) \ - throw ValidationException(#cname" must have "#proper".") + throw xmltooling::ValidationException(#cname" must have "#proper".") + +/** + * Validator code that checks for a required integer attribute + * + * @param cname the name of the XMLObject specialization + * @param proper the proper name of the attribute, content, or singleton member + */ +#define XMLOBJECTVALIDATOR_REQUIRE_INTEGER(cname,proper) \ + if (!ptr->get##proper().first) \ + throw xmltooling::ValidationException(#cname" must have "#proper".") /** * Validator code that checks for one of a pair of @@ -514,7 +1215,19 @@ */ #define XMLOBJECTVALIDATOR_ONEOF(cname,proper1,proper2) \ if (!ptr->get##proper1() && !ptr->get##proper2()) \ - throw ValidationException(#cname" must have "#proper1" or "#proper2".") + throw xmltooling::ValidationException(#cname" must have "#proper1" or "#proper2".") + +/** + * Validator code that checks for one of a pair of + * required attributes, content, or singletons, but disallows both. + * + * @param cname the name of the XMLObject specialization + * @param proper1 the proper name of the first attribute, content, or singleton member + * @param proper2 the proper name of the second attribute, content, or singleton member + */ +#define XMLOBJECTVALIDATOR_ONLYONEOF(cname,proper1,proper2) \ + if ((!ptr->get##proper1() && !ptr->get##proper2()) || (ptr->get##proper1() && ptr->get##proper2())) \ + throw xmltooling::ValidationException(#cname" must have "#proper1" or "#proper2" but not both.") /** * Validator code that checks for one of a set of three @@ -527,7 +1240,27 @@ */ #define XMLOBJECTVALIDATOR_ONEOF3(cname,proper1,proper2,proper3) \ if (!ptr->get##proper1() && !ptr->get##proper2() && !ptr->get##proper3()) \ - throw ValidationException(#cname" must have "#proper1", "#proper2", or "#proper3".") + throw xmltooling::ValidationException(#cname" must have "#proper1", "#proper2", or "#proper3".") + +/** + * Validator code that checks for one of a set of three + * required attributes, content, or singletons but disallows more than one. + * + * @param cname the name of the XMLObject specialization + * @param proper1 the proper name of the first attribute, content, or singleton member + * @param proper2 the proper name of the second attribute, content, or singleton member + * @param proper3 the proper name of the third attribute, content, or singleton member + */ +#define XMLOBJECTVALIDATOR_ONLYONEOF3(cname,proper1,proper2,proper3) \ + int c##proper1##proper2##proper3=0; \ + if (ptr->get##proper1()!=NULL) \ + c##proper1##proper2##proper3++; \ + if (ptr->get##proper2()!=NULL) \ + c##proper1##proper2##proper3++; \ + if (ptr->get##proper3()!=NULL) \ + c##proper1##proper2##proper3++; \ + if (c##proper1##proper2##proper3 != 1) \ + throw xmltooling::ValidationException(#cname" must have only one of "#proper1", "#proper2", or "#proper3".") /** * Validator code that checks a co-constraint (if one present, the other must be) @@ -539,7 +1272,7 @@ */ #define XMLOBJECTVALIDATOR_NONEORBOTH(cname,proper1,proper2) \ if ((ptr->get##proper1() && !ptr->get##proper2()) || (!ptr->get##proper1() && ptr->get##proper2())) \ - throw ValidationException(#cname" cannot have "#proper1" without "#proper2".") + throw xmltooling::ValidationException(#cname" cannot have "#proper1" without "#proper2".") /** * Validator code that checks for a non-empty collection. @@ -549,7 +1282,7 @@ */ #define XMLOBJECTVALIDATOR_NONEMPTY(cname,proper) \ if (ptr->get##proper##s().empty()) \ - throw ValidationException(#cname" must have at least one "#proper".") + throw xmltooling::ValidationException(#cname" must have at least one "#proper".") /** * Declares/defines a Validator specialization that checks object type and @@ -557,15 +1290,18 @@ * * @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 +/** + * @namespace xmltooling + * Public namespace of XML Tooling library + */ namespace xmltooling { /**