types_traits.h

Go to the documentation of this file.

//   Copyright 2016-2023 Jean-Francois Poilpret
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.
 
 
#ifndef TYPES_TRAITS_HH
#define TYPES_TRAITS_HH
 
#include <stddef.h>
#include <stdint.h>
#include "defines.h"
 
namespace types_traits
{
    template<typename T> struct Type_trait
    {
        static constexpr bool IS_INT = false;
        static constexpr bool IS_SIGNED = false;
        static constexpr size_t SIZE = 0;
    };
 
    template<typename T_, bool IS_SIGNED_> struct Type_trait_int
    {
        static constexpr bool IS_INT = true;
        static constexpr bool IS_SIGNED = IS_SIGNED_;
        static constexpr size_t SIZE = sizeof(T_);
    };
 
    template<> struct Type_trait<uint8_t> : Type_trait_int<uint8_t, false> {};
    template<> struct Type_trait<uint16_t> : Type_trait_int<uint16_t, false> {};
    template<> struct Type_trait<uint32_t> : Type_trait_int<uint32_t, false> {};
    template<> struct Type_trait<uint64_t> : Type_trait_int<uint64_t, false> {};
    template<> struct Type_trait<int8_t> : Type_trait_int<int8_t, true> {};
    template<> struct Type_trait<int16_t> : Type_trait_int<int16_t, true> {};
    template<> struct Type_trait<int32_t> : Type_trait_int<int32_t, true> {};
    template<> struct Type_trait<int64_t> : Type_trait_int<int64_t, true> {};
 
    template<typename T> static constexpr bool is_uint8_or_uint16()
    {
        using TRAIT = Type_trait<T>;
        return TRAIT::IS_INT && (TRAIT::SIZE <= sizeof(uint16_t)) && (!TRAIT::IS_SIGNED);
    }
 
    template<class T, class B> struct derives_from
    {
        static void constraints(T* p)
        {
            UNUSED B* pb = p;
        }
        constexpr derives_from()
        {
            UNUSED void (*p)(T*) = constraints;
        }
    };
 
    template<typename T> struct remove_reference
    {
        using type = T;
    };
    template<typename T> struct remove_reference<T&>
    {
        using type = T;
    };
    template<typename T> struct remove_reference<T&&>
    {
        using type = T;
    };
 
    // Find min number of bytes (as power of 2) needed to store value
    constexpr uint8_t uint_size_in_val(uint64_t value)
    {
        return (value & 0xFFFF'FFFF'0000'0000ULL ? 8 :
                value & 0x0000'0000'FFFF'0000ULL ? 4 :
                value & 0x0000'0000'0000'FF00ULL ? 2 : 1);
    }
    template<uint8_t bytes> struct UnsignedInt
    {
        using UTYPE = void;
        using STYPE = void;
    };
    template<> struct UnsignedInt<8>
    {
        using UTYPE = uint64_t;
        using STYPE = int64_t;
    };
    template<> struct UnsignedInt<4>
    {
        using UTYPE = uint32_t;
        using STYPE = int32_t;
    };
    template<> struct UnsignedInt<2>
    {
        using UTYPE = uint16_t;
        using STYPE = int16_t;
    };
    template<> struct UnsignedInt<1>
    {
        using UTYPE = uint8_t;
        using STYPE = int8_t;
    };
 
    template<uint64_t VAL> struct SmallestInt
    {
        using UNSIGNED_TYPE = typename UnsignedInt<uint_size_in_val(VAL)>::UTYPE;
        using SIGNED_TYPE = typename UnsignedInt<uint_size_in_val(VAL)>::STYPE;
    };
}
 
#endif /* TYPES_TRAITS_HH */