![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
diff --git a/src/dom/domptr.h b/src/dom/domptr.h
index bf54deaa2925d6b31554527aa93ad174c625fb23..aaf1220f3ed19be38b2ea5d1a0bd2db57907c557 100644 (file)
--- a/src/dom/domptr.h
+++ b/src/dom/domptr.h
-#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
+#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 <functional>
+
+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 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());
+}
+
+
+
+} //namespace dom
+} //namespace w3c
+} //namespace org
+
+
+#endif // __DOMPTR_H__
+
+
+/*#########################################################################
+## E N D O F F I L E
+#########################################################################*/
+
+
+
+