#include <type_traits>
#include <algorithm>
#include <vector>
#include <iostream>
namespace sort_selector {
// Default to using std::sort
template <typename T, typename = void>
struct dispatcher {
template <typename Iterator>
static void sort(Iterator begin, Iterator end) {
std::cout << "Doing std::sort\n";
std::sort(begin, end);
}
};
// Use custom radix sort implementation for integral types
template <typename T>
struct dispatcher<T, typename std::enable_if<std::is_integral<T>::value>::type> {
template <typename Iterator>
static void sort(Iterator, Iterator) {
std::cout << "Doing radix\n";
// radix implementation
}
};
// Use some other specific stuff for int32_t
template <>
struct dispatcher<int32_t, void> {
template <typename Iterator>
static void sort(Iterator, Iterator) {
std::cout << "Specific overload for int32_t\n";
// Do something
}
};
// Dispatch appropriately
template <typename Iterator>
inline void sort(Iterator begin, Iterator end) {
dispatcher<typename std::iterator_traits<Iterator>::value_type>::sort(begin, end);
}
} // namespace sort_selector
int main() {
std::vector<double> for_stdsort = {1, 4, 6, 2};
std::vector<int64_t> for_radixsort = {1, 4, 6, 2};
std::array<int32_t, 4> array_for_radixsort = {1, 4, 6, 2};
sort_selector::sort(std::begin(for_stdsort), std::end(for_stdsort));
sort_selector::sort(std::begin(for_radixsort), std::end(for_radixsort));
sort_selector::sort(std::begin(array_for_radixsort), std::end(array_for_radixsort));
}
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