add for hashtree

Author: jingkaimori

Kernel/Containers/hashtree.hpp

@@ -15,12 +15,13 @@
 #define HASHTREE_H
 
 #include "hashmap.hpp"
+#include "sharedptr.hpp"
 
 template <class K, class V> class hashtree;
 template <class K, class V> int  N (hashtree<K, V> tree);
 template <class K, class V> bool is_nil (hashtree<K, V> tree);
 
-template <class K, class V> class hashtree_rep : concrete_struct {
+template <class K, class V> class hashtree_rep {
   hashmap<K, hashtree<K, V>> children;
 
 public:
@@ -75,38 +76,26 @@ template <class K, class V> class hashtree_rep : concrete_struct {
  * of NULL pointers so to speak). These NULL nodes are created by passing
  * a boolean value to the hashtree constructor. One cannot accidentally
  * obtain a NULL element by e.g. accessing a child (see below).
- *
- * In general, I tried to imitate the TeXmacs-way of memory management
- * as closely as possibly, however the workaround is not that pretty.
- * As more elegant way might be to modify the hashmap class so that
- * a hashmap contains only a pointer to a function that returns
- * a default value instead of a instance of a value-element.
- * But I didn't want to modify core TeXmacs code.
  ******************************************************************************/
 
-template <class K, class V> class hashtree {
-  // CONCRETE_TEMPLATE_2(hashtree,K,V);
-  hashtree_rep<K, V>* rep;
+template <class K, class V>
+class hashtree : public counted_ptr<hashtree_rep<K, V>, true> {
 
   // this constructor always returns a NULL element
-  inline hashtree (bool) : rep (NULL) {}
+  inline hashtree (bool) : base () {}
 
   // ensures that this hashtree has a rep
   void realize ();
 
 public:
-  inline hashtree (const hashtree<K, V>&);
-  inline ~hashtree ();
-  inline hashtree<K, V>& operator= (hashtree<K, V> x);
-
   // default constructor returns a non-NULL node, which does not have a value
-  inline hashtree () : rep (tm_new<hashtree_rep<K, V>> ()) {}
+  inline hashtree () : base (make ()) {}
 
   // returns a non-NULL node, that has value
-  inline hashtree (V val) : rep (tm_new<hashtree_rep<K, V>> (val)) {}
+  inline hashtree (V val) : base (make (val)) {}
 
   // returns this node's value
-  inline hashtree_rep<K, V>* operator->(void);
+  inline hashtree_rep<K, V>* operator->();
 
   // returns this node's child with the label "key". If the node doesn't
   // have such a child, an error is raised.
@@ -120,8 +109,7 @@ template <class K, class V> class hashtree {
   inline hashtree<K, V> operator[] (K key); // rw access
 
   friend class hashtree_rep<K, V>;
-  friend bool is_nil<K, V> (hashtree<K, V> ht);
-  friend int  N<K, V> (hashtree<K, V> ht);
+  friend int N<K, V> (hashtree<K, V> ht);
 };
 
 #include "hashtree.ipp"

Kernel/Containers/hashtree.ipp

@@ -15,33 +15,6 @@
 #define HASHTREE_C
 #include "hashtree.hpp"
 
-/******************************************************************************
- * Methods normally provided by
- * CONCRETE_TEMPLATE_2_CODE(hashtree,class,K,class,V);
- ******************************************************************************/
-
-template <class K, class V>
-inline hashtree<K, V>::hashtree (const hashtree<K, V>& x) : rep (x.rep) {
-  if (this->rep != NULL) INC_COUNT (this->rep);
-}
-
-template <class K, class V> inline hashtree<K, V>::~hashtree () {
-  if (this->rep != NULL) DEC_COUNT (this->rep);
-}
-
-template <class K, class V>
-inline hashtree<K, V>&
-hashtree<K, V>::operator= (hashtree<K, V> x) {
-  if (this->rep != NULL) DEC_COUNT (this->rep);
-  this->rep= x.rep;
-  if (x.rep != NULL) INC_COUNT (x.rep);
-  return *this;
-}
-
-/******************************************************************************
- * Methods of hashtree_rep<K,V>
- ******************************************************************************/
-
 template <class K, class V>
 inline bool
 hashtree_rep<K, V>::contains (K key) {
@@ -81,9 +54,8 @@ hashtree_rep<K, V>::get_label () {
 template <class K, class V>
 inline void
 hashtree<K, V>::realize () {
-  if (rep == NULL) {
-    rep= tm_new<hashtree_rep<K, V>> ();
-    INC_COUNT (rep);
+  if (this->is_nil ()) {
+    *this= hashtree ();
   }
 }
 
@@ -121,7 +93,7 @@ hashtree<K, V>::operator() (K key) {
 template <class K, class V>
 inline bool
 is_nil (hashtree<K, V> ht) {
-  return ht.rep == NULL;
+  return ht.is_nil ();
 }
 
 template <class K, class V>