How to determine whether a C++ template parameter stores unique keys? - c++

Question

I'm working on some custom algorithm optimization, using containers.
My algorithms need to support all standard containers, as well as custom containers.
Right now, I'm working on making this algorithm work with set containers.
(Set containers require special handling, since individual elements are always const.)
The problem is, I need to separate the code paths, based on whether the set container stores unique keys.
(Unique keys obviously necessitate changes to the algorithm.)
Does the C++ standard library provide any conditional templates that can do this?
(Similar to std::is_signed_v)
Or is there another way to make this determination?
template < typename _SET_T >
void foo ( )
{
if ( unique keys ) // e.g. if _SET_T is a std::set or std::unordered_set
{
// optimize algorithm to account for uniqueness of keys
}
else // e.g. if _SET_T is a std::multiset or std::unordered_multiset
{
// optimize algorithm to account for NON-uniqueness of keys
}
}

Answer 1

There's no such concept and/or trait in the standard library, you'll have to write your own:
template <class T>
struct has_unique_keys : std::false_type {};
template <class... P>
struct has_unique_keys<std::set<P...>> : std::true_type {};
template <class... P>
struct has_unique_keys<std::map<P...>> : std::true_type {};
// ...
The base case makes the assumption that the keys are not unique because I suppose that the unique-keys-expecting algorithm would fail on multiple-keys containers, while the other way around would merely be slower.

Answer 2

You could do it by introducing your own traits and a little indirection.
Example Code
#include <iostream>
#include <set>
#include <unordered_set>
template<typename T>
struct HasUniqueKeys : std::true_type
{
};
template<typename T>
struct HasUniqueKeys<std::multiset<T>> : std::false_type
{
};
template<typename T>
struct HasUniqueKeys<std::unordered_multiset<T>> : std::false_type
{
};
template<bool HasUniqueKeys>
struct FooHelper
{
static void foo()
{
std::cout << "foo(multi_keys)\n";
}
};
template<>
struct FooHelper<true>
{
static void foo()
{
std::cout << "foo(unique_keys)\n";
}
};
template<typename T>
void foo(T keys)
{
FooHelper<HasUniqueKeys<T>::value>::foo();
}
int main()
{
std::set<int> set;
std::unordered_set<int> uset;
std::multiset<int> mset;
std::unordered_multiset<int> umset;
foo(set);
foo(uset);
foo(mset);
foo(umset);
return 0;
}
Example Output
foo(unique_keys)
foo(unique_keys)
foo(multi_keys)
foo(multi_keys)
Live Example