From 13dc07cd155a243a3049ad86e61bef4a376f0604 Mon Sep 17 00:00:00 2001 From: BlackMATov Date: Fri, 10 May 2019 08:59:03 +0700 Subject: [PATCH] EBO for flat_map --- headers/flat_hpp/flat_map.hpp | 144 ++++++++++++++++++++-------------- untests/flat_map_tests.cpp | 28 +++++++ 2 files changed, 114 insertions(+), 58 deletions(-) diff --git a/headers/flat_hpp/flat_map.hpp b/headers/flat_hpp/flat_map.hpp index b531731..85718a1 100644 --- a/headers/flat_hpp/flat_map.hpp +++ b/headers/flat_hpp/flat_map.hpp @@ -17,32 +17,55 @@ namespace flat_hpp { + namespace detail + { + template < typename Value, typename Compare > + class flat_map_compare : public Compare { + public: + flat_map_compare() = default; + + flat_map_compare(const Compare& compare) + : Compare(compare) {} + + bool operator()( + const typename Value::first_type& l, + const typename Value::first_type& r) const + { + return Compare::operator()(l, r); + } + + bool operator()( + const typename Value::first_type& l, + const Value& r) const + { + return Compare::operator()(l, r.first); + } + + bool operator()( + const Value& l, + const typename Value::first_type& r) const + { + return Compare::operator()(l.first, r); + } + + bool operator()(const Value& l, const Value& r) const { + return Compare::operator()(l.first, r.first); + } + }; + } + template < typename Key , typename Value , typename Compare = std::less , typename Container = std::vector> > - class flat_map final { - class uber_comparer_type : public Compare { - public: - uber_comparer_type() = default; - uber_comparer_type(const Compare& c) : Compare(c) {} - - bool operator()(const Key& l, const Key& r) const { - return Compare::operator()(l, r); - } - - bool operator()(const Key& l, typename Container::const_reference r) const { - return Compare::operator()(l, r.first); - } - - bool operator()(typename Container::const_reference l, const Key& r) const { - return Compare::operator()(l.first, r); - } - - bool operator()(typename Container::const_reference l, typename Container::const_reference r) const { - return Compare::operator()(l.first, r.first); - } - }; + class flat_map + : private detail::flat_map_compare< + typename Container::value_type, + Compare> + { + using base_type = detail::flat_map_compare< + typename Container::value_type, + Compare>; public: using key_type = Key; using mapped_type = Value; @@ -64,23 +87,21 @@ namespace flat_hpp using reverse_iterator = typename Container::reverse_iterator; using const_reverse_iterator = typename Container::const_reverse_iterator; - class value_compare { + class value_compare : private key_compare { public: bool operator()(const value_type& l, const value_type& r) const { - return compare_(l.first, r.first); + return key_compare::operator()(l.first, r.first); } protected: friend class flat_map; explicit value_compare(key_compare compare) - : compare_(std::move(compare)) {} - private: - key_compare compare_; + : key_compare(std::move(compare)) {} }; public: flat_map() {} explicit flat_map(const Compare& c) - : compare_(c) {} + : base_type(c) {} template < typename Allocator > explicit flat_map(const Allocator& a) @@ -88,8 +109,8 @@ namespace flat_hpp template < typename Allocator > flat_map(const Compare& c, const Allocator& a) - : data_(a) - , compare_(c) {} + : base_type(c) + , data_(a) {} template < typename InputIter > flat_map(InputIter first, InputIter last) { @@ -98,7 +119,7 @@ namespace flat_hpp template < typename InputIter > flat_map(InputIter first, InputIter last, const Compare& c) - : compare_(c) { + : base_type(c) { insert(first, last); } @@ -110,8 +131,8 @@ namespace flat_hpp template < typename InputIter , typename Allocator > flat_map(InputIter first, InputIter last, const Compare& c, const Allocator& a) - : data_(a) - , compare_(c) { + : base_type(c) + , data_(a) { insert(first, last); } @@ -120,7 +141,7 @@ namespace flat_hpp } flat_map(std::initializer_list ilist, const Compare& c) - : compare_(c) { + : base_type(c) { insert(ilist); } @@ -132,20 +153,20 @@ namespace flat_hpp template < typename Allocator > flat_map(std::initializer_list ilist, const Compare& c, const Allocator& a) - : data_(a) - , compare_(c) { + : base_type(c) + , data_(a) { insert(ilist); } template < typename Allocator > flat_map(flat_map&& other, const Allocator& a) - : data_(std::move(other.data_), a) - , compare_(std::move(other.compare_)) {} + : base_type(static_cast(other)) + , data_(std::move(other.data_), a) {} template < typename Allocator > flat_map(const flat_map& other, const Allocator& a) - : data_(other.data_, a) - , compare_(other.compare_) {} + : base_type(static_cast(other)) + , data_(other.data_, a) {} flat_map(flat_map&& other) = default; flat_map(const flat_map& other) = default; @@ -230,28 +251,28 @@ namespace flat_hpp std::pair insert(value_type&& value) { const iterator iter = lower_bound(value.first); - return iter == end() || compare_(value, *iter) + return iter == end() || this->operator()(value, *iter) ? std::make_pair(data_.insert(iter, std::move(value)), true) : std::make_pair(iter, false); } std::pair insert(const value_type& value) { const iterator iter = lower_bound(value.first); - return iter == end() || compare_(value, *iter) + return iter == end() || this->operator()(value, *iter) ? std::make_pair(data_.insert(iter, value), true) : std::make_pair(iter, false); } iterator insert(const_iterator hint, value_type&& value) { - return (hint == begin() || compare_(*(hint - 1), value)) - && (hint == end() || compare_(value, *hint)) + return (hint == begin() || this->operator()(*(hint - 1), value)) + && (hint == end() || this->operator()(value, *hint)) ? data_.insert(hint, std::move(value)) : insert(std::move(value)).first; } iterator insert(const_iterator hint, const value_type& value) { - return (hint == begin() || compare_(*(hint - 1), value)) - && (hint == end() || compare_(value, *hint)) + return (hint == begin() || this->operator()(*(hint - 1), value)) + && (hint == end() || this->operator()(value, *hint)) ? data_.insert(hint, value) : insert(value).first; } @@ -298,8 +319,10 @@ namespace flat_hpp void swap(flat_map& other) { using std::swap; + swap( + static_cast(*this), + static_cast(other)); swap(data_, other.data_); - swap(compare_, other.compare_); } size_type count(const key_type& key) const { @@ -309,52 +332,57 @@ namespace flat_hpp iterator find(const key_type& key) { const iterator iter = lower_bound(key); - return iter != end() && !compare_(key, iter->first) + return iter != end() && !this->operator()(key, iter->first) ? iter : end(); } const_iterator find(const key_type& key) const { const const_iterator iter = lower_bound(key); - return iter != end() && !compare_(key, iter->first) + return iter != end() && !this->operator()(key, iter->first) ? iter : end(); } std::pair equal_range(const key_type& key) { - return std::equal_range(begin(), end(), key, compare_); + const base_type& comp = *this; + return std::equal_range(begin(), end(), key, comp); } std::pair equal_range(const key_type& key) const { - return std::equal_range(begin(), end(), key, compare_); + const base_type& comp = *this; + return std::equal_range(begin(), end(), key, comp); } iterator lower_bound(const key_type& key) { - return std::lower_bound(begin(), end(), key, compare_); + const base_type& comp = *this; + return std::lower_bound(begin(), end(), key, comp); } const_iterator lower_bound(const key_type& key) const { - return std::lower_bound(begin(), end(), key, compare_); + const base_type& comp = *this; + return std::lower_bound(begin(), end(), key, comp); } iterator upper_bound(const key_type& key) { - return std::upper_bound(begin(), end(), key, compare_); + const base_type& comp = *this; + return std::upper_bound(begin(), end(), key, comp); } const_iterator upper_bound(const key_type& key) const { - return std::upper_bound(begin(), end(), key, compare_); + const base_type& comp = *this; + return std::upper_bound(begin(), end(), key, comp); } key_compare key_comp() const { - return compare_; + return *this; } value_compare value_comp() const { - return value_compare(compare_); + return value_compare(key_comp()); } private: container_type data_; - uber_comparer_type compare_; }; } diff --git a/untests/flat_map_tests.cpp b/untests/flat_map_tests.cpp index eacca10..8e79f08 100644 --- a/untests/flat_map_tests.cpp +++ b/untests/flat_map_tests.cpp @@ -70,6 +70,16 @@ namespace return !(l == r); } + template < typename T > + class dummy_less { + public: + dummy_less(int i) : i(i) {} + bool operator()(const T& l, const T& r) const { + return l < r; + } + int i = 0; + }; + template < typename T > constexpr std::add_const_t& my_as_const(T& t) noexcept { return t; @@ -77,6 +87,14 @@ namespace } TEST_CASE("flat_map") { + SECTION("sizeof") { + REQUIRE(sizeof(flat_map) == sizeof(std::vector>)); + + struct vc : flat_map::value_compare { + int i; + }; + REQUIRE(sizeof(vc) == sizeof(int)); + } SECTION("types") { using map_t = flat_map; @@ -416,6 +434,16 @@ TEST_CASE("flat_map") { REQUIRE(my_as_const(s0).key_comp().i == 42); REQUIRE(my_as_const(s0).value_comp()({2,50},{4,20})); } + SECTION("custom_less") { + using map_t = flat_map>; + auto s0 = map_t(dummy_less(42)); + auto s1 = map_t(dummy_less(21)); + REQUIRE(s0.key_comp().i == 42); + REQUIRE(s1.key_comp().i == 21); + s0.swap(s1); + REQUIRE(s0.key_comp().i == 21); + REQUIRE(s1.key_comp().i == 42); + } SECTION("operators") { using map_t = flat_map;