trivial.h

Go to the documentation of this file.

#pragma once
 
#include "di/function/tag_invoke.h"
#include "di/meta/language.h"
#include "di/meta/operations.h"
#include "di/platform/compiler.h"
#include "di/types/in_place_type.h"
 
namespace di::concepts {
template<typename T>
concept Trivial = __is_trivial(T);
 
template<typename T, typename U>
concept TriviallyAssignableFrom = __is_trivially_assignable(T, U);
 
template<typename T, typename... Args>
concept TriviallyConstructibleFrom = __is_trivially_constructible(T, Args...);
 
template<typename T>
concept TriviallyCopyAssignable = TriviallyAssignableFrom<T&, T const&>;
 
template<typename T>
concept TriviallyCopyConstructible = TriviallyConstructibleFrom<T, T const&>;
 
template<typename T>
concept TriviallyCopyable = __is_trivially_copyable(T);
 
template<typename T>
concept TriviallyDefaultConstructible = TriviallyConstructibleFrom<T>;
 
template<typename T>
concept TriviallyMoveAssignable = TriviallyAssignableFrom<T&, T&&>;
 
template<typename T>
concept TriviallyMoveConstructible = TriviallyConstructibleFrom<T, T&&>;
 
#ifdef DI_CLANG
template<typename T>
concept TriviallyDestructible = __is_trivially_destructible(T);
#else
template<typename T>
concept TriviallyDestructible = Destructible<T> && __has_trivial_destructor(T);
#endif
 
namespace detail {
    struct TriviallyRelocatableFunction {
        template<typename T>
        constexpr auto operator()(InPlaceType<T>) const -> bool {
            if constexpr (TagInvocableTo<TriviallyRelocatableFunction, InPlaceType<T>>) {
                return function::tag_invoke(*this, in_place_type<T>);
            } else {
                return concepts::TriviallyCopyable<T>;
            }
        }
    };
}
 
constexpr inline auto trivially_relocatable = detail::TriviallyRelocatableFunction {};
 
template<typename T>
concept TriviallyRelocatable = trivially_relocatable(in_place_type<T>);

template<typename T>
concept ImplicitLifetime =
    (Scalar<T> || LanguageArray<T> || Aggregate<T> ||
     (TriviallyDestructible<T> &&
      (TriviallyDefaultConstructible<T> || TriviallyCopyConstructible<T> || TriviallyMoveConstructible<T>) ));
}