Split out domptr stuff into its own .h file, so that it can be used by other things...

diff --git a/src/dom/dom.h b/src/dom/dom.h
index dd2c5f1b16fb8bc45ce90e6ed5884d9eac0c4c05..2e0473287fccd91c5ec7163e82ec926c89a8e357 100644 (file)
--- a/src/dom/dom.h
+++ b/src/dom/dom.h
@@ -46,6 +46,9 @@
 
 #include <vector>
 
+#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 T> class Ptr
-{
-public:
-
-    /**
-     * Simple constructor
-     */ 
-    Ptr()
-        { _ref = 0; }
-
-    /**
-     * Constructor upon a reference
-     */ 
-    template<class Y> Ptr(const Ptr<Y> &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<class Y> Ptr &operator=(const Ptr<Y> &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<class Y> Ptr &operator=(Y * ref)
-        {
-        decrementRefCount(_ref);
-        _ref = ref;
-        incrementRefCount(_ref);
-        return *this;
-        }
-
-    /**
-     * Assignment operator
-     */ 
-    template<class Y> 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<class T, class U> inline bool
-   operator==(const Ptr<T> &a, const Ptr<U> &b)
-{
-    return a.get() == b.get();
-}
-
-/**
- * Inequality
- */ 
-template<class T, class U> inline bool
-     operator!=(const Ptr<T> &a, const Ptr<U> &b)
-{
-    return a.get() != b.get();
-}
-
-/**
- * Equality
- */ 
-template<class T> inline bool
-     operator==(const Ptr<T> &a, T * b)
-{
-    return a.get() == b;
-}
-
-/**
- * Inequality
- */ 
-template<class T> inline bool
-     operator!=(const Ptr<T> &a, T * b)
-{
-    return a.get() != b;
-}
-
-/**
- * Equality
- */ 
-template<class T> inline bool
-     operator==(T * a, const Ptr<T> &b)
-{
-    return a == b.get();
-}
-
-/**
- * Inequality
- */ 
-template<class T> inline bool
-     operator!=(T * a, const Ptr<T> &b)
-{
-    return a != b.get();
-}
-
-
-/**
- * Less than
- */ 
-template<class T> inline bool
-     operator<(const Ptr<T> &a, const Ptr<T> &b)
-{
-    return std::less<T *>()(a.get(), b.get());
-}
-
-/**
- * Swap
- */ 
-template<class T> void
-     swap(Ptr<T> &a, Ptr<T> &b)
-{
-    a.swap(b);
-}
-
-
-/**
- * Get the pointer globally, for <algo>
- */ 
-template<class T> T * 
-    get_pointer(const Ptr<T> &p)
-{
-    return p.get();
-}
-
-/**
- * Static cast
- */ 
-template<class T, class U> Ptr<T>
-     static_pointer_cast(const Ptr<U> &p)
-{
-    return static_cast<T *>(p.get());
-}
-
-/**
- * Const cast
- */ 
-template<class T, class U> Ptr<T>
-     const_pointer_cast(const Ptr<U> &p)
-{
-    return const_cast<T *>(p.get());
-}
-
-/**
- * Dynamic cast
- */ 
-template<class T, class U> Ptr<T>
-     dynamic_pointer_cast(const Ptr<U> &p)
-{
-    return dynamic_cast<T *>(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 d325ae1ada3f3ac058176a654e9f0f3bff82610a..107f05b088ad1973888ee414c0ca4c9e52c1645c 100644 (file)
--- 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 (file)
index 0000000..bf54dea
--- /dev/null
+++ b/src/dom/domptr.h
@@ -0,0 +1,337 @@
+#ifndef __DOMPTR_H__\r
+#define __DOMPTR_H__\r
+/**\r
+ * Phoebe DOM Implementation.\r
+ *\r
+ * This is a C++ approximation of the W3C DOM model, which follows\r
+ * fairly closely the specifications in the various .idl files, copies of\r
+ * which are provided for reference.  Most important is this one:\r
+ *\r
+ * http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/idl-definitions.html\r
+ * \r
+ * More thorough explanations of the various classes and their algorithms\r
+ * can be found there.\r
+ *     \r
+ *\r
+ * Authors:\r
+ *   Bob Jamison\r
+ *\r
+ * Copyright (C) 2006-2008 Bob Jamison\r
+ *\r
+ *  This library is free software; you can redistribute it and/or\r
+ *  modify it under the terms of the GNU Lesser General Public\r
+ *  License as published by the Free Software Foundation; either\r
+ *  version 2.1 of the License, or (at your option) any later version.\r
+ *\r
+ *  This library is distributed in the hope that it will be useful,\r
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of\r
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\r
+ *  Lesser General Public License for more details.\r
+ *\r
+ *  You should have received a copy of the GNU Lesser General Public\r
+ *  License along with this library; if not, write to the Free Software\r
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA\r
+ *  \r
+ * =======================================================================\r
+ *  NOTES:\r
+ * \r
+ *  Notice that many of the classes defined here are pure virtual.  In other\r
+ *  words, they are purely unimplemented interfaces.  For the implementations\r
+ *  of them, look in domimpl.h and domimpl.cpp.\r
+ *  \r
+ *  Also, note that there is a domptr.cpp file that has a couple of necessary\r
+ *  functions which cannot be in a .h file\r
+ *             \r
+ */\r
+\r
+#include <functional>\r
+\r
+namespace org\r
+{\r
+namespace w3c\r
+{\r
+namespace dom\r
+{\r
+\r
+\r
+\r
+/*#########################################################################\r
+## NodePtr\r
+#########################################################################*/\r
+\r
+/**\r
+ * A simple Smart Pointer class that handles Nodes and all of its\r
+ * descendants.  This is very similar to shared_ptr, but it is customized\r
+ * to handle our needs. \r
+ */ \r
+template<class T> class Ptr\r
+{\r
+public:\r
+\r
+    /**\r
+     * Simple constructor\r
+     */ \r
+    Ptr()\r
+        { _ref = 0; }\r
+\r
+    /**\r
+     * Constructor upon a reference\r
+     */ \r
+    template<class Y> Ptr(const Ptr<Y> &other)\r
+        {\r
+        _ref = other._ref;\r
+           incrementRefCount(_ref);\r
+        }\r
+\r
+    /**\r
+     * Constructor upon a reference\r
+     */ \r
+    Ptr(T * refArg, bool addRef = true)\r
+        {\r
+        _ref = refArg;\r
+        if(addRef)\r
+                   incrementRefCount(_ref);\r
+        }\r
+\r
+\r
+    /**\r
+     * Copy constructor\r
+     */ \r
+    Ptr(const Ptr &other)\r
+        {\r
+        _ref = other._ref;\r
+           incrementRefCount(_ref);\r
+        }\r
+\r
+    /**\r
+     * Destructor\r
+     */ \r
+    virtual ~Ptr()\r
+    {\r
+        decrementRefCount(_ref);\r
+    }\r
+\r
+\r
+    /**\r
+     * Assignment operator\r
+     */ \r
+    template<class Y> Ptr &operator=(const Ptr<Y> &other)\r
+        {\r
+        decrementRefCount(_ref);\r
+        _ref = other._ref;\r
+        incrementRefCount(_ref);\r
+        return *this;\r
+        }\r
+\r
+    /**\r
+     * Assignment operator\r
+     */ \r
+    Ptr &operator=(const Ptr &other)\r
+        {\r
+        decrementRefCount(_ref);\r
+        _ref = other._ref;\r
+        incrementRefCount(_ref);\r
+        return *this;\r
+        }\r
+\r
+    /**\r
+     * Assignment operator\r
+     */ \r
+    template<class Y> Ptr &operator=(Y * ref)\r
+        {\r
+        decrementRefCount(_ref);\r
+        _ref = ref;\r
+        incrementRefCount(_ref);\r
+        return *this;\r
+        }\r
+\r
+    /**\r
+     * Assignment operator\r
+     */ \r
+    template<class Y> Ptr &operator=(const Y * ref)\r
+        {\r
+        decrementRefCount(_ref);\r
+        _ref = (Y *) ref;\r
+        incrementRefCount(_ref);\r
+        return *this;\r
+        }\r
+\r
+    /**\r
+     * Return the reference\r
+     */ \r
+    T * get() const\r
+        {\r
+        return _ref;\r
+        }\r
+\r
+    /**\r
+     * Dereference operator\r
+     */ \r
+    T &operator*() const\r
+        {\r
+        return *_ref;\r
+        }\r
+\r
+    /**\r
+     * Point-to operator\r
+     */ \r
+    T *operator->() const\r
+        {\r
+        return _ref;\r
+        }\r
+\r
+    /**\r
+     * NOT bool operator.  How to check if we are null without a comparison\r
+     */             \r
+    bool operator! () const\r
+        {\r
+        return (_ref == 0);\r
+        }\r
+\r
+    /**\r
+     * Swap what I reference with the other guy\r
+     */             \r
+    void swap(Ptr &other)\r
+        {\r
+        T *tmp = _ref;\r
+        _ref = other._ref;\r
+        other._ref = tmp;\r
+        }\r
+\r
+    //The referenced item\r
+    T *_ref;\r
+};\r
+\r
+\r
+/**\r
+ * Global definitions.  Many of these are used to mimic behaviour of\r
+ * a real pointer \r
+ */\r
+\r
+/**\r
+ * Equality\r
+ */ \r
+template<class T, class U> inline bool\r
+   operator==(const Ptr<T> &a, const Ptr<U> &b)\r
+{\r
+    return a.get() == b.get();\r
+}\r
+\r
+/**\r
+ * Inequality\r
+ */ \r
+template<class T, class U> inline bool\r
+     operator!=(const Ptr<T> &a, const Ptr<U> &b)\r
+{\r
+    return a.get() != b.get();\r
+}\r
+\r
+/**\r
+ * Equality\r
+ */ \r
+template<class T> inline bool\r
+     operator==(const Ptr<T> &a, T * b)\r
+{\r
+    return a.get() == b;\r
+}\r
+\r
+/**\r
+ * Inequality\r
+ */ \r
+template<class T> inline bool\r
+     operator!=(const Ptr<T> &a, T * b)\r
+{\r
+    return a.get() != b;\r
+}\r
+\r
+/**\r
+ * Equality\r
+ */ \r
+template<class T> inline bool\r
+     operator==(T * a, const Ptr<T> &b)\r
+{\r
+    return a == b.get();\r
+}\r
+\r
+/**\r
+ * Inequality\r
+ */ \r
+template<class T> inline bool\r
+     operator!=(T * a, const Ptr<T> &b)\r
+{\r
+    return a != b.get();\r
+}\r
+\r
+\r
+/**\r
+ * Less than\r
+ */ \r
+template<class T> inline bool\r
+     operator<(const Ptr<T> &a, const Ptr<T> &b)\r
+{\r
+    return std::less<T *>()(a.get(), b.get());\r
+}\r
+\r
+/**\r
+ * Swap\r
+ */ \r
+template<class T> void\r
+     swap(Ptr<T> &a, Ptr<T> &b)\r
+{\r
+    a.swap(b);\r
+}\r
+\r
+\r
+/**\r
+ * Get the pointer globally, for <algo>\r
+ */ \r
+template<class T> T * \r
+    get_pointer(const Ptr<T> &p)\r
+{\r
+    return p.get();\r
+}\r
+\r
+/**\r
+ * Static cast\r
+ */ \r
+template<class T, class U> Ptr<T>\r
+     static_pointer_cast(const Ptr<U> &p)\r
+{\r
+    return static_cast<T *>(p.get());\r
+}\r
+\r
+/**\r
+ * Const cast\r
+ */ \r
+template<class T, class U> Ptr<T>\r
+     const_pointer_cast(const Ptr<U> &p)\r
+{\r
+    return const_cast<T *>(p.get());\r
+}\r
+\r
+/**\r
+ * Dynamic cast\r
+ */ \r
+template<class T, class U> Ptr<T>\r
+     dynamic_pointer_cast(const Ptr<U> &p)\r
+{\r
+    return dynamic_cast<T *>(p.get());\r
+}\r
+\r
+\r
+\r
+}  //namespace dom\r
+}  //namespace w3c\r
+}  //namespace org\r
+\r
+\r
+#endif // __DOMPTR_H__\r
+\r
+\r
+/*#########################################################################\r
+## E N D    O F    F I L E\r
+#########################################################################*/\r
+\r
+\r
+\r
+\r