Fix yet another dependent base C++ language issue.

[cln.git] / src / base / hash / cl_hash1weak.h

diff --git a/src/base/hash/cl_hash1weak.h b/src/base/hash/cl_hash1weak.h
index 0719ec48dc3cfa3c9145ec7c2690d76853cdc8c4..a8b835a3b87be4c4b365349c0ae6fdc028e5a5ea 100644 (file)
--- a/src/base/hash/cl_hash1weak.h
+++ b/src/base/hash/cl_hash1weak.h
@@ -3,7 +3,9 @@
 #ifndef _CL_HASH1WEAK_H
 #define _CL_HASH1WEAK_H
 
-#include "cl_hash1.h"
+#include "base/hash/cl_hash1.h"
+
+namespace cln {
 
 // This is a hash table in which an entry can be removed when a user-defined
 // condition is fulfilled (e.g. the value is not referenced any more).
@@ -20,31 +22,31 @@
 template <class key1_type, class value_type>
 struct cl_heap_weak_hashtable_1 : public cl_heap_hashtable_1 <key1_type,value_type> {
        // Allocation.
-       void* operator new (size_t size) { return cl_malloc_hook(size); }
+       void* operator new (size_t size) { return malloc_hook(size); }
        // Deallocation.
-       void operator delete (void* ptr) { cl_free_hook(ptr); }
+       void operator delete (void* ptr) { free_hook(ptr); }
 public:
        // Function which tells when an unused entry may be garbage collected.
-       cl_boolean (* const _maygc_htentry) (const cl_htentry1<key1_type,value_type>&);
+       bool (* const _maygc_htentry) (const cl_htentry1<key1_type,value_type>&);
        // Constructor.
-       cl_heap_weak_hashtable_1 (cl_boolean (*maygc_htentry) (const cl_htentry1<key1_type,value_type>&))
+       cl_heap_weak_hashtable_1 (bool (*maygc_htentry) (const cl_htentry1<key1_type,value_type>&))
                : cl_heap_hashtable_1 <key1_type,value_type> (),
                  _maygc_htentry (maygc_htentry)
        {
-               _garcol_fun = garcol;
+               this->_garcol_fun = cl_heap_weak_hashtable_1<key1_type,value_type>::garcol;
        }
 private:
        // Garbage collection.
        // Before growing the table, we check whether we can remove unused
        // entries.
-       static cl_boolean garcol (cl_heap* _ht)
+       static bool garcol (cl_heap* _ht)
        {
                var cl_heap_weak_hashtable_1* ht = (cl_heap_weak_hashtable_1*)_ht;
                // Now ht->_garcol_fun = garcol.
                // It is not worth doing a garbage collection if the table
                // is small, say, has fewer than 100 entries.
                if (ht->_count < 100)
-                       return cl_false;
+                       return false;
                // Do a garbage collection.
                var long removed = 0;
                for (long i = 0; i < ht->_size; i++)
@@ -61,7 +63,7 @@ private:
                                ht->remove(entry.key);
                                if (entry.val.pointer_p()) {
                                        var cl_heap* p = entry.val.heappointer;
-                                       if (!(--p->refcount == 0)) cl_abort();
+                                       if (!(--p->refcount == 0)) throw runtime_exception();
                                        cl_free_heap_object(p);
                                }
                                removed++;
@@ -69,25 +71,27 @@ private:
                    }
                if (removed == 0)
                        // Unsuccessful. Let the table grow immediately.
-                       return cl_false;
+                       return false;
                else if (2*removed < ht->_count) {
                        // Table shrank by less than a factor of 1/1.5.
                        // Don't expand the table now, but expand it next time.
-                       ht->_garcol_fun = garcol_nexttime;
-                       return cl_true;
+                       ht->_garcol_fun = cl_heap_weak_hashtable_1<key1_type,value_type>::garcol_nexttime;
+                       return true;
                } else {
                        // Table shrank much. Don't expand the table now,
                        // and try a GC next time.
-                       return cl_true;
+                       return true;
                }
        }
-       static cl_boolean garcol_nexttime (cl_heap* _ht)
+       static bool garcol_nexttime (cl_heap* _ht)
        {
                var cl_heap_weak_hashtable_1* ht = (cl_heap_weak_hashtable_1*)_ht;
                // Now ht->_garcol_fun = garcol_nexttime.
-               ht->_garcol_fun = garcol;
-               return cl_false;
+               ht->_garcol_fun = cl_heap_weak_hashtable_1<key1_type,value_type>::garcol;
+               return false;
        }
 };
 
+}  // namespace cln
+
 #endif /* _CL_HASH1WEAK_H */