Repository: kudu Updated Branches: refs/heads/master 1dba44167 -> 26ef33602
[util] shorten names for key/mapped types There are not functional changes in this change. Change-Id: I9126f9b9a4a2e227ded842eee85140f81051fba6 Reviewed-on: http://gerrit.cloudera.org:8080/4584 Tested-by: Kudu Jenkins Reviewed-by: Adar Dembo <[email protected]> Project: http://git-wip-us.apache.org/repos/asf/kudu/repo Commit: http://git-wip-us.apache.org/repos/asf/kudu/commit/3cb16ff3 Tree: http://git-wip-us.apache.org/repos/asf/kudu/tree/3cb16ff3 Diff: http://git-wip-us.apache.org/repos/asf/kudu/diff/3cb16ff3 Branch: refs/heads/master Commit: 3cb16ff32e3a053664a1947055f6e66e0a5dd87d Parents: 1dba441 Author: Alexey Serbin <[email protected]> Authored: Fri Sep 30 16:53:46 2016 -0700 Committer: Alexey Serbin <[email protected]> Committed: Mon Oct 3 16:42:52 2016 +0000 ---------------------------------------------------------------------- src/kudu/gutil/map-util.h | 150 ++++++++++++++++++++--------------------- 1 file changed, 75 insertions(+), 75 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/kudu/blob/3cb16ff3/src/kudu/gutil/map-util.h ---------------------------------------------------------------------- diff --git a/src/kudu/gutil/map-util.h b/src/kudu/gutil/map-util.h index 8a3b302..6fffedf 100644 --- a/src/kudu/gutil/map-util.h +++ b/src/kudu/gutil/map-util.h @@ -95,9 +95,9 @@ using std::vector; // 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& +const typename Collection::mapped_type& FindOrDie(const Collection& collection, - const typename Collection::value_type::first_type& key) { + const typename Collection::key_type& key) { auto it = collection.find(key); CHECK(it != collection.end()) << "Map key not found: " << key; return it->second; @@ -105,9 +105,9 @@ FindOrDie(const Collection& collection, // Same as above, but returns a non-const reference. template <class Collection> -typename Collection::value_type::second_type& +typename Collection::mapped_type& FindOrDie(Collection& collection, // NOLINT - const typename Collection::value_type::first_type& key) { + const typename Collection::key_type& key) { auto it = collection.find(key); CHECK(it != collection.end()) << "Map key not found: " << key; return it->second; @@ -115,9 +115,9 @@ FindOrDie(Collection& collection, // NOLINT // Same as FindOrDie above, but doesn't log the key on failure. template <class Collection> -const typename Collection::value_type::second_type& +const typename Collection::mapped_type& FindOrDieNoPrint(const Collection& collection, - const typename Collection::value_type::first_type& key) { + const typename Collection::key_type& key) { typename Collection::const_iterator it = collection.find(key); CHECK(it != collection.end()) << "Map key not found"; return it->second; @@ -125,9 +125,9 @@ FindOrDieNoPrint(const Collection& collection, // Same as above, but returns a non-const reference. template <class Collection> -typename Collection::value_type::second_type& +typename Collection::mapped_type& FindOrDieNoPrint(Collection& collection, // NOLINT - const typename Collection::value_type::first_type& key) { + const typename Collection::key_type& key) { typename Collection::iterator it = collection.find(key); CHECK(it != collection.end()) << "Map key not found"; return it->second; @@ -143,10 +143,10 @@ FindOrDieNoPrint(Collection& collection, // NOLINT // 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: template <class Collection> -const typename Collection::value_type::second_type& +const typename Collection::mapped_type& FindWithDefault(const Collection& collection, - const typename Collection::value_type::first_type& key, - const typename Collection::value_type::second_type& value) { + const typename Collection::key_type& key, + const typename Collection::mapped_type& value) { auto it = collection.find(key); if (it == collection.end()) { return value; @@ -157,9 +157,9 @@ FindWithDefault(const Collection& collection, // Returns a pointer to the const value associated with the given key if it // exists, or NULL otherwise. template <class Collection> -const typename Collection::value_type::second_type* +const typename Collection::mapped_type* FindOrNull(const Collection& collection, - const typename Collection::value_type::first_type& key) { + const typename Collection::key_type& key) { auto it = collection.find(key); if (it == collection.end()) { return 0; @@ -169,9 +169,9 @@ FindOrNull(const Collection& collection, // Same as above but returns a pointer to the non-const value. template <class Collection> -typename Collection::value_type::second_type* +typename Collection::mapped_type* FindOrNull(Collection& collection, // NOLINT - const typename Collection::value_type::first_type& key) { + const typename Collection::key_type& key) { auto it = collection.find(key); if (it == collection.end()) { return 0; @@ -182,9 +182,9 @@ FindOrNull(Collection& collection, // NOLINT // Returns a pointer to the const value associated with the greatest key // that's less than or equal to the given key, or NULL if no such key exists. template <class Collection> -const typename Collection::value_type::second_type* +const typename Collection::mapped_type* FindFloorOrNull(const Collection& collection, - const typename Collection::value_type::first_type& key) { + const typename Collection::key_type& key) { auto it = collection.upper_bound(key); if (it == collection.begin()) { return 0; @@ -194,9 +194,9 @@ FindFloorOrNull(const Collection& collection, // Same as above but returns a pointer to the non-const value. template <class Collection> -typename Collection::value_type::second_type* +typename Collection::mapped_type* FindFloorOrNull(Collection& collection, // NOLINT - const typename Collection::value_type::first_type& key) { + const typename Collection::key_type& key) { auto it = collection.upper_bound(key); if (it == collection.begin()) { return 0; @@ -207,9 +207,9 @@ FindFloorOrNull(Collection& collection, // NOLINT // Returns a const-reference to the value associated with the greatest key // that's less than or equal to the given key, or crashes if it does not exist. template <class Collection> -const typename Collection::value_type::second_type& +const typename Collection::mapped_type& FindFloorOrDie(const Collection& collection, - const typename Collection::value_type::first_type& key) { + const typename Collection::key_type& key) { auto it = collection.upper_bound(key); CHECK(it != collection.begin()); return (--it)->second; @@ -217,9 +217,9 @@ FindFloorOrDie(const Collection& collection, // Same as above, but returns a non-const reference. template <class Collection> -typename Collection::value_type::second_type& +typename Collection::mapped_type& FindFloorOrDie(Collection& collection, - const typename Collection::value_type::first_type& key) { + const typename Collection::key_type& key) { auto it = collection.upper_bound(key); CHECK(it != collection.begin()); return (--it)->second; @@ -232,12 +232,12 @@ FindFloorOrDie(Collection& collection, // This function does not distinguish between a missing key and a key mapped // to a NULL value. template <class Collection> -typename Collection::value_type::second_type +typename Collection::mapped_type FindPtrOrNull(const Collection& collection, - const typename Collection::value_type::first_type& key) { + const typename Collection::key_type& key) { auto it = collection.find(key); if (it == collection.end()) { - return typename Collection::value_type::second_type(0); + return typename Collection::mapped_type(0); } return it->second; } @@ -247,12 +247,12 @@ FindPtrOrNull(const Collection& 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 +typename Collection::mapped_type FindPtrOrNull(Collection& collection, // NOLINT - const typename Collection::value_type::first_type& key) { + const typename Collection::key_type& key) { auto it = collection.find(key); if (it == collection.end()) { - return typename Collection::value_type::second_type(0); + return typename Collection::mapped_type(0); } return it->second; } @@ -336,8 +336,8 @@ bool InsertOrUpdate(Collection* const collection, // 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) { + const typename Collection::key_type& key, + const typename Collection::mapped_type& value) { return InsertOrUpdate( collection, typename Collection::value_type(key, value)); } @@ -359,8 +359,8 @@ void InsertOrUpdateMany(Collection* const collection, template <class Collection> bool InsertAndDeleteExisting( Collection* const collection, - const typename Collection::value_type::first_type& key, - const typename Collection::value_type::second_type& value) { + const typename Collection::key_type& key, + const typename Collection::mapped_type& value) { pair<typename Collection::iterator, bool> ret = collection->insert(typename Collection::value_type(key, value)); if (!ret.second) { @@ -385,8 +385,8 @@ bool InsertIfNotPresent(Collection* const collection, template <class Collection> bool InsertIfNotPresent( Collection* const collection, - const typename Collection::value_type::first_type& key, - const typename Collection::value_type::second_type& value) { + const typename Collection::key_type& key, + const typename Collection::mapped_type& value) { return InsertIfNotPresent( collection, typename Collection::value_type(key, value)); } @@ -409,8 +409,8 @@ void InsertOrDieNoPrint(Collection* const collection, // 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) { + const typename Collection::key_type& key, + const typename Collection::mapped_type& data) { CHECK(InsertIfNotPresent(collection, key, data)) << "duplicate key: " << key; } @@ -419,8 +419,8 @@ void InsertOrDie(Collection* const collection, template <class Collection> void InsertOrDieNoPrint( Collection* const collection, - const typename Collection::value_type::first_type& key, - const typename Collection::value_type::second_type& data) { + const typename Collection::key_type& key, + const typename Collection::mapped_type& data) { CHECK(InsertIfNotPresent(collection, key, data)) << "duplicate key."; } @@ -431,12 +431,12 @@ void InsertOrDieNoPrint( // SomeProto& proto = InsertKeyOrDie(&m, 3); // proto.set_field("foo"); template <class Collection> -typename Collection::value_type::second_type& InsertKeyOrDie( +typename Collection::mapped_type& InsertKeyOrDie( Collection* const collection, - const typename Collection::value_type::first_type& key) { + const typename Collection::key_type& key) { typedef typename Collection::value_type value_type; pair<typename Collection::iterator, bool> res = - collection->insert(value_type(key, typename value_type::second_type())); + collection->insert(value_type(key, typename Collection::mapped_type())); CHECK(res.second) << "duplicate key: " << key; return res.first->second; } @@ -449,7 +449,7 @@ typename Collection::value_type::second_type& InsertKeyOrDie( // 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& +typename Collection::mapped_type& LookupOrInsert(Collection* const collection, const typename Collection::value_type& vt) { return collection->insert(vt).first->second; @@ -457,10 +457,10 @@ LookupOrInsert(Collection* const collection, // Same as above except the key-value are passed separately. template <class Collection> -typename Collection::value_type::second_type& +typename Collection::mapped_type& LookupOrInsert(Collection* const collection, - const typename Collection::value_type::first_type& key, - const typename Collection::value_type::second_type& value) { + const typename Collection::key_type& key, + const typename Collection::mapped_type& value) { return LookupOrInsert( collection, typename Collection::value_type(key, value)); } @@ -478,13 +478,13 @@ LookupOrInsert(Collection* const collection, template <typename Sequence, typename Collection> void AddTokenCounts( const Sequence& sequence, - const typename Collection::value_type::second_type& increment, + const typename Collection::mapped_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 = + typename Collection::mapped_type& value = LookupOrInsert(count_map, *it, - typename Collection::value_type::second_type()); + typename Collection::mapped_type()); value += increment; } } @@ -508,13 +508,13 @@ void MapUtilAssignNewInstance(T** location, const Arg &arg) { // 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& +typename Collection::mapped_type& LookupOrInsertNew(Collection* const collection, - const typename Collection::value_type::first_type& key) { + const typename Collection::key_type& key) { pair<typename Collection::iterator, bool> ret = collection->insert( typename Collection::value_type(key, - static_cast<typename Collection::value_type::second_type>(NULL))); + static_cast<typename Collection::mapped_type>(NULL))); if (ret.second) { // This helper is needed to 'extract' the Value type from the type of the // container value, which is (Value*). @@ -526,15 +526,15 @@ LookupOrInsertNew(Collection* const collection, // 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& +typename Collection::mapped_type& LookupOrInsertNew(Collection* const collection, - const typename Collection::value_type::first_type& key, + const typename Collection::key_type& key, const Arg& arg) { pair<typename Collection::iterator, bool> ret = collection->insert( typename Collection::value_type( key, - static_cast<typename Collection::value_type::second_type>(NULL))); + static_cast<typename Collection::mapped_type>(NULL))); if (ret.second) { // This helper is needed to 'extract' the Value type from the type of the // container value, which is (Value*). @@ -557,12 +557,12 @@ LookupOrInsertNew(Collection* const collection, // 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& +typename Collection::mapped_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; + const typename Collection::key_type& key) { + typedef typename Collection::mapped_type SharedPtr; + typedef typename Collection::mapped_type::element_type Element; pair<typename Collection::iterator, bool> ret = collection->insert(typename Collection::value_type(key, SharedPtr())); if (ret.second) { @@ -577,13 +577,13 @@ LookupOrInsertNewSharedPtr( // 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& +typename Collection::mapped_type& LookupOrInsertNewSharedPtr( Collection* const collection, - const typename Collection::value_type::first_type& key, + const typename Collection::key_type& key, const Arg& arg) { - typedef typename Collection::value_type::second_type SharedPtr; - typedef typename Collection::value_type::second_type::element_type Element; + typedef typename Collection::mapped_type SharedPtr; + typedef typename Collection::mapped_type::element_type Element; pair<typename Collection::iterator, bool> ret = collection->insert(typename Collection::value_type(key, SharedPtr())); if (ret.second) { @@ -605,9 +605,9 @@ LookupOrInsertNewSharedPtr( // 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) { + const typename Collection::key_type& key, + const typename Collection::mapped_type& value, + typename Collection::mapped_type* previous) { pair<typename Collection::iterator, bool> ret = collection->insert(typename Collection::value_type(key, value)); if (!ret.second) { @@ -625,7 +625,7 @@ bool UpdateReturnCopy(Collection* const collection, template <class Collection> bool UpdateReturnCopy(Collection* const collection, const typename Collection::value_type& vt, - typename Collection::value_type::second_type* previous) { + typename Collection::mapped_type* previous) { pair<typename Collection::iterator, bool> ret = collection->insert(vt); if (!ret.second) { @@ -647,7 +647,7 @@ bool UpdateReturnCopy(Collection* const collection, // 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* const +typename Collection::mapped_type* const InsertOrReturnExisting(Collection* const collection, const typename Collection::value_type& vt) { pair<typename Collection::iterator, bool> ret = collection->insert(vt); @@ -660,11 +660,11 @@ InsertOrReturnExisting(Collection* const collection, // Same as above, except for explicit key and data. template <class Collection> -typename Collection::value_type::second_type* const +typename Collection::mapped_type* const InsertOrReturnExisting( Collection* const collection, - const typename Collection::value_type::first_type& key, - const typename Collection::value_type::second_type& data) { + const typename Collection::key_type& key, + const typename Collection::mapped_type& data) { return InsertOrReturnExisting(collection, typename Collection::value_type(key, data)); } @@ -701,14 +701,14 @@ void ReverseMap(const Collection& collection, // Note: if 'collection' is a multimap, this will only erase and return the // first value. template <class Collection> -typename Collection::value_type::second_type EraseKeyReturnValuePtr( +typename Collection::mapped_type EraseKeyReturnValuePtr( Collection* const collection, - const typename Collection::value_type::first_type& key) { + const typename Collection::key_type& key) { auto it = collection->find(key); if (it == collection->end()) { - return typename Collection::value_type::second_type(); + return typename Collection::mapped_type(); } - typename Collection::value_type::second_type v = std::move(it->second); + typename Collection::mapped_type v = std::move(it->second); collection->erase(it); return v; }
