Algorithms.h

Go to the documentation of this file.

#pragma once
#include <algorithm>
#include <numeric>
#include <Base/Type.h>
 
 
namespace Base
{
template <class InputIt, class OutputIt, class Pred, class Fct>
void transform_if(InputIt first, InputIt last, OutputIt dest, Pred pred, Fct transform)
{
    while (first != last)
    {
        if (pred(*first))
            *dest++ = transform(*first);
        else
            *dest++ = *first;
 
        ++first;
    }
}
 
template <class Cont, class OutputIt, class Pred, class Fct>
void transform_if(Cont container, OutputIt dest, Pred pred, Fct transform)
{
    transform_if(container.cbegin(), container.cend(), dest, pred, transform);
}
 
template <typename Container, typename OutputIt, typename BinaryFunction>
void transform(Container container, OutputIt out, BinaryFunction function)
{
    std::transform(container.cbegin(), container.cend(), out, function);
}
 
template <typename Container, typename T, typename BinaryFunction>
T accumulate(Container container, T init, BinaryFunction function)
{
    return std::accumulate(container.cbegin(), container.cend(), init, function);
}
 
 
// usage: when we need const std::vector<App::Element*>&, but we have std::vector<App::Wall*> walls, we can use Base::castToBaseContainer<App::Element>(walls);
template <typename To, template <typename...> class Cont, typename FromPtr>
const Cont<To*>& castToBaseContainer(const Cont<FromPtr>& v)
{
    static_assert(std::is_pointer<FromPtr>(), "FromPtr is not a pointer");
    static_assert(std::is_base_of<To, std::remove_pointer_t<FromPtr>>(), "From is not derived from To");
 
    return *reinterpret_cast<const Cont<To*>*>(&v);
}
 
template <typename To, template <typename...> class Cont, typename FromPtr>
Cont<To*>& castToBaseContainer(Cont<FromPtr>& v)
{
    static_assert(std::is_pointer<FromPtr>(), "FromPtr is not a pointer");
    static_assert(std::is_base_of<To, std::remove_pointer_t<FromPtr>>(), "From is not derived from To");
 
    return *reinterpret_cast<Cont<To*>*>(&v);
}
 
 
template <typename Val, typename Cont>
bool allSubtype(const Cont& cont)
{
    return all_of(begin(cont), end(cont), [](auto val) { return dynamic_cast<Val>(val) != nullptr; });
}
 
template <typename BaseClass, template <typename...> class Cont, typename... Derivates>
bool isAnyDerivedFrom(const Cont<BaseClass*>& container)
{
    return std::any_of(begin(container),end(container), [](const auto v) { return ((dynamic_cast<Derivates*>(v) != nullptr) || ...); });
}
 
}