Issue 6279 - Make HashContainer movable and optimize resizing by moving entries.

compiled/Map.h

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-present eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 89 matching lines @@
   template<typename Entry>
   class HashContainer
   {
   public:
     typedef Entry entry_type;
     typedef typename Entry::key_type_cref key_type_cref;
     typedef typename entry_type::size_type size_type;
     typedef HashContainerIterator<Entry> const_iterator;
     typedef HashContainerReference<const Entry> const_reference;
 
-  private:
-    explicit HashContainer(const HashContainer& other);
-    void operator=(const HashContainer& other);
+    explicit HashContainer(HashContainer&& other) = default;
+    HashContainer& operator=(HashContainer&&) = default;
+
+    explicit HashContainer(const HashContainer& other) = delete;
+    void operator=(const HashContainer& other) = delete;
 
   protected:
     static constexpr size_type MIN_BUCKETS = 1;
     static constexpr double LOAD_FACTOR = 0.8;
     std::unique_ptr<entry_type[]> mBuckets;
     size_type mBucketCount;
     size_type mEntryCount;
 
 #if defined(DEBUG)
     size_type mInsertCounter;
@@ skipping 24 matching lines @@
       mEntryCount = 0;
       mBucketCount = bucketCount;
       allocate();
 
       // Copy old entries into the new buffer
       for (size_type i = 0; i < oldCount; i++)
       {
         entry_type& entry = oldBuckets[i];
         if (!entry.is_invalid() && !entry.is_deleted())
         {
-          *find_bucket(entry.first) = entry;
+          *find_bucket(entry.first) = std::move(entry);
           mEntryCount++;
         }
       }
     }
 
-    entry_type* assign(entry_type* existing, const entry_type& entry)
+    entry_type* _assign(entry_type* existing, const entry_type& entry)

[sergei, 2018/01/24 18:37:12]

We normally don't use underscores at the beginning of the names, what about
something like `incrementSize` (something better is very welcomed)? IMO it
should reflect that the function increases mEntryCount if necessary and adjusts
the capacity in accordance with the LOAD_FACTOR.

[hub, 2018/01/24 19:32:01]

I'll call it "prepare_bucket" as we use it to ensure we have a bucket to assign
the entry to. Also I'll change the argument to just take the key instead of the
actual entry. 

     {
       if (existing->is_invalid())
       {
         if (mEntryCount + 1 >= mBucketCount * LOAD_FACTOR)
         {
           resize(mBucketCount << 1);
           existing = find_bucket(entry.first);
         }
         mEntryCount++;
 #if defined(DEBUG)
         mInsertCounter++;
 #endif
       }
+      return existing;
+    }
+
+    entry_type* assign(entry_type* existing, const entry_type& entry)
+    {
+      existing = _assign(existing, entry);
       *existing = entry;
       return existing;
     }
 
+    entry_type* assign(entry_type* existing, entry_type&& entry)
+    {
+      existing = _assign(existing, entry);
+      *existing = std::move(entry);
+      return existing;
+    }
+
     void allocate()
     {
       mBuckets.reset(new entry_type[mBucketCount]);
       // Working around https://github.com/waywardmonkeys/emscripten-trace-collector/issues/2 here
       annotate_address(reinterpret_cast<size_type*>(mBuckets.get()) - 1, "Hash table buffer");
     }
 
   public:
     explicit HashContainer(size_type expectedEntries = 0)
         : mEntryCount(0)
@@ skipping 123 matching lines @@
   const_reference find(key_type_cref key) const
   {
     return super::find(key);
   }
 
   reference find(key_type_cref key)
   {
     return reference(this, key, super::find_bucket(key));
   }
 };