---

yaml
---
r: 191337
b: refs/heads/beta
c: 7c6cab9
h: refs/heads/master
i:
  191335: 6d94b68

Author: sstrickl

[refs]

@@ -911,7 +911,7 @@ refs/tags/2.3.0-flutter-1.5.4-hotfix.1: a1668566e563aef64025d0af88a099cbbe847b7e
 refs/tags/2.3.1: 929b013ddc83a013b49a98fc28b6b503a972bddd
 refs/tags/2.3.1-dev.0.0: 1d1742efd39cd4762b844b510acf8c2f1fa6604e
 refs/tags/2.3.2-dev.0.0: c567183bac8a895014d79cd3bf1d8908d45547d6
-refs/heads/beta: e7614adedbd30727b2aab0f3af0d7d3ec7ea56bb
+refs/heads/beta: 7c6cab995a1bf955992cde62adeb440a4e38e19e
 refs/heads/sjindel.mep: b113b36c157cf54b257e82550e9bbde16f05ad8d
 refs/tags/2.3.2: f7ab96133aa79301daf812ef40b33c99d8ad1495
 refs/tags/2.3.2-dev.0.1: ef57e27c9798b54a54e9a1f74b1bd1f9be7290b1

branches/beta/runtime/vm/hash_map.h

@@ -39,6 +39,15 @@ class BaseDirectChainedHashMap : public B {
   void Insert(typename KeyValueTrait::Pair kv);
   bool Remove(typename KeyValueTrait::Key key);
 
+  // If a pair already exists in the map with an equal key, replace that pair
+  // with this one. Otherwise, insert the pair as a new entry.
+  //
+  // Note: Insert operates in constant time, while Update must walk the chained
+  // entries for a given hash value, checking keys for equality. However, if
+  // multiple value updates are needed for the same key, only using Update
+  // guarantees constant space usage whereas Insert does not.
+  void Update(typename KeyValueTrait::Pair kv);
+
   typename KeyValueTrait::Value LookupValue(
       typename KeyValueTrait::Key key) const;
 
@@ -314,6 +323,20 @@ void BaseDirectChainedHashMap<KeyValueTrait, B, Allocator>::Insert(
   }
 }
 
+template <typename KeyValueTrait, typename B, typename Allocator>
+void BaseDirectChainedHashMap<KeyValueTrait, B, Allocator>::Update(
+    typename KeyValueTrait::Pair kv) {
+  const typename KeyValueTrait::Value kNoValue =
+      KeyValueTrait::ValueOf(typename KeyValueTrait::Pair());
+
+  ASSERT(KeyValueTrait::ValueOf(kv) != kNoValue);
+  if (auto const old_kv = Lookup(KeyValueTrait::KeyOf(kv))) {
+    *old_kv = kv;
+  } else {
+    Insert(kv);
+  }
+}
+
 template <typename KeyValueTrait, typename B, typename Allocator>
 bool BaseDirectChainedHashMap<KeyValueTrait, B, Allocator>::Remove(
     typename KeyValueTrait::Key key) {

branches/beta/runtime/vm/hash_map_test.cc

@@ -220,4 +220,84 @@ TEST_CASE(CStringMap) {
   free(str1);
 }
 
+TEST_CASE(CStringMapUpdate) {
+  const char* const kConst1 = "test";
+  const char* const kConst2 = "test 2";
+
+  char* str1 = OS::SCreate(nullptr, "%s", kConst1);
+  char* str2 = OS::SCreate(nullptr, "%s", kConst2);
+  char* str3 = OS::SCreate(nullptr, "%s", kConst1);
+  char* str4 = OS::SCreate(nullptr, "%s", kConst1);  // Only used for lookup.
+
+  // Make sure these strings are pointer-distinct, but C-string-equal.
+  EXPECT_NE(str1, str3);
+  EXPECT_NE(str1, str4);
+  EXPECT_NE(str3, str4);
+  EXPECT_STREQ(str1, str3);
+  EXPECT_STREQ(str1, str4);
+
+  CStringKeyValueTrait<intptr_t>::Pair p1 = {str1, 1};
+  CStringKeyValueTrait<intptr_t>::Pair p2 = {str2, 2};
+  CStringKeyValueTrait<intptr_t>::Pair p3 = {str3, 3};
+
+  CStringMap<intptr_t> map;
+  EXPECT(map.IsEmpty());
+
+  map.Update(p1);
+  EXPECT_NOTNULL(map.Lookup(str1));
+  EXPECT_EQ(p1.value, map.LookupValue(str1));
+  EXPECT_NULLPTR(map.Lookup(str2));
+  EXPECT_NOTNULL(map.Lookup(str3));
+  EXPECT_EQ(p1.value, map.LookupValue(str3));
+  EXPECT_NOTNULL(map.Lookup(str4));
+  EXPECT_EQ(p1.value, map.LookupValue(str4));
+
+  map.Update(p2);
+  EXPECT_NOTNULL(map.Lookup(str1));
+  EXPECT_EQ(p1.value, map.LookupValue(str1));
+  EXPECT_NOTNULL(map.Lookup(str2));
+  EXPECT_EQ(p2.value, map.LookupValue(str2));
+  EXPECT_NOTNULL(map.Lookup(str3));
+  EXPECT_EQ(p1.value, map.LookupValue(str3));
+  EXPECT_NOTNULL(map.Lookup(str4));
+  EXPECT_EQ(p1.value, map.LookupValue(str4));
+
+  // Check Lookup after Update.
+  map.Update(p3);
+  EXPECT_NOTNULL(map.Lookup(str1));
+  EXPECT_EQ(p3.value, map.LookupValue(str1));
+  EXPECT_NOTNULL(map.Lookup(str2));
+  EXPECT_EQ(p2.value, map.LookupValue(str2));
+  EXPECT_NOTNULL(map.Lookup(str3));
+  EXPECT_EQ(p3.value, map.LookupValue(str3));
+  EXPECT_NOTNULL(map.Lookup(str4));
+  EXPECT_EQ(p3.value, map.LookupValue(str4));
+
+  // Check that single Remove after only Updates ensures Lookup fails after.
+  EXPECT(map.Remove(str3));
+  EXPECT_NULLPTR(map.Lookup(str1));
+  EXPECT_NOTNULL(map.Lookup(str2));
+  EXPECT_EQ(p2.value, map.LookupValue(str2));
+  EXPECT_NULLPTR(map.Lookup(str3));
+  EXPECT_NULLPTR(map.Lookup(str4));
+
+  EXPECT(!map.Remove(str3));
+  EXPECT(map.Remove(str2));
+  EXPECT(map.IsEmpty());
+
+  // Quick double-check that these weren't side-effected by the implementation
+  // of hash maps (p1 especially).
+  EXPECT_EQ(str1, p1.key);
+  EXPECT_EQ(1, p1.value);
+  EXPECT_EQ(str2, p2.key);
+  EXPECT_EQ(2, p2.value);
+  EXPECT_EQ(str3, p3.key);
+  EXPECT_EQ(3, p3.value);
+
+  free(str4);
+  free(str3);
+  free(str2);
+  free(str1);
+}
+
 }  // namespace dart