container_template_functions.hpp

Go to the documentation of this file.

#pragma once
#include <algorithm>
#include <list>
#include <map>
#include <set>
#include <vector>

namespace derecho {

template <typename T>
std::set<T> functional_insert(std::set<T>& a, const std::set<T>& b) {
    a.insert(b.begin(), b.end());
    return a;
}

template <typename T>
std::vector<T> functional_append(const std::vector<T>& original, const T& item) {
    std::vector<T> appended_vec(original);
    appended_vec.emplace_back(item);
    return appended_vec;
}

template <typename T, typename... RestArgs>
std::vector<T> functional_append(const std::vector<T>& original, const T& first_item, RestArgs... rest_items) {
    std::vector<T> appended_vec = functional_append(original, first_item);
    return functional_append(appended_vec, rest_items...);
}

template <typename K1, typename K2, typename V>
std::size_t multimap_size(const std::map<K1, std::map<K2, V>>& multimap) {
    std::size_t count = 0;
    for(const auto& map_pair : multimap) {
        count += map_pair.second.size();
    }
    return count;
}

template <typename K, typename V>
std::list<K> keys_as_list(const std::map<K, V>& map) {
    std::list<K> keys;
    for(const auto& pair : map) {
        keys.emplace_back(pair.first);
    }
    return keys;
}

template <typename Container>
std::size_t index_of(const Container& container, const typename Container::value_type& elem) {
    return std::distance(std::begin(container),
                         std::find(std::begin(container),
                                   std::end(container), elem));
}

}  // namespace derecho