def.hpp

Go to the documentation of this file.

#pragma once

#include <cstddef>
#include <limits>
#include <type_traits>

#include <tudocomp/ds/uint_t.hpp>

// assertions
#if defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__clang__)
    #define tdc_likely(x)    __builtin_expect((x) != 0, 1)
    #define tdc_unlikely(x)  __builtin_expect((x) != 0, 0)
#else
    #define tdc_likely(x)    x
    #define tdc_unlikely(x)  x
#endif

// code compiled only in debug build (set build type to Debug)
#ifdef DEBUG
    #define IF_DEBUG(x) x
#else
    #define IF_DEBUG(x)

    #if defined(GOOGLE_STRIP_LOG)
    #undef GOOGLE_STRIP_LOG
    #endif

    #define GOOGLE_STRIP_LOG 1 // no google logging
#endif

// code compiled only in paranoid debug build (pass -DPARANOID=1 to CMake)
#if defined(DEBUG) && defined(PARANOID)
    #define IF_PARANOID(x) x
#else
    #define IF_PARANOID(x)
#endif

// code compiled only if statistics tracking is enabled (default yes)
// (pass -DSTATS_DISABLED=1 to CMake to disable)
#ifdef STATS_DISABLED
    #define IF_STATS(x)
#else
    #define IF_STATS(x) x
#endif

namespace tdc {
    template<typename T, class X = void>
    struct FastIntType {
        // <not defined>
    };
    template<size_t N>
    struct FastIntType<uint_impl_t<N>, std::enable_if_t<(N <= 32)>> {
        using Type = uint32_t;
    };
    template<size_t N>
    struct FastIntType<uint_impl_t<N>, std::enable_if_t<(N > 32)>> {
        using Type = uint64_t;
    };
    template<>
    struct FastIntType<uint32_t> {
        using Type = uint32_t;
    };
    template<>
    struct FastIntType<uint64_t> {
        using Type = uint64_t;
    };

    template<typename actual_type>
    using fast_t = typename FastIntType<actual_type>::Type;

#ifdef LEN_BITS
    using len_compact_t = uint_t<LEN_BITS>;
#else
    using len_compact_t = uint32_t;
#endif

    using len_t = fast_t<len_compact_t>;

    constexpr size_t INDEX_MAX = std::numeric_limits<len_compact_t>::max();

    constexpr size_t INDEX_BITS = 8 * sizeof(len_compact_t);

    constexpr size_t INDEX_FAST_MAX = std::numeric_limits<len_t>::max();

    constexpr size_t INDEX_FAST_BITS = 8 * sizeof(len_t);

    typedef uint8_t uliteral_t;

    constexpr size_t ULITERAL_MAX = std::numeric_limits<uliteral_t>::max();

    template<typename T = size_t>
    constexpr T literal2int(uliteral_t c) {
        return std::make_unsigned_t<T>(c);
    }

    template<typename T = size_t>
    constexpr uliteral_t int2literal(const T& c) {
        return std::make_unsigned_t<T>(c);
    }
}