GenericConcepts.h

/*
  ==============================================================================
    DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 
    Copyright 2022- by sonible GmbH.
 
    This file is part of VCTR - Versatile Container Templates Reconceptualized.
 
    VCTR is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License version 3
    only, as published by the Free Software Foundation.
 
    VCTR is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License version 3 for more details.
 
    You should have received a copy of the GNU Lesser General Public License
    version 3 along with VCTR.  If not, see <https://www.gnu.org/licenses/>.
  ==============================================================================
*/
 
namespace vctr::has
{
 
template <class Lhs, class Rhs = Lhs>
concept operatorPlusEquals = requires (Lhs l, Rhs r) { l += r; };
 
template <class T>
concept init = requires (T& t, void* ptr, size_t s) { t.init (ptr, s); };
 
template <class T>
concept getStart = requires (const T& t) { { t.getStart() } -> is::realNumber; };
 
template <class T>
concept getLength = requires (const T& t) { { t.getLength() } -> is::realNumber; };
 
template <class T>
concept getEnd = requires (const T& t) { { t.getEnd() } -> is::realNumber; };
 
template <class T, class ValueType>
concept getStartWithValueType = requires (const T& t) { { t.getStart() } -> std::same_as<ValueType>; };
 
template <class T, class ValueType>
concept getLengthWithValueType = requires (const T& t) { { t.getLength() } -> std::same_as<ValueType>; };
 
template <class T, class ValueType>
concept getEndWithValueType = requires (const T& t) { { t.getEnd() } -> std::same_as<ValueType>; };
 
}
 
namespace vctr::detail
{
 
// clang-format off
template <class T>
struct IsStdUniquePtr : std::false_type {};
 
template <class T, class D>
struct IsStdUniquePtr<std::unique_ptr<T, D>> : std::true_type {};
// clang-format on
 
} // namespace vctr::detail
 
namespace vctr::is
{
 
template <class T>
concept triviallyCopyable = std::is_trivially_copyable_v<T>;
 
template <class T>
concept nonConst = ! std::is_const_v<T>;
 
template <class T>
concept pointer = std::is_pointer_v<std::remove_cvref_t<T>>;
 
template <class T>
concept noPointer = ! std::is_pointer_v<std::remove_cvref_t<T>>;
 
template <class T>
concept uniquePtr = detail::IsStdUniquePtr<T>::value;
 
template <class T>
concept lvalueReference = std::is_lvalue_reference_v<T>;
 
template <class T>
concept stdPair = requires (T& t) { [] <class A, class B> (std::pair<A, B>&) {} (t); };
 
template <class T>
concept stdTuple = requires (T& t) { [] <class... Ts> (std::tuple<Ts...>&) {} (t); };
 
template <class T, class... TupleTypes>
concept stdTupleWithTypes = std::same_as<T, std::tuple<TupleTypes...>>;
 
template <class C>
concept constant = requires (const void* ptr) { ptr = &C::value; };
 
template <class C, class T>
concept constantWithType = std::same_as<T, std::remove_cvref_t<decltype (C::value)>>;
 
template <class T>
concept range = has::getStart<T> &&
                has::getLength<T> &&
                has::getEnd<T>;
 
template <class T, class ValueType>
concept rangeWithValueType = has::getStartWithValueType<T, ValueType> &&
                             has::getLengthWithValueType<T, ValueType> &&
                             has::getEndWithValueType<T, ValueType>;
 
} // namespace vctr::is
 
namespace vctr::are
{
 
template <class T, class... U>
concept same = (std::same_as<T, U> || ...);
 
} // namespace vctr::are