more hashtable apis

octa/array.h

@@ -39,6 +39,7 @@ struct Array {
     const T &back() const { return p_buf[(N > 0) ? (N - 1) : 0]; }
 
     Size size() const { return N; }
+    Size max_size() const { return Size(~0) / sizeof(T); }
 
     bool empty() const { return N == 0; }
 

octa/internal/hashtable.h

@@ -70,6 +70,10 @@ namespace detail {
             delete_chunks();
         }
 
+        bool empty() const { return p_len == 0; }
+        octa::Size size() const { return p_len; }
+        Size max_size() const { return Size(~0) / sizeof(E); }
+
         Chain *insert(octa::Size h) {
             if (!p_unused) {
                 Chunk *chunk = octa::allocator_allocate(get_challoc(), 1);
@@ -157,6 +161,13 @@ namespace detail {
             return (insert(h, key) = val);
         }
 
+        float load_factor() const {
+            return p_len / float(p_size);
+        }
+
+        octa::Size bucket_count() const { return p_size; }
+        octa::Size max_bucket_count() const { return Size(~0) / sizeof(Chain); }
+
         void swap(Hashtable &h) {
             octa::swap(p_size, h.p_size);
             octa::swap(p_len, h.p_len);

octa/map.h

@@ -61,10 +61,12 @@ public:
     Map(octa::Size size = 1 << 10, const H &hf = H(), const C &eqf = C(),
         const A &alloc = A()): p_table(size, hf, eqf, alloc) {}
 
-    bool empty() const { return p_table.p_len == 0; }
-    octa::Size size() const { return p_table.p_len; }
+    bool empty() const { return p_table.empty(); }
+    octa::Size size() const { return p_table.size(); }
+    octa::Size max_size() const { return p_table.max_size(); }
 
-    octa::Size bucket_count() const { return p_table.p_size; }
+    octa::Size bucket_count() const { return p_table.bucket_count(); }
+    octa::Size max_bucket_count() const { return p_table.max_bucket_count(); }
 
     void clear() { p_table.clear(); }
 
@@ -92,6 +94,13 @@ public:
         return p_table.insert(h, octa::move(key));
     }
 
+    octa::Size erase(const K &key) {
+        if (p_table.remove(key)) return 1;
+        return 0;
+    }
+
+    float load_factor() const { return p_table.load_factor(); }
+
     void swap(Map &v) {
         octa::swap(p_table, v.p_table);
     }

octa/vector.h

@@ -321,6 +321,8 @@ public:
     Size size() const { return p_len; }
     Size capacity() const { return p_cap; }
 
+    Size max_size() const { return Size(~0) / sizeof(T); }
+
     bool empty() const { return (p_len == 0); }
 
     bool in_range(Size idx) { return idx < p_len; }