louis-langholtz / PlayRho / 680

Committed 18 Oct 2020 12:46AM UTC coverage: 94.373% (-4.6%) from 98.937%

Build # 680

Build Type

Pull #346

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/louis-langholtz/PlayRho/commit/<a class=hub.com/louis-langholtz/PlayRho/commit/815feb9048875b899701114aa1c07cca4071a79a">815feb904<a href="https://github.com/louis-langholtz/PlayRho/commit/815feb9048875b899701114aa1c07cca4071a79a">">Merge </a><a class="double-link" href="https://github.com/louis-langholtz/PlayRho/commit/<a class="double-link" href="https://github.com/louis-langholtz/PlayRho/commit/9d90d9eaa07bac134ed7256f312ad62ea9676aac">9d90d9eaa</a>">9d90d9eaa</a><a href="https://github.com/louis-langholtz/PlayRho/commit/815feb9048875b899701114aa1c07cca4071a79a"> into 8bc3ea52f">8bc3ea52f</a>

Pull Request Pull Request #346: Crazy train 20201012

Run Details

5643 of 5643 new or added lines in 81 files covered. (100.0%)

9963 of 10557 relevant lines covered (94.37%)

24639930.59 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.24

/PlayRho/Common/Templates.hpp

/*
 * 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 {

/// @brief Voiding template class.
template<class...> struct Voidify {
    /// @brief Type alias.
    using type = void;
};

/// @brief Void type templated alias.
template<class... Ts> using VoidT = typename Voidify<Ts...>::type;

/// @brief Low-level implementation of the is-iterable default value trait.
template<class T, class = void>
struct IsIterableImpl: std::false_type {};

/// @brief Low-level implementation of the is-iterable true value trait.
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
{};

/// @brief Gets the maximum size of the given container.
template <class T>
constexpr auto max_size(const T& arg) -> decltype(arg.max_size())
{
    return arg.max_size();
}

/// @brief Checks whether the given container is full.
template <class T>
constexpr auto IsFull(const T& arg) -> decltype(size(arg) == max_size(arg))
{
    return size(arg) == max_size(arg);
}

/// @brief Internal helper template function to avoid confusion for use within classes
///   that define their own <code>data()</code> method.
template <typename T>
static auto Data(T& v)
{
    using ::playrho::data;
    return data(v);
}

/// @brief Internal helper template function to avoid confusion for use within classes
///   that define their own <code>size()</code> method.
template <typename T>
static auto Size(T& v)
{
    using ::playrho::size;
    return size(v);
}

} // namespace detail
    
/// @brief "Not used" annotator.
template<class... T> void NOT_USED(T&&...){}

/// @brief Gets an invalid value for the type.
/// @tparam T Type to get an invalid value for.
/// @note Specialize this function for the types which have an invalid value concept.
/// @see IsValid.
template <typename T>
constexpr T GetInvalid() noexcept
{
    static_assert(sizeof(T) == 0, "No available specialization");
}

/// @brief Determines if the given value is valid.
/// @see GetInvalid.
template <typename T>
constexpr bool IsValid(const T& value) noexcept
{
    // Note: This is not necessarily a no-op!! But it is a "constexpr".
    //
    // 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.

/// @brief Gets an invalid value for the float type.
template <>
constexpr float GetInvalid() noexcept
{
    return std::numeric_limits<float>::signaling_NaN();
}

/// @brief Gets an invalid value for the double type.
template <>
constexpr double GetInvalid() noexcept
{
    return std::numeric_limits<double>::signaling_NaN();
}

/// @brief Gets an invalid value for the long double type.
template <>
constexpr long double GetInvalid() noexcept
{
    return std::numeric_limits<long double>::signaling_NaN();
}

/// @brief Gets an invalid value for the std::size_t type.
template <>
constexpr std::size_t GetInvalid() noexcept
{
    return static_cast<std::size_t>(-1);
}

// IsValid template specializations.

/// @brief Determines if the given value is valid.
template <>
constexpr bool IsValid(const std::size_t& value) noexcept
{
    return value != GetInvalid<std::size_t>();
}

// Other templates.

/// @brief Template function for visiting objects.
/// @note Specialize this function to tie in application specific handling for types
///   which don't already have specialized handling. Specializations should always
///   return <code>true</code>.
/// @note First parameter is the object to visit.
/// @note Second parameter is user data or the <code>nullptr</code>.
/// @see https://en.wikipedia.org/wiki/Visitor_pattern
template <typename T>
bool Visit(const T& /*object*/, void* /*userData*/)
{
    return false;
}

/// @brief Template for determining if the given type is an equality comparable type.
/// @note This isn't exactly the same as the "EqualityComparable" named requirement.
/// @see https://en.cppreference.com/w/cpp/named_req/EqualityComparable
template<class T1, class T2, class = void>
struct IsEqualityComparable: std::false_type {};

/// @brief Template specialization for equality comparable types.
template<class T1, class T2>
struct IsEqualityComparable<T1, T2, detail::VoidT<decltype(T1{} == T2{})> >: std::true_type {};

/// @brief Template for determining if the given type is an inequality comparable type.
template<class T1, class T2, class = void>
struct IsInequalityComparable: std::false_type {};

/// @brief Template specialization for inequality comparable types.
template<class T1, class T2>
struct IsInequalityComparable<T1, T2, detail::VoidT<decltype(T1{} != T2{})> >: std::true_type {};

/// @brief Template for determining if the given types are addable.
template<class T1, class T2 = T1, class = void>
struct IsAddable: std::false_type {};

/// @brief Template specializing for addable types.
template<class T1, class T2>
struct IsAddable<T1, T2, detail::VoidT<decltype(T1{} + T2{})> >: std::true_type {};

/// @brief Template for determining if the given types are multipliable.
template<class T1, class T2, class = void>
struct IsMultipliable: std::false_type {};

/// @brief Template specializing for multipliable types.
template<class T1, class T2>
struct IsMultipliable<T1, T2, detail::VoidT<decltype(T1{} * T2{})> >: std::true_type {};

/// @brief Template for determining if the given types are divisable.
template<class T1, class T2, class = void>
struct IsDivisable: std::false_type {};

/// @brief Template specializing for divisable types.
template<class T1, class T2>
struct IsDivisable<T1, T2, detail::VoidT<decltype(T1{} / T2{})> >: std::true_type {};

/// @brief Template for determining if the given type is an "arithmetic" type.
/// @note In the context of this library, "arithmetic" types are all types which
///   have +, -, *, / arithmetic operator support.
template<class T, class = void>
struct IsArithmetic: std::false_type {};

/// @brief Template specialization for valid/acceptable "arithmetic" types.
template<class T>
struct IsArithmetic<T, detail::VoidT<
    decltype(T{} + T{}), decltype(T{} - T{}), decltype(T{} * T{}), decltype(T{} / T{})
> >: std::true_type {};

/// @brief Determines whether the given type is an iterable type.
template<class T>
using IsIterable = typename detail::IsIterableImpl<T>;

/// @brief Has-type trait template class.
/// @note This is from Piotr Skotnicki's answer on the <em>StackOverflow</em> website
///   to the question of: "How do I find out if a tuple contains a type?".
/// @see https://stackoverflow.com/a/25958302/7410358
template <typename T, typename Tuple>
struct HasType;

/// @brief Has-type trait template class specialized for <code>std::tuple</code> classes.
/// @note This is from Piotr Skotnicki's answer on the <em>StackOverflow</em> website
///   to the question of: "How do I find out if a tuple contains a type?".
/// @see https://stackoverflow.com/a/25958302/7410358
template <typename T>
struct HasType<T, std::tuple<>> : std::false_type {};

/// @brief Has-type trait true class.
/// @note This is from Piotr Skotnicki's answer on the <em>StackOverflow</em> website
///   to the question of: "How do I find out if a tuple contains a type?".
/// @see https://stackoverflow.com/a/25958302/7410358
template <typename T, typename... Ts>
struct HasType<T, std::tuple<T, Ts...>> : std::true_type {};

/// @brief Has-type trait template super class.
/// @note This is from Piotr Skotnicki's answer on the <em>StackOverflow</em> website
///   to the question of: "How do I find out if a tuple contains a type?".
/// @see https://stackoverflow.com/a/25958302/7410358
template <typename T, typename U, typename... Ts>
struct HasType<T, std::tuple<U, Ts...>> : HasType<T, std::tuple<Ts...>> {};

/// @brief Tuple contains type alias.
/// @details Alias in case the trait itself should be <code>std::true_type</code> or
///   <code>std::false_type</code>.
/// @note This is from Piotr Skotnicki's answer on the <em>StackOverflow</em> website
///   to the question of: "How do I find out if a tuple contains a type?".
/// @see https://stackoverflow.com/a/25958302/7410358
template <typename T, typename Tuple>
using TupleContainsType = typename HasType<T, Tuple>::type;

/// @brief Alias for pulling the <code>max_size</code> constomization point into the
///   playrho namesapce.
using detail::max_size;

/// @brief Alias for pulling the <code>IsFull</code> constomization point into the
///   playrho namesapce.
using detail::IsFull;

/// @brief Function object for performing lexicographical less-than
///   comparisons of containers.
/// @see https://en.cppreference.com/w/cpp/algorithm/lexicographical_compare
/// @see https://en.cppreference.com/w/cpp/utility/functional/less
template <typename T>
struct LexicographicalLess
{
    /// @brief Checks whether the first argument is lexicographically less-than the
    ///   second argument.
    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>{});
    }
};

/// @brief Function object for performing lexicographical greater-than
///   comparisons of containers.
/// @see https://en.cppreference.com/w/cpp/algorithm/lexicographical_compare
/// @see https://en.cppreference.com/w/cpp/utility/functional/greater
template <typename T>
struct LexicographicalGreater
{
    /// @brief Checks whether the first argument is lexicographically greater-than the
    ///   second argument.
    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>{});
    }
};

/// @brief Function object for performing lexicographical less-than or equal-to
///   comparisons of containers.
/// @see https://en.cppreference.com/w/cpp/algorithm/lexicographical_compare
/// @see https://en.cppreference.com/w/cpp/utility/functional/less_equal
template <typename T>
struct LexicographicalLessEqual
{
    /// @brief Checks whether the first argument is lexicographically less-than or
    ///   equal-to the second argument.
    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));
    }
};

/// @brief Function object for performing lexicographical greater-than or equal-to
///   comparisons of containers.
/// @see https://en.cppreference.com/w/cpp/algorithm/lexicographical_compare
/// @see https://en.cppreference.com/w/cpp/utility/functional/greater_equal
template <typename T>
struct LexicographicalGreaterEqual
{
    /// @brief Checks whether the first argument is lexicographically greater-than or
    ///   equal-to the second argument.
    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));
    }
};

/// @brief Convenience template function for erasing first found value from container.
/// @return <code>true</code> if value was found and erased, <code>false</code> otherwise.
/// @see EraseAll.
template <typename T, typename U>
auto EraseFirst(T& container, const U& value) ->
    decltype(container.erase(find(begin(container), end(container), value)) != end(container))
{
    const auto endIt = end(container);
    const auto it = find(begin(container), endIt, value);
    if (it != endIt) {
        container.erase(it);
        return true;
    }
    return false;
}

/// @brief Convenience template function for erasing specified value from container.
/// @note This basically is the C++20 <code>std::erase</code> function.
/// @return Count of elements erased.
/// @see EraseFirst.
template <typename T, typename U>
auto EraseAll(T& container, const U& value) ->
    decltype(distance(container.erase(remove(begin(container), end(container), value), end(container)), end(container)))
{
    const auto itEnd = end(container);
    const auto it = remove(begin(container), itEnd, value);
    const auto count = distance(it, itEnd);
    container.erase(it, itEnd);
    return count;
}

/// @brief Has-functor trait template fallback class.
/// @note This is based off the answer by "jrok" on the <em>StackOverflow</em> website
///   to the question of: "Check if a class has a member function of a given signature".
/// @see https://stackoverflow.com/a/16824239/7410358
template <typename, typename T>
struct HasFunctor {
    static_assert(std::integral_constant<T, false>::value,
                  "Second template parameter needs to be of function type.");
};

/// @brief Has-functor trait template class.
/// @note This is based off the answer by "jrok" on the <em>StackOverflow</em> website
///   to the question of: "Check if a class has a member function of a given signature".
/// @see https://stackoverflow.com/a/16824239/7410358
template <typename Type, typename Return, typename... Args>
struct HasFunctor<Type, Return(Args...)> {
private:
    /// @brief Declaration of check function for supporting types given to template.
    template<typename T>
    static constexpr auto check(T*)
    -> typename std::is_same<decltype(std::declval<T>()(std::declval<Args>()...)),Return>::type;

    /// @brief Declaration of check function for non-supporting types given to template.
    template<typename>
    static constexpr std::false_type check(...);

    /// @brief Type alias for given template parameters.
    using type = decltype(check<Type>(0));

public:
    /// Whether or not the given type has the specified functor.
    static constexpr auto value = type::value;
};

/// @brief Has nullary functor type alias.
/// @see HasUnaryFunctor.
template <typename Type, typename Return>
using HasNullaryFunctor = HasFunctor<Type,Return()>;

/// @brief Has unary functor type alias.
/// @see HasNullaryFunctor.
template <typename Type, typename Return, typename Arg>
using HasUnaryFunctor = HasFunctor<Type,Return(Arg)>;

} // namespace playrho

#endif // PLAYRHO_COMMON_TEMPLATES_HPP

1	/*
2	* Copyright (c) 2017 Louis Langholtz https://github.com/louis-langholtz/PlayRho
3	*
4	* This software is provided 'as-is', without any express or implied
5	* warranty. In no event will the authors be held liable for any damages
6	* arising from the use of this software.
7	*
8	* Permission is granted to anyone to use this software for any purpose,
9	* including commercial applications, and to alter it and redistribute it
10	* freely, subject to the following restrictions:
11	*
12	* 1. The origin of this software must not be misrepresented; you must not
13	* claim that you wrote the original software. If you use this software
14	* in a product, an acknowledgment in the product documentation would be
15	* appreciated but is not required.
16	* 2. Altered source versions must be plainly marked as such, and must not be
17	* misrepresented as being the original software.
18	* 3. This notice may not be removed or altered from any source distribution.
19	*/
20
21	#ifndef PLAYRHO_COMMON_TEMPLATES_HPP
22	#define PLAYRHO_COMMON_TEMPLATES_HPP
23
24	#include <PlayRho/Defines.hpp>
25
26	#include <algorithm>
27	#include <functional>
28	#include <iterator>
29	#include <limits>
30	#include <typeinfo>
31	#include <type_traits>
32	#include <tuple>
33	#include <utility>
34
35	namespace playrho {
36
37	// Bring standard customization points into the namespace...
38	using std::begin;
39	using std::end;
40	using std::cbegin;
41	using std::cend;
42	using std::size;
43	using std::empty;
44	using std::data;
45	using std::swap;
46
47	namespace detail {
48
49	/// @brief Voiding template class.
50	template<class...> struct Voidify {
51	/// @brief Type alias.
52	using type = void;
53	};
54
55	/// @brief Void type templated alias.
56	template<class... Ts> using VoidT = typename Voidify<Ts...>::type;
57
58	/// @brief Low-level implementation of the is-iterable default value trait.
59	template<class T, class = void>
60	struct IsIterableImpl: std::false_type {};
61
62	/// @brief Low-level implementation of the is-iterable true value trait.
63	template<class T>
64	struct IsIterableImpl<T, VoidT<
65	decltype(begin(std::declval<T>())),
66	decltype(end(std::declval<T>())),
67	decltype(++std::declval<decltype(begin(std::declval<T&>()))&>()),
68	decltype(*begin(std::declval<T>()))
69	>>:
70	std::true_type
71	{};
72
73	/// @brief Gets the maximum size of the given container.
74	template <class T>
75	constexpr auto max_size(const T& arg) -> decltype(arg.max_size())	32,873,329✔
76	{
77	return arg.max_size();	32,873,329✔
78	}
79
80	/// @brief Checks whether the given container is full.
81	template <class T>
82	constexpr auto IsFull(const T& arg) -> decltype(size(arg) == max_size(arg))	32,873,323✔
83	{
84	return size(arg) == max_size(arg);	32,873,323✔
85	}
86
87	/// @brief Internal helper template function to avoid confusion for use within classes
88	/// that define their own <code>data()</code> method.
89	template <typename T>
90	static auto Data(T& v)	914✔
91	{
92	using ::playrho::data;
93	return data(v);	914✔
94	}
95
96	/// @brief Internal helper template function to avoid confusion for use within classes
97	/// that define their own <code>size()</code> method.
98	template <typename T>
99	static auto Size(T& v)	774✔
100	{
101	using ::playrho::size;
102	return size(v);	774✔
103	}
104
105	} // namespace detail
106
107	/// @brief "Not used" annotator.
108	template<class... T> void NOT_USED(T&&...){}	20,000✔
109
110	/// @brief Gets an invalid value for the type.
111	/// @tparam T Type to get an invalid value for.
112	/// @note Specialize this function for the types which have an invalid value concept.
113	/// @see IsValid.
114	template <typename T>
115	constexpr T GetInvalid() noexcept
116	{
117	static_assert(sizeof(T) == 0, "No available specialization");
118	}
119
120	/// @brief Determines if the given value is valid.
121	/// @see GetInvalid.
122	template <typename T>
123	constexpr bool IsValid(const T& value) noexcept	2,014,716,733✔
124	{
125	// Note: This is not necessarily a no-op!! But it is a "constexpr".
126	//
127	// From http://en.cppreference.com/w/cpp/numeric/math/isnan:
128	// "Another way to test if a floating-point value is NaN is
129	// to compare it with itself:
130	// bool is_nan(double x) { return x != x; }
131	//
132	// So for all T, for which isnan() is implemented, this should work
133	// correctly and quite usefully!
134	//
135	return value == value;	2,014,716,733✔
136	}
137
138	// GetInvalid template specializations.
139
140	/// @brief Gets an invalid value for the float type.
141	template <>
142	constexpr float GetInvalid() noexcept	9,111,230✔
143	{
144	return std::numeric_limits<float>::signaling_NaN();	9,111,230✔
145	}
146
147	/// @brief Gets an invalid value for the double type.
148	template <>
149	constexpr double GetInvalid() noexcept	9,214,478✔
150	{
151	return std::numeric_limits<double>::signaling_NaN();	9,214,478✔
152	}
153
154	/// @brief Gets an invalid value for the long double type.
155	template <>
156	constexpr long double GetInvalid() noexcept
157	{
158	return std::numeric_limits<long double>::signaling_NaN();
159	}
160
161	/// @brief Gets an invalid value for the std::size_t type.
162	template <>
163	constexpr std::size_t GetInvalid() noexcept	88✔
164	{
165	return static_cast<std::size_t>(-1);	88✔
166	}
167
168	// IsValid template specializations.
169
170	/// @brief Determines if the given value is valid.
171	template <>
172	constexpr bool IsValid(const std::size_t& value) noexcept
173	{
174	return value != GetInvalid<std::size_t>();
175	}
176
177	// Other templates.
178
179	/// @brief Template function for visiting objects.
180	/// @note Specialize this function to tie in application specific handling for types
181	/// which don't already have specialized handling. Specializations should always
182	/// return <code>true</code>.
183	/// @note First parameter is the object to visit.
184	/// @note Second parameter is user data or the <code>nullptr</code>.
185	/// @see https://en.wikipedia.org/wiki/Visitor_pattern
186	template <typename T>
187	bool Visit(const T& /object/, void* /userData/)	2✔
188	{
189	return false;	2✔
190	}
191
192	/// @brief Template for determining if the given type is an equality comparable type.
193	/// @note This isn't exactly the same as the "EqualityComparable" named requirement.
194	/// @see https://en.cppreference.com/w/cpp/named_req/EqualityComparable
195	template<class T1, class T2, class = void>
196	struct IsEqualityComparable: std::false_type {};
197
198	/// @brief Template specialization for equality comparable types.
199	template<class T1, class T2>
200	struct IsEqualityComparable<T1, T2, detail::VoidT<decltype(T1{} == T2{})> >: std::true_type {};
201
202	/// @brief Template for determining if the given type is an inequality comparable type.
203	template<class T1, class T2, class = void>
204	struct IsInequalityComparable: std::false_type {};
205
206	/// @brief Template specialization for inequality comparable types.
207	template<class T1, class T2>
208	struct IsInequalityComparable<T1, T2, detail::VoidT<decltype(T1{} != T2{})> >: std::true_type {};
209
210	/// @brief Template for determining if the given types are addable.
211	template<class T1, class T2 = T1, class = void>
212	struct IsAddable: std::false_type {};
213
214	/// @brief Template specializing for addable types.
215	template<class T1, class T2>
216	struct IsAddable<T1, T2, detail::VoidT<decltype(T1{} + T2{})> >: std::true_type {};
217
218	/// @brief Template for determining if the given types are multipliable.
219	template<class T1, class T2, class = void>
220	struct IsMultipliable: std::false_type {};
221
222	/// @brief Template specializing for multipliable types.
223	template<class T1, class T2>
224	struct IsMultipliable<T1, T2, detail::VoidT<decltype(T1{} * T2{})> >: std::true_type {};
225
226	/// @brief Template for determining if the given types are divisable.
227	template<class T1, class T2, class = void>
228	struct IsDivisable: std::false_type {};
229
230	/// @brief Template specializing for divisable types.
231	template<class T1, class T2>
232	struct IsDivisable<T1, T2, detail::VoidT<decltype(T1{} / T2{})> >: std::true_type {};
233
234	/// @brief Template for determining if the given type is an "arithmetic" type.
235	/// @note In the context of this library, "arithmetic" types are all types which
236	/// have +, -, *, / arithmetic operator support.
237	template<class T, class = void>
238	struct IsArithmetic: std::false_type {};
239
240	/// @brief Template specialization for valid/acceptable "arithmetic" types.
241	template<class T>
242	struct IsArithmetic<T, detail::VoidT<
243	decltype(T{} + T{}), decltype(T{} - T{}), decltype(T{} * T{}), decltype(T{} / T{})
244	> >: std::true_type {};
245
246	/// @brief Determines whether the given type is an iterable type.
247	template<class T>
248	using IsIterable = typename detail::IsIterableImpl<T>;
249
250	/// @brief Has-type trait template class.
251	/// @note This is from Piotr Skotnicki's answer on the <em>StackOverflow</em> website
252	/// to the question of: "How do I find out if a tuple contains a type?".
253	/// @see https://stackoverflow.com/a/25958302/7410358
254	template <typename T, typename Tuple>
255	struct HasType;
256
257	/// @brief Has-type trait template class specialized for <code>std::tuple</code> classes.
258	/// @note This is from Piotr Skotnicki's answer on the <em>StackOverflow</em> website
259	/// to the question of: "How do I find out if a tuple contains a type?".
260	/// @see https://stackoverflow.com/a/25958302/7410358
261	template <typename T>
262	struct HasType<T, std::tuple<>> : std::false_type {};
263
264	/// @brief Has-type trait true class.
265	/// @note This is from Piotr Skotnicki's answer on the <em>StackOverflow</em> website
266	/// to the question of: "How do I find out if a tuple contains a type?".
267	/// @see https://stackoverflow.com/a/25958302/7410358
268	template <typename T, typename... Ts>
269	struct HasType<T, std::tuple<T, Ts...>> : std::true_type {};
270
271	/// @brief Has-type trait template super class.
272	/// @note This is from Piotr Skotnicki's answer on the <em>StackOverflow</em> website
273	/// to the question of: "How do I find out if a tuple contains a type?".
274	/// @see https://stackoverflow.com/a/25958302/7410358
275	template <typename T, typename U, typename... Ts>
276	struct HasType<T, std::tuple<U, Ts...>> : HasType<T, std::tuple<Ts...>> {};
277
278	/// @brief Tuple contains type alias.
279	/// @details Alias in case the trait itself should be <code>std::true_type</code> or
280	/// <code>std::false_type</code>.
281	/// @note This is from Piotr Skotnicki's answer on the <em>StackOverflow</em> website
282	/// to the question of: "How do I find out if a tuple contains a type?".
283	/// @see https://stackoverflow.com/a/25958302/7410358
284	template <typename T, typename Tuple>
285	using TupleContainsType = typename HasType<T, Tuple>::type;
286
287	/// @brief Alias for pulling the <code>max_size</code> constomization point into the
288	/// playrho namesapce.
289	using detail::max_size;
290
291	/// @brief Alias for pulling the <code>IsFull</code> constomization point into the
292	/// playrho namesapce.
293	using detail::IsFull;
294
295	/// @brief Function object for performing lexicographical less-than
296	/// comparisons of containers.
297	/// @see https://en.cppreference.com/w/cpp/algorithm/lexicographical_compare
298	/// @see https://en.cppreference.com/w/cpp/utility/functional/less
299	template <typename T>
300	struct LexicographicalLess
301	{
302	/// @brief Checks whether the first argument is lexicographically less-than the
303	/// second argument.
304	constexpr bool operator()(const T& lhs, const T& rhs) const	70✔
305	{
306	using std::less;
307	using ElementType = decltype(*begin(lhs));
308	return std::lexicographical_compare(begin(lhs), end(lhs), begin(rhs), end(rhs),	70✔
309	less<ElementType>{});	70✔
310	}
311	};
312
313	/// @brief Function object for performing lexicographical greater-than
314	/// comparisons of containers.
315	/// @see https://en.cppreference.com/w/cpp/algorithm/lexicographical_compare
316	/// @see https://en.cppreference.com/w/cpp/utility/functional/greater
317	template <typename T>
318	struct LexicographicalGreater
319	{
320	/// @brief Checks whether the first argument is lexicographically greater-than the
321	/// second argument.
322	constexpr bool operator()(const T& lhs, const T& rhs) const	28✔
323	{
324	using std::greater;
325	using ElementType = decltype(*begin(lhs));
326	return std::lexicographical_compare(begin(lhs), end(lhs), begin(rhs), end(rhs),	28✔
327	greater<ElementType>{});	28✔
328	}
329	};
330
331	/// @brief Function object for performing lexicographical less-than or equal-to
332	/// comparisons of containers.
333	/// @see https://en.cppreference.com/w/cpp/algorithm/lexicographical_compare
334	/// @see https://en.cppreference.com/w/cpp/utility/functional/less_equal
335	template <typename T>
336	struct LexicographicalLessEqual
337	{
338	/// @brief Checks whether the first argument is lexicographically less-than or
339	/// equal-to the second argument.
340	constexpr bool operator()(const T& lhs, const T& rhs) const	28✔
341	{
342	using std::mismatch;
343	using std::less;
344	using std::get;
345	using ElementType = decltype(*begin(lhs));
346	const auto lhsEnd = end(lhs);	28✔
347	const auto diff = mismatch(begin(lhs), lhsEnd, begin(rhs), end(rhs));	28✔
348	return (get<0>(diff) == lhsEnd) \|\| less<ElementType>{}(get<0>(diff), get<1>(diff));	28✔
349	}
350	};
351
352	/// @brief Function object for performing lexicographical greater-than or equal-to
353	/// comparisons of containers.
354	/// @see https://en.cppreference.com/w/cpp/algorithm/lexicographical_compare
355	/// @see https://en.cppreference.com/w/cpp/utility/functional/greater_equal
356	template <typename T>
357	struct LexicographicalGreaterEqual
358	{
359	/// @brief Checks whether the first argument is lexicographically greater-than or
360	/// equal-to the second argument.
361	constexpr bool operator()(const T& lhs, const T& rhs) const	28✔
362	{
363	using std::mismatch;
364	using std::greater;
365	using std::get;
366	using ElementType = decltype(*begin(lhs));
367	const auto lhsEnd = end(lhs);	28✔
368	const auto diff = mismatch(begin(lhs), lhsEnd, begin(rhs), end(rhs));	28✔
369	return (get<0>(diff) == lhsEnd) \|\| greater<ElementType>{}(get<0>(diff), get<1>(diff));	28✔
370	}
371	};
372
373	/// @brief Convenience template function for erasing first found value from container.
374	/// @return <code>true</code> if value was found and erased, <code>false</code> otherwise.
375	/// @see EraseAll.
376	template <typename T, typename U>
377	auto EraseFirst(T& container, const U& value) ->	10✔
378	decltype(container.erase(find(begin(container), end(container), value)) != end(container))
379	{
380	const auto endIt = end(container);	10✔
381	const auto it = find(begin(container), endIt, value);	10✔
382	if (it != endIt) {	10✔
383	container.erase(it);	×
384	return true;	×
385	}
386	return false;	10✔
387	}
388
389	/// @brief Convenience template function for erasing specified value from container.
390	/// @note This basically is the C++20 <code>std::erase</code> function.
391	/// @return Count of elements erased.
392	/// @see EraseFirst.
393	template <typename T, typename U>
394	auto EraseAll(T& container, const U& value) ->	16✔
395	decltype(distance(container.erase(remove(begin(container), end(container), value), end(container)), end(container)))
396	{
397	const auto itEnd = end(container);	16✔
398	const auto it = remove(begin(container), itEnd, value);	16✔
399	const auto count = distance(it, itEnd);	16✔
400	container.erase(it, itEnd);	16✔
401	return count;	16✔
402	}
403
404	/// @brief Has-functor trait template fallback class.
405	/// @note This is based off the answer by "jrok" on the <em>StackOverflow</em> website
406	/// to the question of: "Check if a class has a member function of a given signature".
407	/// @see https://stackoverflow.com/a/16824239/7410358
408	template <typename, typename T>
409	struct HasFunctor {
410	static_assert(std::integral_constant<T, false>::value,
411	"Second template parameter needs to be of function type.");
412	};
413
414	/// @brief Has-functor trait template class.
415	/// @note This is based off the answer by "jrok" on the <em>StackOverflow</em> website
416	/// to the question of: "Check if a class has a member function of a given signature".
417	/// @see https://stackoverflow.com/a/16824239/7410358
418	template <typename Type, typename Return, typename... Args>
419	struct HasFunctor<Type, Return(Args...)> {
420	private:
421	/// @brief Declaration of check function for supporting types given to template.
422	template<typename T>
423	static constexpr auto check(T*)
424	-> typename std::is_same<decltype(std::declval<T>()(std::declval<Args>()...)),Return>::type;
425
426	/// @brief Declaration of check function for non-supporting types given to template.
427	template<typename>
428	static constexpr std::false_type check(...);
429
430	/// @brief Type alias for given template parameters.
431	using type = decltype(check<Type>(0));
432
433	public:
434	/// Whether or not the given type has the specified functor.
435	static constexpr auto value = type::value;
436	};
437
438	/// @brief Has nullary functor type alias.
439	/// @see HasUnaryFunctor.
440	template <typename Type, typename Return>
441	using HasNullaryFunctor = HasFunctor<Type,Return()>;
442
443	/// @brief Has unary functor type alias.
444	/// @see HasNullaryFunctor.
445	template <typename Type, typename Return, typename Arg>
446	using HasUnaryFunctor = HasFunctor<Type,Return(Arg)>;
447
448	} // namespace playrho
449
450	#endif // PLAYRHO_COMMON_TEMPLATES_HPP

louis-langholtz / PlayRho / 680

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous