Templates.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2017 Louis Langholtz https://github.com/louis-langholtz/PlayRho
 *
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */
 
#ifndef PLAYRHO_COMMON_TEMPLATES_HPP
#define PLAYRHO_COMMON_TEMPLATES_HPP
 
#include <PlayRho/Defines.hpp>
 
#include <algorithm>
#include <functional>
#include <iterator>
#include <limits>
#include <typeinfo>
#include <type_traits>
#include <tuple>
#include <utility>
 
namespace playrho {
 
// Bring standard customization points into the namespace...
using std::begin;
using std::end;
using std::cbegin;
using std::cend;
using std::size;
using std::empty;
using std::data;
using std::swap;
 
namespace detail {
 
template<class...> struct Voidify {
    using type = void;
};
 
template<class... Ts> using VoidT = typename Voidify<Ts...>::type;
 
template<class T, class = void>
struct IsIterableImpl: std::false_type {};
 
template<class T>
struct IsIterableImpl<T, VoidT<
    decltype(begin(std::declval<T>())),
    decltype(end(std::declval<T>())),
    decltype(++std::declval<decltype(begin(std::declval<T&>()))&>()),
    decltype(*begin(std::declval<T>()))
    >>:
    std::true_type
{};
 
template <class T>
PLAYRHO_CONSTEXPR inline auto max_size(const T& arg) -> decltype(arg.max_size())
{
    return arg.max_size();
}
 
template <class T>
PLAYRHO_CONSTEXPR inline auto IsFull(const T& arg) -> decltype(size(arg) == max_size(arg))
{
    return size(arg) == max_size(arg);
}
 
template <typename T>
static auto Data(T& v)
{
    using ::playrho::data;
    return data(v);
}
 
template <typename T>
static auto Size(T& v)
{
    using ::playrho::size;
    return size(v);
}
 
} // namespace detail
    
    template<class... T> void NOT_USED(T&&...){}
 
    template <typename T>
    PLAYRHO_CONSTEXPR inline T GetInvalid() noexcept
    {
        static_assert(sizeof(T) == 0, "No available specialization");
    }
 
    template <typename T>
    PLAYRHO_CONSTEXPR inline bool IsValid(const T& value) noexcept
    {
        // Note: This is not necessarily a no-op!! But it is a "PLAYRHO_CONSTEXPR inline".
        //
        // From http://en.cppreference.com/w/cpp/numeric/math/isnan:
        //   "Another way to test if a floating-point value is NaN is
        //    to compare it with itself:
        //      bool is_nan(double x) { return x != x; }
        //
        // So for all T, for which isnan() is implemented, this should work
        // correctly and quite usefully!
        //
        return value == value;
    }
 
    // GetInvalid template specializations.
    
    template <>
    PLAYRHO_CONSTEXPR inline float GetInvalid() noexcept
    {
        return std::numeric_limits<float>::signaling_NaN();
    }
    
    template <>
    PLAYRHO_CONSTEXPR inline double GetInvalid() noexcept
    {
        return std::numeric_limits<double>::signaling_NaN();
    }
    
    template <>
    PLAYRHO_CONSTEXPR inline long double GetInvalid() noexcept
    {
        return std::numeric_limits<long double>::signaling_NaN();
    }
    
    template <>
    PLAYRHO_CONSTEXPR inline std::size_t GetInvalid() noexcept
    {
        return static_cast<std::size_t>(-1);
    }
    
    // IsValid template specializations.
    
    template <>
    PLAYRHO_CONSTEXPR inline bool IsValid(const std::size_t& value) noexcept
    {
        return value != GetInvalid<std::size_t>();
    }
    
    // Other templates.
    
    template <class T>
    PLAYRHO_CONSTEXPR const T* GetPtr(const T* value) noexcept
    {
        return value;
    }
    
    template <class T>
    PLAYRHO_CONSTEXPR inline T* GetPtr(T* value) noexcept
    {
        return value;
    }
    
    template <class T>
    PLAYRHO_CONSTEXPR const T* GetPtr(const T& value) noexcept
    {
        return &value;
    }
    
    template <class T>
    PLAYRHO_CONSTEXPR inline T* GetPtr(T& value) noexcept
    {
        return &value;
    }
 
    template <class T>
    PLAYRHO_CONSTEXPR const T& GetRef(const T* value) noexcept
    {
        return *value;
    }
    
    template <class T>
    PLAYRHO_CONSTEXPR inline T& GetRef(T* value) noexcept
    {
        return *value;
    }
    
    template <class T>
    PLAYRHO_CONSTEXPR const T& GetRef(const T& value) noexcept
    {
        return value;
    }
    
    template <class T>
    PLAYRHO_CONSTEXPR inline T& GetRef(T& value) noexcept
    {
        return value;
    }
    
    template <typename T>
    bool Visit(const T& /*object*/, void* /*userData*/)
    {
        return false;
    }
    
    template <typename T>
    inline const char* GetTypeName() noexcept
    {
        // No gaurantee of what the following returns. Could be mangled!
        // See http://en.cppreference.com/w/cpp/types/type_info/name
        return typeid(T).name();
    }
    
    template <>
    inline const char* GetTypeName<float>() noexcept
    {
        return "float";
    }
    
    template <>
    inline const char* GetTypeName<double>() noexcept
    {
        return "double";
    }
    
    template <>
    inline const char* GetTypeName<long double>() noexcept
    {
        return "long double";
    }
    
    template<class T1, class T2, class = void>
    struct IsEqualityComparable: std::false_type {};
    
    template<class T1, class T2>
    struct IsEqualityComparable<T1, T2, detail::VoidT<decltype(T1{} == T2{})> >: std::true_type {};
    
    template<class T1, class T2, class = void>
    struct IsInequalityComparable: std::false_type {};
    
    template<class T1, class T2>
    struct IsInequalityComparable<T1, T2, detail::VoidT<decltype(T1{} != T2{})> >: std::true_type {};
 
    template<class T1, class T2 = T1, class = void>
    struct IsAddable: std::false_type {};
    
    template<class T1, class T2>
    struct IsAddable<T1, T2, detail::VoidT<decltype(T1{} + T2{})> >: std::true_type {};
 
    template<class T1, class T2, class = void>
    struct IsMultipliable: std::false_type {};
    
    template<class T1, class T2>
    struct IsMultipliable<T1, T2, detail::VoidT<decltype(T1{} * T2{})> >: std::true_type {};
    
    template<class T1, class T2, class = void>
    struct IsDivisable: std::false_type {};
    
    template<class T1, class T2>
    struct IsDivisable<T1, T2, detail::VoidT<decltype(T1{} / T2{})> >: std::true_type {};
 
    template<class T, class = void>
    struct IsArithmetic: std::false_type {};
    
    template<class T>
    struct IsArithmetic<T, detail::VoidT<
        decltype(T{} + T{}), decltype(T{} - T{}), decltype(T{} * T{}), decltype(T{} / T{})
    > >: std::true_type {};
    
    template<class T>
    using IsIterable = typename detail::IsIterableImpl<T>;
 
    template <typename T, typename Tuple>
    struct HasType;
    
    template <typename T>
    struct HasType<T, std::tuple<>> : std::false_type {};
    
    template <typename T, typename... Ts>
    struct HasType<T, std::tuple<T, Ts...>> : std::true_type {};
    
    template <typename T, typename U, typename... Ts>
    struct HasType<T, std::tuple<U, Ts...>> : HasType<T, std::tuple<Ts...>> {};
 
    template <typename T, typename Tuple>
    using TupleContainsType = typename HasType<T, Tuple>::type;
    
    using detail::max_size;
    
    using detail::IsFull;
 
    template <typename T>
    struct LexicographicalLess
    {
        constexpr bool operator()(const T& lhs, const T& rhs) const
        {
            using std::less;
            using ElementType = decltype(*begin(lhs));
            return std::lexicographical_compare(begin(lhs), end(lhs), begin(rhs), end(rhs),
                                                less<ElementType>{});
        }
    };
    
    template <typename T>
    struct LexicographicalGreater
    {
        constexpr bool operator()(const T& lhs, const T& rhs) const
        {
            using std::greater;
            using ElementType = decltype(*begin(lhs));
            return std::lexicographical_compare(begin(lhs), end(lhs), begin(rhs), end(rhs),
                                                greater<ElementType>{});
        }
    };
 
    template <typename T>
    struct LexicographicalLessEqual
    {
        constexpr bool operator()(const T& lhs, const T& rhs) const
        {
            using std::mismatch;
            using std::less;
            using std::get;
            using ElementType = decltype(*begin(lhs));
            const auto lhsEnd = end(lhs);
            const auto diff = mismatch(begin(lhs), lhsEnd, begin(rhs), end(rhs));
            return (get<0>(diff) == lhsEnd) || less<ElementType>{}(*get<0>(diff), *get<1>(diff));
        }
    };
 
    template <typename T>
    struct LexicographicalGreaterEqual
    {
        constexpr bool operator()(const T& lhs, const T& rhs) const
        {
            using std::mismatch;
            using std::greater;
            using std::get;
            using ElementType = decltype(*begin(lhs));
            const auto lhsEnd = end(lhs);
            const auto diff = mismatch(begin(lhs), lhsEnd, begin(rhs), end(rhs));
            return (get<0>(diff) == lhsEnd) || greater<ElementType>{}(*get<0>(diff), *get<1>(diff));
        }
    };
 
} // namespace playrho
 
#endif // PLAYRHO_COMMON_TEMPLATES_HPP