sfinae_helpers.hpp

Go to the documentation of this file.

/*
 * SPDX-Licence-Identifier: MIT
 *
 * Copyright 2025 Larry Chips
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the “Software”), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
#pragma once

 
#include <limits>
#include <type_traits>
#include <utility>
 
#include "ugmisc/features.hpp"
 
 
 
 
namespace ugmisc {
 
 
 
 
template<class T>
using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;
 
 
 
 
template<class T>
using plain_ref_t = std::remove_cv_t<T>&;
 
 
 
 
template<class T> plain_ref_t<T> decl_plain_ref();
 
 
 
 
template<class T, class=void>
struct get_is_bitwise : std::false_type {};
 
 
 
 
template<class T>
struct get_is_bitwise<
    T,
    std::void_t<
        decltype(decl_plain_ref<T>() = std::declval<T>() | std::declval<T>()),
        decltype(decl_plain_ref<T>() = std::declval<T>() & std::declval<T>()),
        decltype(decl_plain_ref<T>() = std::declval<T>() ^ std::declval<T>()),
        decltype(decl_plain_ref<T>() = ~ std::declval<T>())
        >
    >
    : public std::true_type {};
 
 
 

template<class T>
static constexpr bool is_bitwise = get_is_bitwise<T>::value;
#ifdef UGMISC_USE_CONCEPT_DECLS
template<class T>
concept Bitwise = is_bitwise<T>;
#endif
 
 
 

template<class T, class R=T> using uint_only = std::enable_if_t<
    std::numeric_limits<T>::is_integer
    && ( ! std::numeric_limits<T>::is_signed ),
 
    R
    >;
#ifdef UGMISC_USE_CONCEPT_DECLS
template<class T>
concept Uint =
    std::numeric_limits<T>::is_integer
    && ! std::numeric_limits<T>::is_signed
    ;
#endif
 
 
 

template<class T, class R=T> using modulo_uint_only = std::enable_if_t<
    std::numeric_limits<T>::is_integer
    && ( ! std::numeric_limits<T>::is_signed )
    && std::numeric_limits<T>::is_modulo
    && std::is_arithmetic_v<T>,
 
    R
    >;
#ifdef UGMISC_USE_CONCEPT_DECLS
template<class T>
concept ModuloUint =
    Uint<T> && std::numeric_limits<T>::is_modulo
    && std::is_arithmetic_v<T>
    ;
#endif
 
 
 
 
/*
 * See below.
 */
template<class T> static constexpr bool is_bitwise_uint =
    std::numeric_limits<T>::is_integer
    && ( ! std::numeric_limits<T>::is_signed )
    && ( std::numeric_limits<T>::radix == 2 )
    && std::numeric_limits<T>::is_modulo
    && std::is_arithmetic_v<T>
    && is_bitwise<T>
    ;

template<class T, class R=T> using bitwise_uint_only = std::enable_if_t<
    is_bitwise_uint<T>,
    R
    >;
#ifdef UGMISC_USE_CONCEPT_DECLS
template<class T> concept BitwiseUint = Bitwise<T> && ModuloUint<T>;
#endif
 
 
 

template<class T, class R=T> using int_only = std::enable_if_t<
    std::numeric_limits<T>::is_integer,
 
    R
    >;
#ifdef UGMISC_USE_CONCEPT_DECLS
template<class T> concept Int = std::numeric_limits<T>::is_integer;
#endif
} /* ugmisc */