functional.h

Go to the documentation of this file.

#ifndef FPMAS_FUNCTIONAL_H
#define FPMAS_FUNCTIONAL_H
 
#include <utility>
#include <functional>
#include <vector>
#include <unordered_map>
#include <map>
#include <set>
 
namespace fpmas { namespace utils {
 
    namespace detail {
        template<typename Container>
            struct Concat {
            };
 
        template<typename T, typename Alloc>
            struct Concat<std::vector<T, Alloc>> {
                static std::vector<T, Alloc> concat(
                        std::vector<T, Alloc>& init, const std::vector<T, Alloc>& c) {
                    init.insert(init.end(), c.begin(), c.end());
                    return std::move(init);
                }
            };
 
        template<typename T, typename Comp, typename Alloc>
            struct Concat<std::set<T, Comp, Alloc>> {
                static std::set<T, Comp, Alloc> concat(
                        std::set<T, Comp, Alloc>& init,
                        const std::set<T, Comp, Alloc>& c) {
                    init.insert(c.begin(), c.end());
                    return std::move(init);
                }
            };
 
        template<typename K, typename T, typename Comp, typename Alloc>
            struct Concat<std::map<K, T, Comp, Alloc>> {
                static std::map<K, T, Comp, Alloc> concat(
                        std::map<K, T, Comp, Alloc>& init,
                        const std::map<K, T, Comp, Alloc>& c
                        ) {
                    init.insert(c.begin(), c.end());
                    return std::move(init);
                }
            };
 
        template<typename K, typename T, typename Hash, typename KeyEq, typename Alloc>
            struct Concat<std::unordered_map<K, T, Hash, KeyEq, Alloc>> {
                static std::unordered_map<K, T, Hash, KeyEq, Alloc> concat(
                        std::unordered_map<K, T, Hash, KeyEq, Alloc>& init,
                        const std::unordered_map<K, T, Hash, KeyEq, Alloc>& c
                        ) {
                    init.insert(c.begin(), c.end());
                    return std::move(init);
                }
            };
    }
 
    struct Concat {
        template<typename Container>
            Container operator()(Container& init, const Container& c) const {
                return detail::Concat<Container>::concat(init, c);
            }
    };
 
    template<typename T, typename Compare = std::less<T>>
        struct Max {
            T operator()(const T& a, const T& b) {
                return std::max(a, b, Compare());
            }
        };
    template<typename T, typename Compare = std::less<T>>
        struct Min {
            T operator()(const T& a, const T& b) {
                return std::min(a, b, Compare());
            }
        };
}}
#endif