fundamentaltypes.h

Go to the documentation of this file.

 
#include "elementa/license.inc"
#include "elementa/checks.inc"
 
#ifndef ELEMENTA_BASE_FUNDAMENTALTYPES_H
#define ELEMENTA_BASE_FUNDAMENTALTYPES_H
 
#include <cstdint>
#include <climits>
#include <cstddef>
#include <type_traits>
#include <cmath>
 
 
namespace elementa
{
 
namespace base
{
 
/* ====================================================================== */
 
/* ========================================================================= */
 
/* *************************************************************************
 
    Enum class: endian
 
****************************************************************************/
 
#if ELE_PRE_CPPVER < 2020
 
    enum class endian
    {
    #ifdef ELE_MAKE_LINUX
        little = __ORDER_LITTLE_ENDIAN__,
        big    = __ORDER_BIG_ENDIAN__,
        native = __BYTE_ORDER__
    #else
        little = 0,
        big    = 1,
        native = little
    #endif
    };
#endif
 
 
/* *************************************************************************
 
    Types: sizebits_t, sizebytes_t, LongestUnsigned, LongestInt
 
****************************************************************************/
 
 
using sizebits_t = unsigned;
 
 
using sizebytes_t = unsigned;
 
 
using LongestUnsigned = unsigned long long;
 
using LongestInt = long long;
 
using LongestReal = long double;
 
 
/* *************************************************************************
 
    Enum: SignSpec
 
****************************************************************************/
 
enum class SignSpec: uint8_t { kSigned = 0, kUnsigned }; 
 
 
/* *************************************************************************
 
    Const expression: kMaxBitsInt
 
****************************************************************************/
 
 
#if ULLONG_MAX > 65535LLU
    #if ULLONG_MAX > 4294967295LLU 
        constexpr sizebits_t kMaxBitsInt = 64;
    #else
        constexpr sizebits_t kMaxBitsInt = 32;
    #endif
#else
    constexpr sizebits_t kMaxBitsInt = 16; 
#endif
 
 
/* *************************************************************************
 
    Const expression: kLeastSizeForBits
 
****************************************************************************/
 
 
constexpr sizebits_t kLeastSizeForBits(sizebits_t nbs)
{
    return( (nbs <= 8 ? 8: 
            (nbs <= 16 ? 16 : 
            (nbs <= 32 ? 32 : 
            (nbs <= 64 ? 64 : 0)
           ))));
}
 
 
/* *************************************************************************
 
    Template: ExactInteger
 
****************************************************************************/
 
 
template <sizebits_t NBITS, SignSpec SIGN>
using ExactInteger = 
    typename std::conditional< ((NBITS == 8) && (SIGN==SignSpec::kSigned)), 
        int8_t,
    typename std::conditional< ((NBITS == 8) && (SIGN==SignSpec::kUnsigned)), 
        uint8_t,
    typename std::conditional< ((NBITS == 16) && (SIGN==SignSpec::kSigned)), 
        int16_t,
    typename std::conditional< ((NBITS == 16) && (SIGN==SignSpec::kUnsigned)), 
        uint16_t,
    typename std::conditional< ((NBITS == 32) && (SIGN==SignSpec::kSigned) && 
                                (kMaxBitsInt > 16)), 
        int32_t,
    typename std::conditional< ((NBITS == 32) && (SIGN==SignSpec::kUnsigned) && 
                                (kMaxBitsInt > 16)), 
        uint32_t,
    typename std::conditional< ((NBITS == 64) && (SIGN==SignSpec::kSigned) &&
                                (kMaxBitsInt > 32)), 
        int64_t,
    typename std::conditional< ((NBITS == 64) && (SIGN==SignSpec::kUnsigned) &&
                                (kMaxBitsInt > 32)), 
        uint64_t, 
        void >::type >::type >::type >::type >::type >::type >::type >::type;
 
 
/* *************************************************************************
 
    Template const expression: kNBitsSet
 
**************************************************************************/
 
 
template <typename I>
constexpr I kNBitsSet(sizebits_t n)
{ 
    return(static_cast<I>( (static_cast<I>(1) << n) - 1));
}
 
/* *************************************************************************
 
    Function: len_for_bits
 
******************************************************************************/
 
uint8_t len_for_bits(uint8_t nbits);
 
/* *************************************************************************
 
    Template function: count_bits
 
**************************************************************************/
 
template <typename T>
sizebits_t count_bits(T v)
{
    sizebits_t n = 0;
    for (sizebits_t f = 0; f < sizeof(T)*CHAR_BIT; ++f)
    {
        n += static_cast<sizebits_t>((v & 1) != 0);
        v >>= 1;
    }
    return(n);
}
 
/* *************************************************************************
 
    Template function: most_significant_bit
 
**************************************************************************/
 
template <typename T, sizebits_t N = sizeof(T)*CHAR_BIT>
sizebits_t most_significant_bit(T b)
{
    T mask = static_cast<T>(1) << (N - 1);
    sizebits_t res = N - 1;
    for (sizebits_t f = 0; f < N; ++f)
    {
        if ((b & mask) != 0) return(res);
        --res;
        mask >>= 1;
    }
    return(N);
}
 
/* *************************************************************************
 
    Template const expression: kPtrPlusBytes
    Functions: to_number
 
**************************************************************************/
 
 
template <typename PT>
const PT * kPtrPlusBytes(const PT * p, size_t boff)
{
    return(reinterpret_cast<const PT *>(
            reinterpret_cast<const char *>(p) + boff));
}
 
LongestUnsigned to_number(const void * p);
 
int to_number(char n);
 
unsigned to_number(unsigned char n);
 
 
 // Integral types extensions
 
 // Fundamental types
 
 
} // end namespace base
 
} // end namespace elementa
 
#endif