THUAI6/CAPI/cpp/grpc/include/google/protobuf/stubs/map_util.h

// Protocol Buffers - Google's data interchange format
// Copyright 2014 Google Inc.  All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// 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.

// from google3/util/gtl/map_util.h
// Author: Anton Carver

#ifndef GOOGLE_PROTOBUF_STUBS_MAP_UTIL_H__
#define GOOGLE_PROTOBUF_STUBS_MAP_UTIL_H__

#include <stddef.h>
#include <iterator>
#include <string>
#include <utility>
#include <vector>

#include <google/protobuf/stubs/common.h>

namespace google
{
    namespace protobuf
    {
        namespace internal
        {
            // Local implementation of RemoveConst to avoid including base/type_traits.h.
            template<class T>
            struct RemoveConst
            {
                typedef T type;
            };
            template<class T>
            struct RemoveConst<const T> : RemoveConst<T>
            {
            };
        }  // namespace internal

        //
        // Find*()
        //

        // Returns a const reference to the value associated with the given key if it
        // exists. Crashes otherwise.
        //
        // This is intended as a replacement for operator[] as an rvalue (for reading)
        // when the key is guaranteed to exist.
        //
        // operator[] for lookup is discouraged for several reasons:
        //  * It has a side-effect of inserting missing keys
        //  * It is not thread-safe (even when it is not inserting, it can still
        //      choose to resize the underlying storage)
        //  * It invalidates iterators (when it chooses to resize)
        //  * It default constructs a value object even if it doesn't need to
        //
        // This version assumes the key is printable, and includes it in the fatal log
        // message.
        template<class Collection>
        const typename Collection::value_type::second_type&
            FindOrDie(const Collection& collection, const typename Collection::value_type::first_type& key)
        {
            typename Collection::const_iterator it = collection.find(key);
            GOOGLE_CHECK(it != collection.end()) << "Map key not found: " << key;
            return it->second;
        }

        // Same as above, but returns a non-const reference.
        template<class Collection>
        typename Collection::value_type::second_type&
            FindOrDie(Collection& collection,  // NOLINT
                      const typename Collection::value_type::first_type& key)
        {
            typename Collection::iterator it = collection.find(key);
            GOOGLE_CHECK(it != collection.end()) << "Map key not found: " << key;
            return it->second;
        }

        // Same as FindOrDie above, but doesn't log the key on failure.
        template<class Collection>
        const typename Collection::value_type::second_type&
            FindOrDieNoPrint(const Collection& collection, const typename Collection::value_type::first_type& key)
        {
            typename Collection::const_iterator it = collection.find(key);
            GOOGLE_CHECK(it != collection.end()) << "Map key not found";
            return it->second;
        }

        // Same as above, but returns a non-const reference.
        template<class Collection>
        typename Collection::value_type::second_type&
            FindOrDieNoPrint(Collection& collection,  // NOLINT
                             const typename Collection::value_type::first_type& key)
        {
            typename Collection::iterator it = collection.find(key);
            GOOGLE_CHECK(it != collection.end()) << "Map key not found";
            return it->second;
        }

        // Returns a const reference to the value associated with the given key if it
        // exists, otherwise returns a const reference to the provided default value.
        //
        // WARNING: If a temporary object is passed as the default "value,"
        // this function will return a reference to that temporary object,
        // which will be destroyed at the end of the statement. A common
        // example: if you have a map with string values, and you pass a char*
        // as the default "value," either use the returned value immediately
        // or store it in a string (not string&).
        // Details: http://go/findwithdefault
        template<class Collection>
        const typename Collection::value_type::second_type&
            FindWithDefault(const Collection& collection, const typename Collection::value_type::first_type& key, const typename Collection::value_type::second_type& value)
        {
            typename Collection::const_iterator it = collection.find(key);
            if (it == collection.end())
            {
                return value;
            }
            return it->second;
        }

        // Returns a pointer to the const value associated with the given key if it
        // exists, or nullptr otherwise.
        template<class Collection>
        const typename Collection::value_type::second_type*
            FindOrNull(const Collection& collection, const typename Collection::value_type::first_type& key)
        {
            typename Collection::const_iterator it = collection.find(key);
            if (it == collection.end())
            {
                return 0;
            }
            return &it->second;
        }

        // Same as above but returns a pointer to the non-const value.
        template<class Collection>
        typename Collection::value_type::second_type*
            FindOrNull(Collection& collection,  // NOLINT
                       const typename Collection::value_type::first_type& key)
        {
            typename Collection::iterator it = collection.find(key);
            if (it == collection.end())
            {
                return 0;
            }
            return &it->second;
        }

        // Returns the pointer value associated with the given key. If none is found,
        // nullptr is returned. The function is designed to be used with a map of keys to
        // pointers.
        //
        // This function does not distinguish between a missing key and a key mapped
        // to nullptr.
        template<class Collection>
        typename Collection::value_type::second_type
            FindPtrOrNull(const Collection& collection, const typename Collection::value_type::first_type& key)
        {
            typename Collection::const_iterator it = collection.find(key);
            if (it == collection.end())
            {
                return typename Collection::value_type::second_type();
            }
            return it->second;
        }

        // Same as above, except takes non-const reference to collection.
        //
        // This function is needed for containers that propagate constness to the
        // pointee, such as boost::ptr_map.
        template<class Collection>
        typename Collection::value_type::second_type
            FindPtrOrNull(Collection& collection,  // NOLINT
                          const typename Collection::value_type::first_type& key)
        {
            typename Collection::iterator it = collection.find(key);
            if (it == collection.end())
            {
                return typename Collection::value_type::second_type();
            }
            return it->second;
        }

        // Finds the pointer value associated with the given key in a map whose values
        // are linked_ptrs. Returns nullptr if key is not found.
        template<class Collection>
        typename Collection::value_type::second_type::element_type*
            FindLinkedPtrOrNull(const Collection& collection, const typename Collection::value_type::first_type& key)
        {
            typename Collection::const_iterator it = collection.find(key);
            if (it == collection.end())
            {
                return 0;
            }
            // Since linked_ptr::get() is a const member returning a non const,
            // we do not need a version of this function taking a non const collection.
            return it->second.get();
        }

        // Same as above, but dies if the key is not found.
        template<class Collection>
        typename Collection::value_type::second_type::element_type&
            FindLinkedPtrOrDie(const Collection& collection, const typename Collection::value_type::first_type& key)
        {
            typename Collection::const_iterator it = collection.find(key);
            GOOGLE_CHECK(it != collection.end()) << "key not found: " << key;
            // Since linked_ptr::operator*() is a const member returning a non const,
            // we do not need a version of this function taking a non const collection.
            return *it->second;
        }

        // Finds the value associated with the given key and copies it to *value (if not
        // nullptr). Returns false if the key was not found, true otherwise.
        template<class Collection, class Key, class Value>
        bool FindCopy(const Collection& collection, const Key& key, Value* const value)
        {
            typename Collection::const_iterator it = collection.find(key);
            if (it == collection.end())
            {
                return false;
            }
            if (value)
            {
                *value = it->second;
            }
            return true;
        }

        //
        // Contains*()
        //

        // Returns true if and only if the given collection contains the given key.
        template<class Collection, class Key>
        bool ContainsKey(const Collection& collection, const Key& key)
        {
            return collection.find(key) != collection.end();
        }

        // Returns true if and only if the given collection contains the given key-value
        // pair.
        template<class Collection, class Key, class Value>
        bool ContainsKeyValuePair(const Collection& collection, const Key& key, const Value& value)
        {
            typedef typename Collection::const_iterator const_iterator;
            std::pair<const_iterator, const_iterator> range = collection.equal_range(key);
            for (const_iterator it = range.first; it != range.second; ++it)
            {
                if (it->second == value)
                {
                    return true;
                }
            }
            return false;
        }

        //
        // Insert*()
        //

        // Inserts the given key-value pair into the collection. Returns true if and
        // only if the key from the given pair didn't previously exist. Otherwise, the
        // value in the map is replaced with the value from the given pair.
        template<class Collection>
        bool InsertOrUpdate(Collection* const collection, const typename Collection::value_type& vt)
        {
            std::pair<typename Collection::iterator, bool> ret = collection->insert(vt);
            if (!ret.second)
            {
                // update
                ret.first->second = vt.second;
                return false;
            }
            return true;
        }

        // Same as above, except that the key and value are passed separately.
        template<class Collection>
        bool InsertOrUpdate(Collection* const collection, const typename Collection::value_type::first_type& key, const typename Collection::value_type::second_type& value)
        {
            return InsertOrUpdate(
                collection, typename Collection::value_type(key, value)
            );
        }

        // Inserts/updates all the key-value pairs from the range defined by the
        // iterators "first" and "last" into the given collection.
        template<class Collection, class InputIterator>
        void InsertOrUpdateMany(Collection* const collection, InputIterator first, InputIterator last)
        {
            for (; first != last; ++first)
            {
                InsertOrUpdate(collection, *first);
            }
        }

        // Change the value associated with a particular key in a map or hash_map
        // of the form map<Key, Value*> which owns the objects pointed to by the
        // value pointers.  If there was an existing value for the key, it is deleted.
        // True indicates an insert took place, false indicates an update + delete.
        template<class Collection>
        bool InsertAndDeleteExisting(
            Collection* const collection,
            const typename Collection::value_type::first_type& key,
            const typename Collection::value_type::second_type& value
        )
        {
            std::pair<typename Collection::iterator, bool> ret =
                collection->insert(typename Collection::value_type(key, value));
            if (!ret.second)
            {
                delete ret.first->second;
                ret.first->second = value;
                return false;
            }
            return true;
        }

        // Inserts the given key and value into the given collection if and only if the
        // given key did NOT already exist in the collection. If the key previously
        // existed in the collection, the value is not changed. Returns true if the
        // key-value pair was inserted; returns false if the key was already present.
        template<class Collection>
        bool InsertIfNotPresent(Collection* const collection, const typename Collection::value_type& vt)
        {
            return collection->insert(vt).second;
        }

        // Same as above except the key and value are passed separately.
        template<class Collection>
        bool InsertIfNotPresent(
            Collection* const collection,
            const typename Collection::value_type::first_type& key,
            const typename Collection::value_type::second_type& value
        )
        {
            return InsertIfNotPresent(
                collection, typename Collection::value_type(key, value)
            );
        }

        // Same as above except dies if the key already exists in the collection.
        template<class Collection>
        void InsertOrDie(Collection* const collection, const typename Collection::value_type& value)
        {
            GOOGLE_CHECK(InsertIfNotPresent(collection, value))
                << "duplicate value: " << value;
        }

        // Same as above except doesn't log the value on error.
        template<class Collection>
        void InsertOrDieNoPrint(Collection* const collection, const typename Collection::value_type& value)
        {
            GOOGLE_CHECK(InsertIfNotPresent(collection, value)) << "duplicate value.";
        }

        // Inserts the key-value pair into the collection. Dies if key was already
        // present.
        template<class Collection>
        void InsertOrDie(Collection* const collection, const typename Collection::value_type::first_type& key, const typename Collection::value_type::second_type& data)
        {
            GOOGLE_CHECK(InsertIfNotPresent(collection, key, data))
                << "duplicate key: " << key;
        }

        // Same as above except doesn't log the key on error.
        template<class Collection>
        void InsertOrDieNoPrint(
            Collection* const collection,
            const typename Collection::value_type::first_type& key,
            const typename Collection::value_type::second_type& data
        )
        {
            GOOGLE_CHECK(InsertIfNotPresent(collection, key, data)) << "duplicate key.";
        }

        // Inserts a new key and default-initialized value. Dies if the key was already
        // present. Returns a reference to the value. Example usage:
        //
        // map<int, SomeProto> m;
        // SomeProto& proto = InsertKeyOrDie(&m, 3);
        // proto.set_field("foo");
        template<class Collection>
        typename Collection::value_type::second_type& InsertKeyOrDie(
            Collection* const collection,
            const typename Collection::value_type::first_type& key
        )
        {
            typedef typename Collection::value_type value_type;
            std::pair<typename Collection::iterator, bool> res =
                collection->insert(value_type(key, typename value_type::second_type()));
            GOOGLE_CHECK(res.second) << "duplicate key: " << key;
            return res.first->second;
        }

        //
        // Lookup*()
        //

        // Looks up a given key and value pair in a collection and inserts the key-value
        // pair if it's not already present. Returns a reference to the value associated
        // with the key.
        template<class Collection>
        typename Collection::value_type::second_type&
            LookupOrInsert(Collection* const collection, const typename Collection::value_type& vt)
        {
            return collection->insert(vt).first->second;
        }

        // Same as above except the key-value are passed separately.
        template<class Collection>
        typename Collection::value_type::second_type&
            LookupOrInsert(Collection* const collection, const typename Collection::value_type::first_type& key, const typename Collection::value_type::second_type& value)
        {
            return LookupOrInsert(
                collection, typename Collection::value_type(key, value)
            );
        }

        // Counts the number of equivalent elements in the given "sequence", and stores
        // the results in "count_map" with element as the key and count as the value.
        //
        // Example:
        //   vector<string> v = {"a", "b", "c", "a", "b"};
        //   map<string, int> m;
        //   AddTokenCounts(v, 1, &m);
        //   assert(m["a"] == 2);
        //   assert(m["b"] == 2);
        //   assert(m["c"] == 1);
        template<typename Sequence, typename Collection>
        void AddTokenCounts(
            const Sequence& sequence,
            const typename Collection::value_type::second_type& increment,
            Collection* const count_map
        )
        {
            for (typename Sequence::const_iterator it = sequence.begin();
                 it != sequence.end();
                 ++it)
            {
                typename Collection::value_type::second_type& value =
                    LookupOrInsert(count_map, *it, typename Collection::value_type::second_type());
                value += increment;
            }
        }

        // Returns a reference to the value associated with key. If not found, a value
        // is default constructed on the heap and added to the map.
        //
        // This function is useful for containers of the form map<Key, Value*>, where
        // inserting a new key, value pair involves constructing a new heap-allocated
        // Value, and storing a pointer to that in the collection.
        template<class Collection>
        typename Collection::value_type::second_type&
            LookupOrInsertNew(Collection* const collection, const typename Collection::value_type::first_type& key)
        {
            typedef typename std::iterator_traits<
                typename Collection::value_type::second_type>::value_type Element;
            std::pair<typename Collection::iterator, bool> ret =
                collection->insert(typename Collection::value_type(
                    key,
                    static_cast<typename Collection::value_type::second_type>(nullptr)
                ));
            if (ret.second)
            {
                ret.first->second = new Element();
            }
            return ret.first->second;
        }

        // Same as above but constructs the value using the single-argument constructor
        // and the given "arg".
        template<class Collection, class Arg>
        typename Collection::value_type::second_type&
            LookupOrInsertNew(Collection* const collection, const typename Collection::value_type::first_type& key, const Arg& arg)
        {
            typedef typename std::iterator_traits<
                typename Collection::value_type::second_type>::value_type Element;
            std::pair<typename Collection::iterator, bool> ret =
                collection->insert(typename Collection::value_type(
                    key,
                    static_cast<typename Collection::value_type::second_type>(nullptr)
                ));
            if (ret.second)
            {
                ret.first->second = new Element(arg);
            }
            return ret.first->second;
        }

        // Lookup of linked/shared pointers is used in two scenarios:
        //
        // Use LookupOrInsertNewLinkedPtr if the container owns the elements.
        // In this case it is fine working with the raw pointer as long as it is
        // guaranteed that no other thread can delete/update an accessed element.
        // A mutex will need to lock the container operation as well as the use
        // of the returned elements. Finding an element may be performed using
        // FindLinkedPtr*().
        //
        // Use LookupOrInsertNewSharedPtr if the container does not own the elements
        // for their whole lifetime. This is typically the case when a reader allows
        // parallel updates to the container. In this case a Mutex only needs to lock
        // container operations, but all element operations must be performed on the
        // shared pointer. Finding an element must be performed using FindPtr*() and
        // cannot be done with FindLinkedPtr*() even though it compiles.

        // Lookup a key in a map or hash_map whose values are linked_ptrs.  If it is
        // missing, set collection[key].reset(new Value::element_type) and return that.
        // Value::element_type must be default constructable.
        template<class Collection>
        typename Collection::value_type::second_type::element_type*
            LookupOrInsertNewLinkedPtr(
                Collection* const collection,
                const typename Collection::value_type::first_type& key
            )
        {
            typedef typename Collection::value_type::second_type Value;
            std::pair<typename Collection::iterator, bool> ret =
                collection->insert(typename Collection::value_type(key, Value()));
            if (ret.second)
            {
                ret.first->second.reset(new typename Value::element_type);
            }
            return ret.first->second.get();
        }

        // A variant of LookupOrInsertNewLinkedPtr where the value is constructed using
        // a single-parameter constructor.  Note: the constructor argument is computed
        // even if it will not be used, so only values cheap to compute should be passed
        // here.  On the other hand it does not matter how expensive the construction of
        // the actual stored value is, as that only occurs if necessary.
        template<class Collection, class Arg>
        typename Collection::value_type::second_type::element_type*
            LookupOrInsertNewLinkedPtr(
                Collection* const collection,
                const typename Collection::value_type::first_type& key,
                const Arg& arg
            )
        {
            typedef typename Collection::value_type::second_type Value;
            std::pair<typename Collection::iterator, bool> ret =
                collection->insert(typename Collection::value_type(key, Value()));
            if (ret.second)
            {
                ret.first->second.reset(new typename Value::element_type(arg));
            }
            return ret.first->second.get();
        }

        // Lookup a key in a map or hash_map whose values are shared_ptrs.  If it is
        // missing, set collection[key].reset(new Value::element_type). Unlike
        // LookupOrInsertNewLinkedPtr, this function returns the shared_ptr instead of
        // the raw pointer. Value::element_type must be default constructable.
        template<class Collection>
        typename Collection::value_type::second_type&
            LookupOrInsertNewSharedPtr(
                Collection* const collection,
                const typename Collection::value_type::first_type& key
            )
        {
            typedef typename Collection::value_type::second_type SharedPtr;
            typedef typename Collection::value_type::second_type::element_type Element;
            std::pair<typename Collection::iterator, bool> ret =
                collection->insert(typename Collection::value_type(key, SharedPtr()));
            if (ret.second)
            {
                ret.first->second.reset(new Element());
            }
            return ret.first->second;
        }

        // A variant of LookupOrInsertNewSharedPtr where the value is constructed using
        // a single-parameter constructor.  Note: the constructor argument is computed
        // even if it will not be used, so only values cheap to compute should be passed
        // here.  On the other hand it does not matter how expensive the construction of
        // the actual stored value is, as that only occurs if necessary.
        template<class Collection, class Arg>
        typename Collection::value_type::second_type&
            LookupOrInsertNewSharedPtr(
                Collection* const collection,
                const typename Collection::value_type::first_type& key,
                const Arg& arg
            )
        {
            typedef typename Collection::value_type::second_type SharedPtr;
            typedef typename Collection::value_type::second_type::element_type Element;
            std::pair<typename Collection::iterator, bool> ret =
                collection->insert(typename Collection::value_type(key, SharedPtr()));
            if (ret.second)
            {
                ret.first->second.reset(new Element(arg));
            }
            return ret.first->second;
        }

        //
        // Misc Utility Functions
        //

        // Updates the value associated with the given key. If the key was not already
        // present, then the key-value pair are inserted and "previous" is unchanged. If
        // the key was already present, the value is updated and "*previous" will
        // contain a copy of the old value.
        //
        // InsertOrReturnExisting has complementary behavior that returns the
        // address of an already existing value, rather than updating it.
        template<class Collection>
        bool UpdateReturnCopy(Collection* const collection, const typename Collection::value_type::first_type& key, const typename Collection::value_type::second_type& value, typename Collection::value_type::second_type* previous)
        {
            std::pair<typename Collection::iterator, bool> ret =
                collection->insert(typename Collection::value_type(key, value));
            if (!ret.second)
            {
                // update
                if (previous)
                {
                    *previous = ret.first->second;
                }
                ret.first->second = value;
                return true;
            }
            return false;
        }

        // Same as above except that the key and value are passed as a pair.
        template<class Collection>
        bool UpdateReturnCopy(Collection* const collection, const typename Collection::value_type& vt, typename Collection::value_type::second_type* previous)
        {
            std::pair<typename Collection::iterator, bool> ret = collection->insert(vt);
            if (!ret.second)
            {
                // update
                if (previous)
                {
                    *previous = ret.first->second;
                }
                ret.first->second = vt.second;
                return true;
            }
            return false;
        }

        // Tries to insert the given key-value pair into the collection. Returns nullptr if
        // the insert succeeds. Otherwise, returns a pointer to the existing value.
        //
        // This complements UpdateReturnCopy in that it allows to update only after
        // verifying the old value and still insert quickly without having to look up
        // twice. Unlike UpdateReturnCopy this also does not come with the issue of an
        // undefined previous* in case new data was inserted.
        template<class Collection>
        typename Collection::value_type::second_type* InsertOrReturnExisting(
            Collection* const collection, const typename Collection::value_type& vt
        )
        {
            std::pair<typename Collection::iterator, bool> ret = collection->insert(vt);
            if (ret.second)
            {
                return nullptr;  // Inserted, no existing previous value.
            }
            else
            {
                return &ret.first->second;  // Return address of already existing value.
            }
        }

        // Same as above, except for explicit key and data.
        template<class Collection>
        typename Collection::value_type::second_type* InsertOrReturnExisting(
            Collection* const collection,
            const typename Collection::value_type::first_type& key,
            const typename Collection::value_type::second_type& data
        )
        {
            return InsertOrReturnExisting(collection, typename Collection::value_type(key, data));
        }

        // Erases the collection item identified by the given key, and returns the value
        // associated with that key. It is assumed that the value (i.e., the
        // mapped_type) is a pointer. Returns nullptr if the key was not found in the
        // collection.
        //
        // Examples:
        //   map<string, MyType*> my_map;
        //
        // One line cleanup:
        //     delete EraseKeyReturnValuePtr(&my_map, "abc");
        //
        // Use returned value:
        //     std::unique_ptr<MyType> value_ptr(
        //         EraseKeyReturnValuePtr(&my_map, "abc"));
        //     if (value_ptr.get())
        //       value_ptr->DoSomething();
        //
        template<class Collection>
        typename Collection::value_type::second_type EraseKeyReturnValuePtr(
            Collection* const collection,
            const typename Collection::value_type::first_type& key
        )
        {
            typename Collection::iterator it = collection->find(key);
            if (it == collection->end())
            {
                return nullptr;
            }
            typename Collection::value_type::second_type v = it->second;
            collection->erase(it);
            return v;
        }

        // Inserts all the keys from map_container into key_container, which must
        // support insert(MapContainer::key_type).
        //
        // Note: any initial contents of the key_container are not cleared.
        template<class MapContainer, class KeyContainer>
        void InsertKeysFromMap(const MapContainer& map_container, KeyContainer* key_container)
        {
            GOOGLE_CHECK(key_container != nullptr);
            for (typename MapContainer::const_iterator it = map_container.begin();
                 it != map_container.end();
                 ++it)
            {
                key_container->insert(it->first);
            }
        }

        // Appends all the keys from map_container into key_container, which must
        // support push_back(MapContainer::key_type).
        //
        // Note: any initial contents of the key_container are not cleared.
        template<class MapContainer, class KeyContainer>
        void AppendKeysFromMap(const MapContainer& map_container, KeyContainer* key_container)
        {
            GOOGLE_CHECK(key_container != nullptr);
            for (typename MapContainer::const_iterator it = map_container.begin();
                 it != map_container.end();
                 ++it)
            {
                key_container->push_back(it->first);
            }
        }

        // A more specialized overload of AppendKeysFromMap to optimize reallocations
        // for the common case in which we're appending keys to a vector and hence can
        // (and sometimes should) call reserve() first.
        //
        // (It would be possible to play SFINAE games to call reserve() for any
        // container that supports it, but this seems to get us 99% of what we need
        // without the complexity of a SFINAE-based solution.)
        template<class MapContainer, class KeyType>
        void AppendKeysFromMap(const MapContainer& map_container, std::vector<KeyType>* key_container)
        {
            GOOGLE_CHECK(key_container != nullptr);
            // We now have the opportunity to call reserve(). Calling reserve() every
            // time is a bad idea for some use cases: libstdc++'s implementation of
            // vector<>::reserve() resizes the vector's backing store to exactly the
            // given size (unless it's already at least that big). Because of this,
            // the use case that involves appending a lot of small maps (total size
            // N) one by one to a vector would be O(N^2). But never calling reserve()
            // loses the opportunity to improve the use case of adding from a large
            // map to an empty vector (this improves performance by up to 33%). A
            // number of heuristics are possible; see the discussion in
            // cl/34081696. Here we use the simplest one.
            if (key_container->empty())
            {
                key_container->reserve(map_container.size());
            }
            for (typename MapContainer::const_iterator it = map_container.begin();
                 it != map_container.end();
                 ++it)
            {
                key_container->push_back(it->first);
            }
        }

        // Inserts all the values from map_container into value_container, which must
        // support push_back(MapContainer::mapped_type).
        //
        // Note: any initial contents of the value_container are not cleared.
        template<class MapContainer, class ValueContainer>
        void AppendValuesFromMap(const MapContainer& map_container, ValueContainer* value_container)
        {
            GOOGLE_CHECK(value_container != nullptr);
            for (typename MapContainer::const_iterator it = map_container.begin();
                 it != map_container.end();
                 ++it)
            {
                value_container->push_back(it->second);
            }
        }

        // A more specialized overload of AppendValuesFromMap to optimize reallocations
        // for the common case in which we're appending values to a vector and hence
        // can (and sometimes should) call reserve() first.
        //
        // (It would be possible to play SFINAE games to call reserve() for any
        // container that supports it, but this seems to get us 99% of what we need
        // without the complexity of a SFINAE-based solution.)
        template<class MapContainer, class ValueType>
        void AppendValuesFromMap(const MapContainer& map_container, std::vector<ValueType>* value_container)
        {
            GOOGLE_CHECK(value_container != nullptr);
            // See AppendKeysFromMap for why this is done.
            if (value_container->empty())
            {
                value_container->reserve(map_container.size());
            }
            for (typename MapContainer::const_iterator it = map_container.begin();
                 it != map_container.end();
                 ++it)
            {
                value_container->push_back(it->second);
            }
        }

    }  // namespace protobuf
}  // namespace google

#endif  // GOOGLE_PROTOBUF_STUBS_MAP_UTIL_H__