Changeset 86d1939 in mainline

Timestamp:

2018-07-05T21:41:21Z (7 years ago)

Author:

Dzejrou <dzejrou@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

c439e6a

Parents:

86b3ae98

git-author:

Dzejrou <dzejrou@…> (2018-04-24 21:12:53)

git-committer:

Dzejrou <dzejrou@…> (2018-07-05 21:41:21)

Message:

cpp: fixed compilation errors, added bodies of some functions

File:

• uspace/lib/cpp/include/impl/unordered_map.hpp (modified) (10 diffs)

uspace/lib/cpp/include/impl/unordered_map.hpp

@@ -31 +31 @@
 
 #include <initializer_list>
-#include <internal/hash_map.hpp>
+#include <internal/hash_table.hpp>
 #include <functional>
 #include <memory>
@@ -43 +43 @@
 
     template<
-        class Key, class Value
+        class Key, class Value,
         class Hash = hash<Key>,
         class Pred = equal_to<Key>,
@@ -81 +81 @@
             { /* DUMMY BODY */ }
 
-            explicit unordered_map(size_type bucket_count = default_bucket_count_,
+            explicit unordered_map(size_type bucket_count,
                                    const hasher& hf = hasher{},
                                    const key_equal& eql = key_equal{},
@@ -96 +96 @@
                 : unordered_map{bucket_count, hf, eql, alloc}
             {
-                // TODO: insert the range
+                insert(first, last);
             }
 
@@ -126 +126 @@
                 : unordered_map{bucket_count, hf, eql, alloc}
             {
-                // TODO: insert the range
+                insert(init.begin(), init.end());
             }
 
@@ -179 +179 @@
             unordered_map& operator=(initializer_list<value_type>& init)
             {
-                // TODO: implement
+                table_.clear();
+                table_.reserve(init.size());
+
+                insert(init.begin(), init.end());
+
                 return *this;
             }
@@ -338 +342 @@
             iterator erase(const_iterator position)
             {
-                // TODO: implement
+                return table_.erase(position);
             }
 
             size_type erase(const key_type& key)
             {
-                // TODO: implement
+                return table_.erase(key);
             }
 
             iterator erase(const_iterator first, const_iterator last)
             {
-                // TODO: implement
+                while (first != last)
+                    first = erase(first);
+
+                return iterator{
+                    table_.table(), first.idx(),
+                    table_.size(), table_.head(first.idx())
+                };
             }
 
@@ -377 +387 @@
             iterator find(const key_type& key)
             {
-                // TODO: implement
+                return table_.find(key);
             }
 
             const_iterator find(const key_type& key) const
             {
-                // TODO: implement
+                return table_.find(key);
             }
 
             size_type count(const key_type& key) const
             {
-                // TODO: implement
+                return table_.count(key);
             }
 
             pair<iterator, iterator> equal_range(const key_type& key)
             {
-                // TODO: implement
+                return table_.equal_range(key);
             }
 
             pair<const_iterator, const_iterator> equal_range(const key_type& key) const
             {
-                // TODO: implement
+                return table_.equal_range(key);
             }
 
             mapped_type& operator[](const key_type& key)
             {
-                // TODO: implement
+                auto spot = table_.find_insertion_spot(key);
+                auto bucket = get<0>(spot);
+
+                if (bucket->head)
+                {
+                    auto head = bucket->head;
+                    auto current = bucket->head;
+
+                    do
+                    {
+                        if (table_.keys_equal(key, current->value))
+                            return current->value.second;
+                        else
+                            current = current->next;
+                    }
+                    while (current != head);
+                }
+
+                bucket->append(new node_type{key, mapped_type{}});
+
+                return bucket->head->value.second;
             }
 
             mapped_type& operator[](key_type&& key)
             {
-                // TODO: implement
+                auto spot = table_.find_insertion_spot(key);
+                auto bucket = get<0>(spot);
+
+                if (bucket->head)
+                {
+                    auto head = bucket->head;
+                    auto current = bucket->head;
+
+                    do
+                    {
+                        if (table_.keys_equal(key, current->value))
+                            return current->value.second;
+                        else
+                            current = current->next;
+                    }
+                    while (current != head);
+                }
+
+                bucket->append(new node_type{move(key), mapped_type{}});
+
+                return bucket->head->value.second;
             }
 
@@ -496 +546 @@
 
         private:
-            aux::hash_map<
+            using table_type = aux::hash_table<
                 value_type, key_type, aux::key_value_key_extractor<key_type, mapped_type>,
                 hasher, key_equal, allocator_type, size_type,
                 iterator, const_iterator, local_iterator, const_local_iterator,
                 aux::hash_single_policy
-            > table_;
-
+            >;
+            using node_type = typename table_type::node_type;
+
+            table_type table_;
             allocator_type allocator_;
 
@@ -513 +565 @@
 
     template<
-        class Key, class Value
+        class Key, class Value,
         class Hash = hash<Key>,
         class Pred = equal_to<Key>,