Issue 5142 - Convert Element Hiding to C++

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 128 matching lines @@
       }
     }
 
     void resize(size_type bucketCount)
     {
       std::unique_ptr<entry_type[]> oldBuckets(std::move(mBuckets));
       size_type oldCount = mBucketCount;
 
       mEntryCount = 0;
       mBucketCount = bucketCount;
-      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");
+      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;
           mEntryCount++;
         }
@@ skipping 11 matching lines @@
         }
         mEntryCount++;
 #if defined(DEBUG)
         mInsertCounter++;
 #endif
       }
       *existing = 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)
     {
       expectedEntries = ceil(expectedEntries / LOAD_FACTOR);
       mBucketCount = MIN_BUCKETS;
       while (mBucketCount < expectedEntries)
         mBucketCount <<= 1;
 
-      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");
+      allocate();
+    }
+
+    void clear()
+    {
+      mEntryCount = 0;
+      allocate();
     }
 
     void insert(const entry_type& entry)
     {
       assign(find_bucket(entry.first), entry);
     }
 
     bool erase(key_type_cref key)
     {
       entry_type* entry = find_bucket(key);
@@ skipping 12 matching lines @@
     const_iterator begin() const
     {
       return const_iterator(&mBuckets[0], &mBuckets[mBucketCount]);
     }
 
     const_iterator end() const
     {
       return const_iterator(&mBuckets[mBucketCount], &mBuckets[mBucketCount]);
     }
 
+    bool empty() const

[sergei, 2018/01/15 15:31:19]

What about renaming of `empty` and `size` methods because IMO they are
confusing. The interface is pretty close to the interface of std library but
these two methods are different because they don't reflect the actual number of
stored elements, they show the number of occupied buckets where all buckets can
contain deleted entries, so e.g. std::map::size() would return zero in this
case.

[hub, 2018/01/16 02:57:39]

I'm willing to not add empty() and use size() == 0 where I need it. Then we can
actually fix HashContainer() in a different patch.

Done

[sergei, 2018/01/16 16:43:58]

As I see it's really used as 
!((filter.GetDomains() && filter.GetDomains()->size()) ||
mExceptions.find(filter.GetSelector()))
in ElemHide::Add. Can there be something wrong when the size is positive but
there are actually nothing because the entry was removed?
I have not checked the whole  logic of the code in details yet.

+    {
+      return mEntryCount == 0;
+    }
+
     size_type size() const
     {
       return mEntryCount;
     }
   };
 
   template<typename Entry>
   struct MapReference : public HashContainerReference<Entry>
   {
     typedef HashContainerReference<Entry> super;
@@ skipping 68 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));
   }
 };