X-Git-Url: http://www.project-moonshot.org/gitweb/?a=blobdiff_plain;f=xmltooling%2Fbase.h;h=5ae111c5a3e4eecd756ce0f97015c99dd2bf049b;hb=f239625ccb33bd1648f119ca4e93ad374aba958a;hp=d1192dc02d7fcf4306c3ae39e4db6fddd6543822;hpb=c5fb8332562b44232477938f00eced1aefaed65c;p=shibboleth%2Fcpp-xmltooling.git diff --git a/xmltooling/base.h b/xmltooling/base.h index d1192dc..5ae111c 100644 --- a/xmltooling/base.h +++ b/xmltooling/base.h @@ -1,24 +1,28 @@ -/* - * Copyright 2001-2008 Internet2 +/** + * Licensed to the University Corporation for Advanced Internet + * Development, Inc. (UCAID) under one or more contributor license + * agreements. See the NOTICE file distributed with this work for + * additional information regarding copyright ownership. * - * 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 + * UCAID licenses this file to you 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 + * 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. + * 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. */ /** * @file xmltooling/base.h * - * Base header file definitions - * Must be included prior to including any other header + * Base header file definitions. + * Must be included prior to including any other header. */ #ifndef __xmltooling_base_h__ @@ -39,6 +43,10 @@ # define XMLTOOLING_NO_XMLSEC 1 #endif +#ifndef HAVE_NULLPTR +# define nullptr 0 +#endif + #if defined(XMLTOOLING_NO_XMLSEC) || !defined(HAVE_XSECSIZE_T) # ifdef XMLTOOLING_XERCESC_64BITSAFE # include @@ -683,16 +691,18 @@ XMLCh* m_##proper; \ public: \ pair get##proper() const { \ - return make_pair((m_##proper!=NULL),(m_##proper!=NULL ? xercesc::XMLString::parseInt(m_##proper): 0)); \ + return make_pair((m_##proper!=nullptr),(m_##proper!=nullptr ? xercesc::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()); \ + try { \ + xmltooling::xstring buf = boost::lexical_cast(proper); \ + set##proper(buf.c_str()); \ + } \ + catch (boost::bad_lexical_cast&) { \ + } \ } /** @@ -730,8 +740,8 @@ } \ void set##proper(const type* proper) { \ m_##proper = prepareForAssignment(m_##proper,proper); \ - XMLString::release(&m_##proper##Prefix); \ - m_##proper##Prefix = NULL; \ + xercesc::XMLString::release(&m_##proper##Prefix); \ + m_##proper##Prefix = nullptr; \ } /** @@ -1011,7 +1021,7 @@ */ #define MARSHALL_QNAME_ATTRIB(proper,ucase,namespaceURI) \ if (m_##proper) { \ - auto_ptr_XMLCh qstr(m_##proper->toString().c_str()); \ + xmltooling::auto_ptr_XMLCh qstr(m_##proper->toString().c_str()); \ domElement->setAttributeNS(namespaceURI, ucase##_ATTRIB_NAME, qstr.get()); \ } @@ -1105,7 +1115,8 @@ */ #define PROC_QNAME_ATTRIB(proper,ucase,namespaceURI) \ if (xmltooling::XMLHelper::isNodeNamed(attribute, namespaceURI, ucase##_ATTRIB_NAME)) { \ - set##proper(XMLHelper::getAttributeValueAsQName(attribute)); \ + std::auto_ptr q(xmltooling::XMLHelper::getAttributeValueAsQName(attribute)); \ + set##proper(q.get()); \ return; \ } @@ -1237,14 +1248,16 @@ #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 ? xercesc::XMLString::parseInt(getTextContent()) : 0)); \ + return std::make_pair((getTextContent()!=nullptr), (getTextContent()!=nullptr ? xercesc::XMLString::parseInt(getTextContent()) : 0)); \ } \ 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()); \ + try { \ + xmltooling::xstring buf = boost::lexical_cast(proper); \ + setTextContent(buf.c_str()); \ + } \ + catch (boost::bad_lexical_cast&) { \ + } \ } \ XMLTOOLING_DOXYGEN(Sets or clears proper.) \ void set##proper(const XMLCh* proper) { \ @@ -1254,7 +1267,7 @@ /** * Implements cloning methods for an XMLObject specialization implementation class. * - * @param cname the name of the XMLObject specialization + * @param cname the name of the XMLObject specialization */ #define IMPL_XMLOBJECT_CLONE(cname) \ cname* clone##cname() const { \ @@ -1271,6 +1284,229 @@ } /** + * Implements cloning methods for an XMLObject specialization implementation class + * that must override a base class clone method. + * + * @param cname the name of the XMLObject specialization + * @param base name of base type. + */ +#define IMPL_XMLOBJECT_CLONE2(cname,base) \ + cname* clone##cname() const { \ + return dynamic_cast(clone()); \ + } \ + base* clone##base() const { \ + return dynamic_cast(clone()); \ + } \ + xmltooling::XMLObject* clone() const { \ + std::auto_ptr domClone(xmltooling::AbstractDOMCachingXMLObject::clone()); \ + cname##Impl* ret=dynamic_cast(domClone.get()); \ + if (ret) { \ + domClone.release(); \ + return ret; \ + } \ + return new cname##Impl(*this); \ + } + +/** + * Implements cloning methods for an XMLObject specialization implementation class that + * needs two stage duplication to avoid invoking virtual methods during construction. + * + * @param cname the name of the XMLObject specialization + */ +#define IMPL_XMLOBJECT_CLONE_EX(cname) \ + cname* clone##cname() const { \ + return dynamic_cast(clone()); \ + } \ + xmltooling::XMLObject* clone() const { \ + std::auto_ptr domClone(xmltooling::AbstractDOMCachingXMLObject::clone()); \ + cname##Impl* ret=dynamic_cast(domClone.get()); \ + if (ret) { \ + domClone.release(); \ + return ret; \ + } \ + std::auto_ptr ret2(new cname##Impl(*this)); \ + ret2->_clone(*this); \ + return ret2.release(); \ + } + +/** + * Implements cloning methods for an XMLObject specialization implementation class that + * needs two stage duplication to avoid invoking virtual methods during construction, + * and must override a base class clone method. + * + * @param cname the name of the XMLObject specialization + * @param base name of base type + */ +#define IMPL_XMLOBJECT_CLONE_EX2(cname,base) \ + cname* clone##cname() const { \ + return dynamic_cast(clone()); \ + } \ + base* clone##base() const { \ + return dynamic_cast(clone()); \ + } \ + xmltooling::XMLObject* clone() const { \ + std::auto_ptr domClone(xmltooling::AbstractDOMCachingXMLObject::clone()); \ + cname##Impl* ret=dynamic_cast(domClone.get()); \ + if (ret) { \ + domClone.release(); \ + return ret; \ + } \ + std::auto_ptr ret2(new cname##Impl(*this)); \ + ret2->_clone(*this); \ + return ret2.release(); \ + } + +/** + * Implements cloning of a child attribute, for use in copy constructor or + * deferred clone methods. + * + * proper the proper name of the attribute to clone + */ +#define IMPL_CLONE_ATTRIB(proper) \ + set##proper(src.get##proper()) + +/** + * Implements cloning of a child attribute in a foreign namespace, for use in copy constructor or + * deferred clone methods. + * + * proper the proper name of the attribute to clone + */ +#define IMPL_CLONE_FOREIGN_ATTRIB(proper) \ + set##proper(src.get##proper()); \ + if (src.m_##proper##Prefix) \ + m_##proper##Prefix = xercesc::XMLString::replicate(src.m_##proper##Prefix) + +/** + * Implements cloning of an integer child attribute, for use in copy constructor or + * deferred clone methods. + * + * proper the proper name of the attribute to clone + */ +#define IMPL_CLONE_INTEGER_ATTRIB(proper) \ + set##proper(src.m_##proper) + +/** + * Implements cloning of a boolean child attribute, for use in copy constructor or + * deferred clone methods. + * + * proper the proper name of the attribute to clone + */ +#define IMPL_CLONE_BOOLEAN_ATTRIB(proper) \ + proper(src.m_##proper) + +/** + * Implements cloning of a child object, for use in copy constructor or + * deferred clone methods. + * + * proper the proper name of the child object to clone + */ +#define IMPL_CLONE_XMLOBJECT_CHILD(proper) \ + if (src.get##proper()) \ + set##proper(src.get##proper()->clone()) + +/** + * Implements cloning of a typed child object, for use in copy constructor or + * deferred clone methods. + * + * proper the proper name of the child type to clone + */ +#define IMPL_CLONE_TYPED_CHILD(proper) \ + if (src.get##proper()) \ + set##proper(src.get##proper()->clone##proper()) + +/** + * Implements cloning of an untyped child collection, for use in copy constructor or + * deferred clone methods. + * + * proper the proper name of the child type to clone + */ +#define IMPL_CLONE_XMLOBJECT_CHILDREN(proper) \ + static void (VectorOf(XMLObject)::* XMLObject_push_back)(XMLObject* const&) = &VectorOf(XMLObject)::push_back; \ + VectorOf(XMLObject) c##proper = get##proper##s(); \ + std::for_each( \ + src.m_##proper##s.begin(), src.m_##proper##s.end(), \ + boost::lambda::if_(boost::lambda::_1 != ((XMLObject*)nullptr)) \ + [boost::lambda::bind(XMLObject_push_back, boost::ref(c##proper), boost::lambda::bind(&XMLObject::clone, boost::lambda::_1))] \ + ) + +/** + * Implements cloning of a child collection, for use in copy constructor or + * deferred clone methods. + * + * proper the proper name of the child type to clone + */ +#define IMPL_CLONE_TYPED_CHILDREN(proper) \ + static void (VectorOf(proper)::* proper##_push_back)(proper* const&) = &VectorOf(proper)::push_back; \ + VectorOf(proper) c##proper = get##proper##s(); \ + std::for_each( \ + src.m_##proper##s.begin(), src.m_##proper##s.end(), \ + boost::lambda::if_(boost::lambda::_1 != ((proper*)nullptr)) \ + [boost::lambda::bind(proper##_push_back, boost::ref(c##proper), boost::lambda::bind(&proper::clone##proper, boost::lambda::_1))] \ + ) + +/** + * Implements cloning of a child collection in a foreign namespace, for use in copy constructor or + * deferred clone methods. + * + * proper the proper name of the child type to clone + * ns the namespace of the child type + */ +#define IMPL_CLONE_TYPED_FOREIGN_CHILDREN(proper,ns) \ + static void (VectorOf(ns::proper)::* proper##_push_back)(ns::proper* const&) = &VectorOf(ns::proper)::push_back; \ + VectorOf(ns::proper) c##proper = get##proper##s(); \ + std::for_each( \ + src.m_##proper##s.begin(), src.m_##proper##s.end(), \ + boost::lambda::if_(boost::lambda::_1 != ((ns::proper*)nullptr)) \ + [boost::lambda::bind(proper##_push_back, boost::ref(c##proper), boost::lambda::bind(&ns::proper::clone##proper, boost::lambda::_1))] \ + ) + +/** + * Opens an iteration loop over all of the children of an object. + */ +#define IMPL_CLONE_CHILDBAG_BEGIN \ + for (list::const_iterator _bagit = src.m_children.begin(); _bagit != src.m_children.end(); ++_bagit) { + +/** + * Closes an iteration loop over all of the children of an object. + */ +#define IMPL_CLONE_CHILDBAG_END } + +/** + * Implements cloning of a typed child in a bag iteration loop based on a cast check. + * + * @param proper the proper name of the child type to clone + */ +#define IMPL_CLONE_TYPED_CHILD_IN_BAG(proper) \ + proper* _##proper##cast = dynamic_cast(*_bagit); \ + if (_##proper##cast) { \ + get##proper##s().push_back(_##proper##cast->clone##proper()); \ + continue; \ + } + +/** + * Implements cloning of a typed child in a forign namespace in a bag iteration loop based on a cast check. + * + * @param proper the proper name of the child type to clone + * @param ns the namespace of the child type + */ +#define IMPL_CLONE_TYPED_FOREIGN_CHILD_IN_BAG(proper,ns) \ + ns::proper* _##proper##cast = dynamic_cast(*_bagit); \ + if (_##proper##cast) { \ + get##proper##s().push_back(_##proper##cast->clone##proper()); \ + continue; \ + } + +/** + * Implements cloning of an XMLObject child in a bag iteration loop. + * + * @param proper the proper name of the child to clone + */ +#define IMPL_CLONE_XMLOBJECT_CHILD_IN_BAG(proper) \ + if (*_bagit) { \ + get##proper##s().push_back((*_bagit)->clone()); \ + } + +/** * Declares an XMLObject specialization with a simple content model and type, * handling it as string data. * @@ -1334,7 +1570,7 @@ } \ XMLTOOLING_DOXYGEN(Builder that allows element/type override.) \ virtual cname* buildObject( \ - const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix=NULL, const xmltooling::QName* schemaType=NULL \ + const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix=nullptr, const xmltooling::QName* schemaType=nullptr \ ) const /** @@ -1399,7 +1635,7 @@ } \ 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 XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix=nullptr, const xmltooling::QName* schemaType=nullptr \ ) const /** @@ -1561,11 +1797,11 @@ */ #define XMLOBJECTVALIDATOR_ONLYONEOF3(cname,proper1,proper2,proper3) \ int c##proper1##proper2##proper3=0; \ - if (ptr->get##proper1()!=NULL) \ + if (ptr->get##proper1()!=nullptr) \ c##proper1##proper2##proper3++; \ - if (ptr->get##proper2()!=NULL) \ + if (ptr->get##proper2()!=nullptr) \ c##proper1##proper2##proper3++; \ - if (ptr->get##proper3()!=NULL) \ + if (ptr->get##proper3()!=nullptr) \ c##proper1##proper2##proper3++; \ if (c##proper1##proper2##proper3 != 1) \ throw xmltooling::ValidationException(#cname" must have only one of "#proper1", "#proper2", or "#proper3".")