From 43681cdf579847308fcba92f8db11e576405f540 Mon Sep 17 00:00:00 2001 From: ishmal Date: Wed, 23 Apr 2008 17:56:40 +0000 Subject: [PATCH] Split out domptr stuff into its own .h file, so that it can be used by other things. This might lead to a GP smart pointer to use for binding with scripts. --- src/dom/dom.h | 347 ++++++--------------------------------------- src/dom/domptr.cpp | 3 +- src/dom/domptr.h | 337 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 386 insertions(+), 301 deletions(-) create mode 100644 src/dom/domptr.h diff --git a/src/dom/dom.h b/src/dom/dom.h index dd2c5f1b1..2e0473287 100644 --- a/src/dom/dom.h +++ b/src/dom/dom.h @@ -46,6 +46,9 @@ #include +#include "domptr.h" + + /** * What type of string do we want? Pick one of the following * Then below, select one of the corresponding typedefs. @@ -91,269 +94,6 @@ typedef unsigned long long DOMTimeStamp; typedef void DOMUserData; -/*######################################################################### -## NodePtr -#########################################################################*/ - -/** - * A simple Smart Pointer class that handles Nodes and all of its - * descendants. This is very similar to shared_ptr, but it is customized - * to handle our needs. - */ -template class Ptr -{ -public: - - /** - * Simple constructor - */ - Ptr() - { _ref = 0; } - - /** - * Constructor upon a reference - */ - template Ptr(const Ptr &other) - { - _ref = other._ref; - incrementRefCount(_ref); - } - - /** - * Constructor upon a reference - */ - Ptr(T * refArg, bool addRef = true) - { - _ref = refArg; - if(addRef) - incrementRefCount(_ref); - } - - - /** - * Copy constructor - */ - Ptr(const Ptr &other) - { - _ref = other._ref; - incrementRefCount(_ref); - } - - /** - * Destructor - */ - virtual ~Ptr() - { - decrementRefCount(_ref); - } - - - /** - * Assignment operator - */ - template Ptr &operator=(const Ptr &other) - { - decrementRefCount(_ref); - _ref = other._ref; - incrementRefCount(_ref); - return *this; - } - - /** - * Assignment operator - */ - Ptr &operator=(const Ptr &other) - { - decrementRefCount(_ref); - _ref = other._ref; - incrementRefCount(_ref); - return *this; - } - - /** - * Assignment operator - */ - template Ptr &operator=(Y * ref) - { - decrementRefCount(_ref); - _ref = ref; - incrementRefCount(_ref); - return *this; - } - - /** - * Assignment operator - */ - template Ptr &operator=(const Y * ref) - { - decrementRefCount(_ref); - _ref = (Y *) ref; - incrementRefCount(_ref); - return *this; - } - - /** - * Return the reference - */ - T * get() const - { - return _ref; - } - - /** - * Dereference operator - */ - T &operator*() const - { - return *_ref; - } - - /** - * Point-to operator - */ - T *operator->() const - { - return _ref; - } - - /** - * NOT bool operator. How to check if we are null without a comparison - */ - bool operator! () const - { - return (_ref == 0); - } - - /** - * Swap what I reference with the other guy - */ - void swap(Ptr &other) - { - T *tmp = _ref; - _ref = other._ref; - other._ref = tmp; - } - - //The referenced item - T *_ref; -}; - - -/** - * Global definitions. Many of these are used to mimic behaviour of - * a real pointer - */ - -/** - * Equality - */ -template inline bool - operator==(const Ptr &a, const Ptr &b) -{ - return a.get() == b.get(); -} - -/** - * Inequality - */ -template inline bool - operator!=(const Ptr &a, const Ptr &b) -{ - return a.get() != b.get(); -} - -/** - * Equality - */ -template inline bool - operator==(const Ptr &a, T * b) -{ - return a.get() == b; -} - -/** - * Inequality - */ -template inline bool - operator!=(const Ptr &a, T * b) -{ - return a.get() != b; -} - -/** - * Equality - */ -template inline bool - operator==(T * a, const Ptr &b) -{ - return a == b.get(); -} - -/** - * Inequality - */ -template inline bool - operator!=(T * a, const Ptr &b) -{ - return a != b.get(); -} - - -/** - * Less than - */ -template inline bool - operator<(const Ptr &a, const Ptr &b) -{ - return std::less()(a.get(), b.get()); -} - -/** - * Swap - */ -template void - swap(Ptr &a, Ptr &b) -{ - a.swap(b); -} - - -/** - * Get the pointer globally, for - */ -template T * - get_pointer(const Ptr &p) -{ - return p.get(); -} - -/** - * Static cast - */ -template Ptr - static_pointer_cast(const Ptr &p) -{ - return static_cast(p.get()); -} - -/** - * Const cast - */ -template Ptr - const_pointer_cast(const Ptr &p) -{ - return const_cast(p.get()); -} - -/** - * Dynamic cast - */ -template Ptr - dynamic_pointer_cast(const Ptr &p) -{ - return dynamic_cast(p.get()); -} - /** * This is used for opaque references to arbitrary objects from @@ -1248,7 +988,7 @@ public: } /** - * + * Get the number of nodes in this list */ virtual unsigned long getLength() { @@ -1321,49 +1061,56 @@ protected: ## NamedNodeMap #########################################################################*/ -class NamedNodeMapEntry -{ -public: - NamedNodeMapEntry(const DOMString &theNamespaceURI, - const DOMString &theName, - const NodePtr theNode) - { - namespaceURI = theNamespaceURI; - name = theName; - node = theNode; - } - NamedNodeMapEntry(const NamedNodeMapEntry &other) - { - assign(other); - } - NamedNodeMapEntry &operator=(const NamedNodeMapEntry &other) - { - assign(other); - return *this; - } - virtual ~NamedNodeMapEntry() - { - } - void assign(const NamedNodeMapEntry &other) - { - namespaceURI = other.namespaceURI; - name = other.name; - node = other.node; - } - DOMString namespaceURI; - DOMString name; - NodePtr node; -}; - /** - * + * Contains a mapping from name->NodePtr. Used for various purposes. For + * example, a list of Attributes is a NamedNodeMap. */ class NamedNodeMap { +private: + + /** + * table entry. Not an API item + */ + class NamedNodeMapEntry + { + public: + NamedNodeMapEntry(const DOMString &theNamespaceURI, + const DOMString &theName, + const NodePtr theNode) + { + namespaceURI = theNamespaceURI; + name = theName; + node = theNode; + } + NamedNodeMapEntry(const NamedNodeMapEntry &other) + { + assign(other); + } + NamedNodeMapEntry &operator=(const NamedNodeMapEntry &other) + { + assign(other); + return *this; + } + virtual ~NamedNodeMapEntry() + { + } + void assign(const NamedNodeMapEntry &other) + { + namespaceURI = other.namespaceURI; + name = other.name; + node = other.node; + } + DOMString namespaceURI; + DOMString name; + NodePtr node; + }; + + public: /** - * + * Return the named node. Return nullptr if not found. */ virtual NodePtr getNamedItem(const DOMString& name) { diff --git a/src/dom/domptr.cpp b/src/dom/domptr.cpp index d325ae1ad..107f05b08 100644 --- a/src/dom/domptr.cpp +++ b/src/dom/domptr.cpp @@ -10,7 +10,7 @@ * Authors: * Bob Jamison * - * Copyright (C) 2006 Bob Jamison + * Copyright (C) 2006-2008 Bob Jamison * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -28,6 +28,7 @@ */ #include "dom.h" +#include "domptr.h" namespace org diff --git a/src/dom/domptr.h b/src/dom/domptr.h new file mode 100644 index 000000000..bf54deaa2 --- /dev/null +++ b/src/dom/domptr.h @@ -0,0 +1,337 @@ +#ifndef __DOMPTR_H__ +#define __DOMPTR_H__ +/** + * Phoebe DOM Implementation. + * + * This is a C++ approximation of the W3C DOM model, which follows + * fairly closely the specifications in the various .idl files, copies of + * which are provided for reference. Most important is this one: + * + * http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/idl-definitions.html + * + * More thorough explanations of the various classes and their algorithms + * can be found there. + * + * + * Authors: + * Bob Jamison + * + * Copyright (C) 2006-2008 Bob Jamison + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + * ======================================================================= + * NOTES: + * + * Notice that many of the classes defined here are pure virtual. In other + * words, they are purely unimplemented interfaces. For the implementations + * of them, look in domimpl.h and domimpl.cpp. + * + * Also, note that there is a domptr.cpp file that has a couple of necessary + * functions which cannot be in a .h file + * + */ + +#include + +namespace org +{ +namespace w3c +{ +namespace dom +{ + + + +/*######################################################################### +## NodePtr +#########################################################################*/ + +/** + * A simple Smart Pointer class that handles Nodes and all of its + * descendants. This is very similar to shared_ptr, but it is customized + * to handle our needs. + */ +template class Ptr +{ +public: + + /** + * Simple constructor + */ + Ptr() + { _ref = 0; } + + /** + * Constructor upon a reference + */ + template Ptr(const Ptr &other) + { + _ref = other._ref; + incrementRefCount(_ref); + } + + /** + * Constructor upon a reference + */ + Ptr(T * refArg, bool addRef = true) + { + _ref = refArg; + if(addRef) + incrementRefCount(_ref); + } + + + /** + * Copy constructor + */ + Ptr(const Ptr &other) + { + _ref = other._ref; + incrementRefCount(_ref); + } + + /** + * Destructor + */ + virtual ~Ptr() + { + decrementRefCount(_ref); + } + + + /** + * Assignment operator + */ + template Ptr &operator=(const Ptr &other) + { + decrementRefCount(_ref); + _ref = other._ref; + incrementRefCount(_ref); + return *this; + } + + /** + * Assignment operator + */ + Ptr &operator=(const Ptr &other) + { + decrementRefCount(_ref); + _ref = other._ref; + incrementRefCount(_ref); + return *this; + } + + /** + * Assignment operator + */ + template Ptr &operator=(Y * ref) + { + decrementRefCount(_ref); + _ref = ref; + incrementRefCount(_ref); + return *this; + } + + /** + * Assignment operator + */ + template Ptr &operator=(const Y * ref) + { + decrementRefCount(_ref); + _ref = (Y *) ref; + incrementRefCount(_ref); + return *this; + } + + /** + * Return the reference + */ + T * get() const + { + return _ref; + } + + /** + * Dereference operator + */ + T &operator*() const + { + return *_ref; + } + + /** + * Point-to operator + */ + T *operator->() const + { + return _ref; + } + + /** + * NOT bool operator. How to check if we are null without a comparison + */ + bool operator! () const + { + return (_ref == 0); + } + + /** + * Swap what I reference with the other guy + */ + void swap(Ptr &other) + { + T *tmp = _ref; + _ref = other._ref; + other._ref = tmp; + } + + //The referenced item + T *_ref; +}; + + +/** + * Global definitions. Many of these are used to mimic behaviour of + * a real pointer + */ + +/** + * Equality + */ +template inline bool + operator==(const Ptr &a, const Ptr &b) +{ + return a.get() == b.get(); +} + +/** + * Inequality + */ +template inline bool + operator!=(const Ptr &a, const Ptr &b) +{ + return a.get() != b.get(); +} + +/** + * Equality + */ +template inline bool + operator==(const Ptr &a, T * b) +{ + return a.get() == b; +} + +/** + * Inequality + */ +template inline bool + operator!=(const Ptr &a, T * b) +{ + return a.get() != b; +} + +/** + * Equality + */ +template inline bool + operator==(T * a, const Ptr &b) +{ + return a == b.get(); +} + +/** + * Inequality + */ +template inline bool + operator!=(T * a, const Ptr &b) +{ + return a != b.get(); +} + + +/** + * Less than + */ +template inline bool + operator<(const Ptr &a, const Ptr &b) +{ + return std::less()(a.get(), b.get()); +} + +/** + * Swap + */ +template void + swap(Ptr &a, Ptr &b) +{ + a.swap(b); +} + + +/** + * Get the pointer globally, for + */ +template T * + get_pointer(const Ptr &p) +{ + return p.get(); +} + +/** + * Static cast + */ +template Ptr + static_pointer_cast(const Ptr &p) +{ + return static_cast(p.get()); +} + +/** + * Const cast + */ +template Ptr + const_pointer_cast(const Ptr &p) +{ + return const_cast(p.get()); +} + +/** + * Dynamic cast + */ +template Ptr + dynamic_pointer_cast(const Ptr &p) +{ + return dynamic_cast(p.get()); +} + + + +} //namespace dom +} //namespace w3c +} //namespace org + + +#endif // __DOMPTR_H__ + + +/*######################################################################### +## E N D O F F I L E +#########################################################################*/ + + + + -- 2.30.2