--- /dev/null
+namespace stlplus\r
+{\r
+\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+ // body class implements the aliasing behaviour\r
+\r
+ template<typename O, typename N>\r
+ class safe_iterator_body\r
+ {\r
+ private:\r
+ const O* m_owner;\r
+ N* m_node;\r
+ unsigned m_count;\r
+\r
+ public:\r
+\r
+ safe_iterator_body(const O* owner, N* node) throw() : \r
+ m_owner(owner), m_node(node), m_count(1)\r
+ {\r
+// std::cerr << "constructing " \r
+// << std::hex << ((unsigned long)this) \r
+// << " => " << ((unsigned long)m_owner) << ":" << ((unsigned long)m_node)\r
+// << ":" << std::dec << m_count << std::endl;\r
+ }\r
+\r
+ ~safe_iterator_body(void) throw()\r
+ {\r
+// std::cerr << "destroying " \r
+// << std::hex << ((unsigned long)this) \r
+// << " => " << ((unsigned long)m_owner) << ":" << ((unsigned long)m_node)\r
+// << ":" << std::dec << m_count << std::endl;\r
+ m_owner = 0;\r
+ m_node = 0;\r
+ }\r
+\r
+ unsigned count(void) const\r
+ {\r
+ return m_count;\r
+ }\r
+\r
+ void increment(void)\r
+ {\r
+ ++m_count;\r
+// std::cerr << "incremented " \r
+// << std::hex << ((unsigned long)this) \r
+// << " => " << ((unsigned long)m_owner) << ":" << ((unsigned long)m_node)\r
+// << ":" << std::dec << m_count << std::endl;\r
+ }\r
+\r
+ bool decrement(void)\r
+ {\r
+ --m_count;\r
+// std::cerr << "decremented " \r
+// << std::hex << ((unsigned long)this) \r
+// << " => " << ((unsigned long)m_owner) << ":" << ((unsigned long)m_node)\r
+// << ":" << std::dec << m_count << std::endl;\r
+ return m_count == 0;\r
+ }\r
+\r
+ N* node(void) const throw()\r
+ {\r
+ return m_node;\r
+ }\r
+\r
+ const O* owner(void) const throw()\r
+ {\r
+ return m_owner;\r
+ }\r
+\r
+ void change_owner(const O* owner)\r
+ {\r
+ m_owner = owner;\r
+ }\r
+\r
+ bool equal(const safe_iterator_body<O,N>* right) const throw()\r
+ {\r
+// return m_node == right->m_node;\r
+ return compare(right) == 0;\r
+ }\r
+\r
+ int compare(const safe_iterator_body<O,N>* right) const throw()\r
+ {\r
+ return ((long)m_node) - ((long)right->m_node);\r
+ }\r
+\r
+ bool null(void) const throw()\r
+ {\r
+ return m_owner == 0;\r
+ }\r
+\r
+ bool end(void) const throw()\r
+ {\r
+ return m_owner != 0 && m_node == 0;\r
+ }\r
+\r
+ bool valid(void) const throw()\r
+ {\r
+ return m_owner != 0 && m_node != 0;\r
+ }\r
+\r
+ void set_end(void) throw()\r
+ {\r
+ m_node = 0;\r
+ }\r
+\r
+ void set_null(void) throw()\r
+ {\r
+ m_owner = 0;\r
+ m_node = 0;\r
+ }\r
+\r
+ void assert_valid(void) const throw(null_dereference,end_dereference)\r
+ {\r
+ if (null())\r
+ throw null_dereference("stlplus::safe_iterator");\r
+ if (end())\r
+ throw end_dereference("stlplus::safe_iterator");\r
+ }\r
+\r
+ void assert_non_null(void) const throw(null_dereference)\r
+ {\r
+ if (null())\r
+ throw null_dereference("stlplus::safe_iterator");\r
+ }\r
+\r
+ void assert_owner(const O* owner) const throw(wrong_object)\r
+ {\r
+ if (owner != m_owner)\r
+ throw wrong_object("stlplus::safe_iterator");\r
+ }\r
+ };\r
+\r
+\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+ // Master Iterator\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+\r
+ // construct a valid iterator\r
+ template<typename O, typename N>\r
+ master_iterator<O,N>::master_iterator(const O* owner, N* node) throw() :\r
+ m_body(new safe_iterator_body<O,N>(owner,node))\r
+ {\r
+ }\r
+\r
+ // destructor - disconnect all iterators from the node\r
+ // this usually happens when the node is deleted and must invalidate all aliases\r
+ template<typename O, typename N>\r
+ master_iterator<O,N>::~master_iterator(void) throw()\r
+ {\r
+ m_body->set_end();\r
+ if(m_body->decrement())\r
+ {\r
+ delete m_body;\r
+ m_body = 0;\r
+ }\r
+ }\r
+\r
+ // dereference\r
+ template<typename O, typename N>\r
+ N* master_iterator<O,N>::node(void) const throw()\r
+ {\r
+ return m_body->node();\r
+ }\r
+\r
+ template<typename O, typename N>\r
+ const O* master_iterator<O,N>::owner(void) const throw()\r
+ {\r
+ return m_body->owner();\r
+ }\r
+\r
+ // when you move a node from one owner to another, call this on the node's iterator\r
+ // this effectively moves all iterators to the node so that they are owned by the new owner too\r
+ template<typename O, typename N>\r
+ void master_iterator<O,N>::change_owner(const O* owner) throw()\r
+ {\r
+ m_body->change_owner(owner);\r
+ }\r
+\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+ // Safe Iterator\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+\r
+ // construct a null iterator\r
+ // later assignment of a valid iterator to this is done by using step\r
+ template<typename O, typename N>\r
+ safe_iterator<O,N>::safe_iterator(void) throw() : \r
+ m_body(new safe_iterator_body<O,N>(0,0))\r
+ {\r
+ }\r
+\r
+ // construct a valid iterator by aliasing from the owner node's master iterator\r
+ template<typename O, typename N>\r
+ safe_iterator<O,N>::safe_iterator(const master_iterator<O,N>& r) throw() :\r
+ m_body(0)\r
+ {\r
+ m_body = r.m_body;\r
+ m_body->increment();\r
+ }\r
+\r
+ // construct a valid iterator by aliasing from the owner node's master iterator\r
+ template<typename O, typename N>\r
+ safe_iterator<O,N>::safe_iterator(const safe_iterator<O,N>& r) throw() :\r
+ m_body(0)\r
+ {\r
+ m_body = r.m_body;\r
+ m_body->increment();\r
+ }\r
+\r
+ // assignment implements dealiasing followed by aliasing\r
+ template<typename O, typename N>\r
+ safe_iterator<O,N>& safe_iterator<O,N>::operator=(const safe_iterator<O,N>& r) throw()\r
+ {\r
+ if (m_body != r.m_body)\r
+ {\r
+ if (m_body->decrement())\r
+ delete m_body;\r
+ m_body = r.m_body;\r
+ m_body->increment();\r
+ }\r
+ return *this;\r
+ }\r
+\r
+ // destructor - implements dealiasing\r
+ template<typename O, typename N>\r
+ safe_iterator<O,N>::~safe_iterator(void) throw()\r
+ {\r
+ if(m_body->decrement())\r
+ {\r
+ delete m_body;\r
+ m_body = 0;\r
+ }\r
+ }\r
+\r
+\r
+ // increment/decrement operation\r
+ // implements dealiasing followed by aliasing\r
+ template<typename O, typename N>\r
+ void safe_iterator<O,N>::set(const master_iterator<O,N>& r) throw()\r
+ {\r
+ if (m_body != r.m_body)\r
+ {\r
+ if (m_body->decrement())\r
+ delete m_body;\r
+ m_body = r.m_body;\r
+ m_body->increment();\r
+ }\r
+ }\r
+\r
+ // dereference\r
+ template<typename O, typename N>\r
+ N* safe_iterator<O,N>::node(void) const throw()\r
+ {\r
+ return m_body->node();\r
+ }\r
+\r
+ template<typename O, typename N>\r
+ const O* safe_iterator<O,N>::owner(void) const throw()\r
+ {\r
+ return m_body->owner();\r
+ }\r
+\r
+ // change to a null iterator - i.e. one that doees not belong to any object\r
+ // this does not affect any other iterators pointing to the same node\r
+ template<typename O, typename N>\r
+ void safe_iterator<O,N>::set_null(void) throw()\r
+ {\r
+ if (m_body->count() == 1)\r
+ {\r
+ // no aliases, so just make this null\r
+ m_body->set_null();\r
+ }\r
+ else\r
+ {\r
+ // create a new body which is null so as not to affect any other aliases\r
+ m_body->decrement();\r
+ m_body = new safe_iterator_body<O,N>(0,0);\r
+ }\r
+ }\r
+\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+ // operations for clients that do not have a master end iterator\r
+ // alternatively, have a master end iterator as part of the container\r
+ // and call constructor(master_end) or step(master_end)\r
+\r
+ // construct an end iterator\r
+ template<typename O, typename N>\r
+ safe_iterator<O,N>::safe_iterator(const O* owner) throw() :\r
+ m_body(new safe_iterator_body<O,N>(owner,0))\r
+ {\r
+ }\r
+\r
+ // change to an end iterator - e.g. as a result of incrementing off the end\r
+ template<typename O, typename N>\r
+ void safe_iterator<O,N>::set_end(void) throw()\r
+ {\r
+ if (m_body->count() == 1)\r
+ {\r
+ // no aliases, so just make this an end iterator\r
+ m_body->set_end();\r
+ }\r
+ else\r
+ {\r
+ // create a new body which is null so as not to affect any other aliases\r
+ m_body->decrement();\r
+ m_body = new safe_iterator_body<O,N>(owner(),0);\r
+ }\r
+ }\r
+\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+ // tests\r
+\r
+ // comparison\r
+ template<typename O, typename N>\r
+ bool safe_iterator<O,N>::equal(const safe_iterator<O,N>& right) const throw()\r
+ {\r
+ return compare(right) == 0;\r
+ }\r
+\r
+ template<typename O, typename N>\r
+ int safe_iterator<O,N>::compare(const safe_iterator<O,N>& right) const throw()\r
+ {\r
+ if (m_body == right.m_body) return 0;\r
+ return m_body->compare(right.m_body);\r
+ }\r
+\r
+ // a null iterator is one that has not been initialised with a value yet\r
+ template<typename O, typename N>\r
+ bool safe_iterator<O,N>::null(void) const throw()\r
+ {\r
+ return m_body->null();\r
+ }\r
+\r
+ // an end iterator is one that points to the end element of the list of nodes\r
+ template<typename O, typename N>\r
+ bool safe_iterator<O,N>::end(void) const throw()\r
+ {\r
+ return m_body->end();\r
+ }\r
+\r
+ // a valid iterator is one that can be dereferenced\r
+ template<typename O, typename N>\r
+ bool safe_iterator<O,N>::valid(void) const throw()\r
+ {\r
+ return m_body->valid();\r
+ }\r
+\r
+ // check the rules for a valid iterator that can be dereferenced\r
+ template<typename O, typename N>\r
+ void safe_iterator<O,N>::assert_valid(void) const throw(null_dereference,end_dereference)\r
+ {\r
+ m_body->assert_valid();\r
+ }\r
+\r
+ template<typename O, typename N>\r
+ void safe_iterator<O,N>::assert_valid(const O* owner) const throw(wrong_object,null_dereference,end_dereference)\r
+ {\r
+ m_body->assert_valid();\r
+ m_body->assert_owner(owner);\r
+ }\r
+\r
+ template<typename O, typename N>\r
+ void safe_iterator<O,N>::assert_non_null(void) const throw(null_dereference)\r
+ {\r
+ m_body->assert_non_null();\r
+ }\r
+\r
+ template<typename O, typename N>\r
+ void safe_iterator<O,N>::assert_owner(const O* owner) const throw(wrong_object)\r
+ {\r
+ m_body->assert_owner(owner);\r
+ }\r
+\r
+} // end namespace stlplus\r
projects / chaz / yoink / blobdiff