detect.h

Go to the documentation of this file.

//
// Copyright 2017 - 2026 (C). Alex Robenko. All rights reserved.
//
// SPDX-License-Identifier: MPL-2.0
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 
#pragma once
 
#include "comms/CompileControl.h"
#include "comms/util/type_traits.h"
 
#include <cstddef>
#include <type_traits>
#include <utility>
 
#if COMMS_HAS_CPP20_SPAN
#include <span>
#endif // #if COMMS_HAS_CPP20_SPAN
 
namespace comms
{
 
namespace util
{
 
namespace detect
{
 
namespace details
{
 
// MSVC2015 Is not working correctly with VoidT or any other workaround
// suggested at https://en.cppreference.com/w/cpp/types/void_t
 
// template <typename... TArgs>
// using VoidT = void;
 
// template <typename TVoid, template <class...> class TOp, typename... TArgs>
// struct PresenceDetector
// {
//    static const bool Value = false;
// };
 
// template <template <class...> class TOp, typename... TArgs>
// struct PresenceDetector<VoidT<TOp<TArgs...> >, TOp, TArgs...>
// {
//    static const bool Value = true;
// };
 
// template <template <class...> class TOp, typename... TArgs>
// constexpr bool isDetected()
// {
//    return PresenceDetector<void, TOp, TArgs...>::Value;
// }
 
// template <typename T>
// using HasClearOp = decltype(std::declval<T&>().clear());
 
// template <typename T>
// using HasReserveOp = decltype(std::declval<T&>().reserve(std::declval<typename T::size_type>()));
 
template <typename T>
struct IsStdSpan
{
    static constexpr bool Value = false;
};
 
#if COMMS_HAS_CPP20_SPAN
template <typename T, std::size_t TExt>
struct IsStdSpan<std::span<T, TExt> >
{
    static constexpr bool Value = true;
};
#endif // #if COMMS_HAS_CPP20_SPAN
 
template <typename T>
class HasClearFunc
{
    using No = comms::util::EmptyStruct<>;
 
protected:
    template <typename C>
    static auto test(std::nullptr_t) -> decltype(std::declval<C>().clear());
 
    template <typename>
    static No test(...);
 
public:
    static const bool Value = !std::is_same<No, decltype(test<T>(nullptr))>::value;
};
 
template <typename T>
class HasReserveFunc
{
    using No = comms::util::EmptyStruct<>;
 
protected:
    template <typename C>
    static auto test(std::nullptr_t) -> decltype(std::declval<C>().reserve(0U));
 
    template <typename>
    static No test(...);
 
public:
    static const bool Value = !std::is_same<No, decltype(test<T>(nullptr))>::value;
};
 
template <typename T>
class HasResizeFunc
{
    using No = comms::util::EmptyStruct<>;
 
protected:
    template <typename C>
    static auto test(std::nullptr_t) -> decltype(std::declval<C>().resize(0U));
 
    template <typename>
    static No test(...);
 
public:
    static const bool Value = !std::is_same<No, decltype(test<T>(nullptr))>::value;
};
 
template <typename T>
class HasRemoveSuffixFunc
{
    using No = comms::util::EmptyStruct<>;
 
protected:
    template <typename C>
    static auto test(std::nullptr_t) -> decltype(std::declval<C>().remove_suffix(0U));
 
    template <typename>
    static No test(...);
 
public:
    static const bool Value = !std::is_same<No, decltype(test<T>(nullptr))>::value;
};
 
template <typename T>
class HasAssignFunc
{
    using No = comms::util::EmptyStruct<>;
 
protected:
    template <typename C>
    static auto test(std::nullptr_t) -> decltype(std::declval<C>().assign(static_cast<typename C::const_pointer>(nullptr), static_cast<typename C::const_pointer>(nullptr)));
 
    template <typename>
    static No test(...);
 
public:
    static const bool Value = !std::is_same<No, decltype(test<T>(nullptr))>::value;
};
 
template <typename T>
class HasPtrSizeConstructor
{
    using No = comms::util::EmptyStruct<>;
 
protected:
    template <typename C>
    static auto test(std::nullptr_t) -> decltype(C(static_cast<typename C::const_pointer>(nullptr), static_cast<typename C::size_type>(0U)));
 
    template <typename>
    static No test(...);
 
public:
    static const bool Value = !std::is_same<No, decltype(test<T>(nullptr))>::value;
};
 
template <typename T>
class HasMaxSizeFunc
{
    using No = comms::util::EmptyStruct<>;
 
protected:
    template <typename C>
    static auto test(std::nullptr_t) -> decltype(std::declval<C>().max_size());
 
    template <typename>
    static No test(...);
 
public:
    static const bool Value = !std::is_same<No, decltype(test<T>(nullptr))>::value;
};
 
} // namespace details
 
} // namespace detect
 
} // namespace util
 
} // namespace comms