feat(util): Introduce map utilities (#2076)

When using C++ standard map-like containers, it's inconvenient to use
the find*() functions, we have to compare the found iterator to the
`end()` element, using the `second` to access its value, etc. It will
be convenient to introduce some map utilities.

The facebook/folly implementation [1] is limited, it lacks of some useful
functions (for example, ContainsKey(), InsertIfNotPresent()).

The original "gutil" implementation maybe from google/supersonic [2], but
it has been archived and not hasn't been well maintainanced for years.

The apache/kudu and impala/kudu implementation [3][4] is copied from some
google implementation, but they lack of meaningful licenses.

Another evoluted implementation is google/zetasql [5], and it contains
clear license. It's a SQL analyzer framework but not a lightweight
infrastructure library, it's too heavy to introduce the whole project.

This patch introduces the necessary source code of map-util and its unit
tests (under src/gutil/*), and give a few examples to show how to use.

1. https://github.com/facebook/folly/blob/main/folly/container/MapUtil.h
2. https://github.com/google/supersonic/blob/master/supersonic/utils/map_util.h
3. https://github.com/apache/kudu/blob/master/src/kudu/gutil/map-util.h
4. https://github.com/apache/impala/blob/master/be/src/gutil/map-util.h
5. https://github.com/google/zetasql/blob/master/zetasql/base/map_util.h

Author: acelyc111

.licenserc.yaml

@@ -667,5 +667,13 @@ header:
     - 'src/zookeeper/zookeeper_session.h'
     - 'src/zookeeper/zookeeper_session_mgr.cpp'
     - 'src/zookeeper/zookeeper_session_mgr.h'
+    # Apache License, Version 2.0, Copyright 2018 Google LLC
+    - 'src/gutil/test/map_traits_test.cpp'
+    - 'src/gutil/test/map_util_test.h'
+    - 'src/gutil/test/map_util_unittest.cpp'
+    - 'src/gutil/test/no_destructor_test.cpp'
+    - 'src/gutil/map_traits.h'
+    - 'src/gutil/map_util.h'
+    - 'src/gutil/no_destructor.h'
 
   comment: on-failure

LICENSE

@@ -570,3 +570,26 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+--------------------------------------------------------------------------------
+
+src/gutil/test/map_traits_test.cpp
+src/gutil/test/map_util_test.h
+src/gutil/test/map_util_unittest.cpp
+src/gutil/test/no_destructor_test.cpp
+src/gutil/map_traits.h
+src/gutil/map_util.h
+src/gutil/no_destructor.h
+
+Copyright 2018 Google LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

src/CMakeLists.txt

@@ -41,6 +41,7 @@ add_subdirectory(client_lib)
 add_subdirectory(common)
 add_subdirectory(failure_detector)
 add_subdirectory(geo)
+add_subdirectory(gutil)
 add_subdirectory(http)
 add_subdirectory(meta)
 add_subdirectory(nfs)

src/base/idl_utils.h

@@ -23,16 +23,17 @@
 
 #include "rrdb/rrdb_types.h"
 #include "utils/fmt_utils.h"
+#include "gutil/map_util.h"
 
 namespace pegasus {
 
 inline std::string cas_check_type_to_string(dsn::apps::cas_check_type::type type)
 {
-    auto it = dsn::apps::_cas_check_type_VALUES_TO_NAMES.find(type);
-    if (it == dsn::apps::_cas_check_type_VALUES_TO_NAMES.end()) {
-        return std::string("INVALID=") + std::to_string(int(type));
+    const auto *name = gutil::FindOrNull(dsn::apps::_cas_check_type_VALUES_TO_NAMES, type);
+    if (dsn_unlikely(name == nullptr)) {
+        return fmt::format("INVALID={}", type);
     }
-    return it->second;
+    return *name;
 }
 
 inline bool cas_is_check_operand_needed(dsn::apps::cas_check_type::type type)

src/common/duplication_common.cpp

@@ -122,6 +122,7 @@ class duplication_group_registry : public utils::singleton<duplication_group_reg
                      _group.size(),
                      "there might be duplicate cluster_name in configuration");
 
+        // TODO(yingchun): add InsertValuesFromMap to src/gutil/map_util.h, then use it here.
         for (const auto &kv : _group) {
             _distinct_cids.insert(kv.second);
         }

src/gutil/CMakeLists.txt

@@ -0,0 +1,21 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# TODO(yingchun): add the project after new *.cpp files have been added.
+#set(MY_PROJ_NAME pgs_gutil)
+
+add_subdirectory(test)

src/gutil/map_traits.h

@@ -0,0 +1,80 @@
+//
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#pragma once
+
+// Traits classes for performing uniform lookup on different map value types.
+//
+// The access is computed as follows:
+//
+//   1. If T has a `first` or `second` field, use them.
+//   2. Otherwise if it has `key()` or `value()` methods, use them.
+//   3. Otherwise the program is ill-formed.
+
+#include <utility>
+
+namespace gutil {
+namespace subtle {
+namespace internal_map_traits {
+struct Rank1
+{
+};
+struct Rank0 : Rank1
+{
+};
+
+template <class V>
+auto GetKey(V &&v, Rank0) -> decltype((std::forward<V>(v).first))
+{
+    return std::forward<V>(v).first;
+}
+template <class V>
+auto GetKey(V &&v, Rank1) -> decltype(std::forward<V>(v).key())
+{
+    return std::forward<V>(v).key();
+}
+
+template <class V>
+auto GetMapped(V &&v, Rank0) -> decltype((std::forward<V>(v).second))
+{
+    return std::forward<V>(v).second;
+}
+template <class V>
+auto GetMapped(V &&v, Rank1) -> decltype(std::forward<V>(v).value())
+{
+    return std::forward<V>(v).value();
+}
+
+} // namespace internal_map_traits
+
+// Accesses the `key_type` from a `value_type`.
+template <typename V>
+auto GetKey(V &&v)
+    -> decltype(internal_map_traits::GetKey(std::forward<V>(v), internal_map_traits::Rank0()))
+{
+    return internal_map_traits::GetKey(std::forward<V>(v), internal_map_traits::Rank0());
+}
+
+// Accesses the `mapped_type` from a `value_type`.
+template <typename V>
+auto GetMapped(V &&v)
+    -> decltype(internal_map_traits::GetMapped(std::forward<V>(v), internal_map_traits::Rank0()))
+{
+    return internal_map_traits::GetMapped(std::forward<V>(v), internal_map_traits::Rank0());
+}
+
+} // namespace subtle
+} // namespace gutil