Bidirectional unordered map for trivial types, including string literals; could be efficiently used as a unordered non-bidirectional map. More...

#include <userver/utils/trivial_map.hpp>

Public Types
using	First = typename TypesPair::first_type

using	Second = typename TypesPair::second_type

template<class T >
using	MappedTypeFor = std::conditional_t< std::is_convertible_v< T, First >, Second, First >

Public Member Functions
constexpr	TrivialBiMap (BuilderFunc &&func) noexcept

constexpr std::optional< Second >	TryFindByFirst (First value) const noexcept

constexpr std::optional< First >	TryFindBySecond (Second value) const noexcept

template<class T >
constexpr std::optional< MappedTypeFor< T > >	TryFind (T value) const noexcept

constexpr std::optional< Second >	TryFindICaseByFirst (std::string_view value) const noexcept
	Case insensitive search for value.

constexpr std::optional< First >	TryFindICaseBySecond (std::string_view value) const noexcept
	Case insensitive search for value.

constexpr std::optional< MappedTypeFor< std::string_view > >	TryFindICase (std::string_view value) const noexcept
	Case insensitive search for value that calls either TryFindICaseBySecond or TryFindICaseByFirst.

constexpr std::size_t	size () const noexcept
	Returns count of Case's in mapping.

std::string	Describe () const

std::string	DescribeFirst () const

std::string	DescribeSecond () const

template<typename T >
std::string	DescribeByType () const

Detailed Description

template<typename BuilderFunc>
class utils::TrivialBiMap< BuilderFunc >

Bidirectional unordered map for trivial types, including string literals; could be efficiently used as a unordered non-bidirectional map.

constexpr utils::TrivialBiMap kToInt = [](auto selector) {
  return selector()
      .Case("zero", 0)
      .Case("one", 1)
      .Case("two", 2)
      .Case("three", 3)
      .Case("four", 4);
};
 
TEST(TrivialBiMap, StringBasic) {
  EXPECT_FALSE(kToInt.TryFind(42));
 
  EXPECT_EQ(kToInt.TryFind("one").value(), 1);
  EXPECT_EQ(kToInt.TryFind(2).value(), "two");
 
  EXPECT_EQ(kToInt.TryFind("ten").value_or(-1), -1);
}

utils::TrivialBiMap and utils::TrivialSet are known to outperform std::unordered_map if:

there's 32 or less elements in map/set
or keys are string literals and all of them differ in length.

Implementation of string search is very efficient due to modern compilers optimize it to a switch by input string length and an integral comparison (rather than a std::memcmp call). In other words, it usually takes O(1) to find the match in the map.

The same story with integral or enum mappings - compiler optimizes them into a switch and it usually takes O(1) to find the match.

enum class Colors { kRed, kOrange, kYellow, kGreen, kBlue, kViolet };
enum ThirdPartyColor { kGreen, kBlue, kViolet, kRed, kOrange, kYellow };
 
constexpr utils::TrivialBiMap kColorSwitch = [](auto selector) {
  return selector()
      .Case(ThirdPartyColor::kRed, Colors::kRed)
      .Case(ThirdPartyColor::kOrange, Colors::kOrange)
      .Case(ThirdPartyColor::kYellow, Colors::kYellow)
      .Case(ThirdPartyColor::kGreen, Colors::kGreen)
      .Case(ThirdPartyColor::kBlue, Colors::kBlue)
      .Case(ThirdPartyColor::kViolet, Colors::kViolet);
};
 
TEST(TrivialBiMap, EnumToEnum) {
  EXPECT_EQ(kColorSwitch.TryFind(ThirdPartyColor::kRed).value(), Colors::kRed);
  EXPECT_EQ(kColorSwitch.TryFind(ThirdPartyColor::kBlue).value(),
            Colors::kBlue);
 
  EXPECT_EQ(kColorSwitch.TryFind(Colors::kGreen).value(),
            ThirdPartyColor::kGreen);
  EXPECT_EQ(kColorSwitch.TryFind(Colors::kOrange).value(),
            ThirdPartyColor::kOrange);
}

For a single value Case statements see utils::TrivialSet.

Definition at line 487 of file trivial_map.hpp.

Public Types

Public Member Functions

Detailed Description

Member Typedef Documentation

◆ First

◆ MappedTypeFor

◆ Second

Constructor & Destructor Documentation

◆ TrivialBiMap()

Member Function Documentation

◆ Describe()

◆ DescribeByType()

◆ DescribeFirst()

◆ DescribeSecond()

◆ size()

◆ TryFind()

◆ TryFindByFirst()

◆ TryFindBySecond()

◆ TryFindICase()

◆ TryFindICaseByFirst()

◆ TryFindICaseBySecond()