Documentation of type_safe

( foonathan/type_safe)

Header file types.hpp

namespace type_safe
{
    inline namespace types
    {
        using int8_t = integer<int8_t>;
        
        using int16_t = integer<int16_t>;
        
        using int32_t = integer<int32_t>;
        
        using int64_t = integer<int64_t>;
        
        using uint8_t = integer<uint8_t>;
        
        using uint16_t = integer<uint16_t>;
        
        using uint32_t = integer<uint32_t>;
        
        using uint64_t = integer<uint64_t>;
        
        inline namespace literals
        {
            template <char ... Digits>
            constexpr int8_t operator""_i8();
            
            template <char ... Digits>
            constexpr int16_t operator""_i16();
            
            template <char ... Digits>
            constexpr int32_t operator""_i32();
            
            template <char ... Digits>
            constexpr int64_t operator""_i64();
            
            template <char ... Digits>
            constexpr uint8_t operator""_u8();
            
            template <char ... Digits>
            constexpr uint16_t operator""_u16();
            
            template <char ... Digits>
            constexpr uint32_t operator""_u32();
            
            template <char ... Digits>
            constexpr uint64_t operator""_u64();
        }
        
        using int_fast8_t = integer<int_fast8_t>;
        
        using int_fast16_t = integer<int_fast16_t>;
        
        using int_fast32_t = integer<int_fast32_t>;
        
        using int_fast64_t = integer<int_fast64_t>;
        
        using uint_fast8_t = integer<uint_fast8_t>;
        
        using uint_fast16_t = integer<uint_fast16_t>;
        
        using uint_fast32_t = integer<uint_fast32_t>;
        
        using uint_fast64_t = integer<uint_fast64_t>;
        
        using int_least8_t = integer<int_least8_t>;
        
        using int_least16_t = integer<int_least16_t>;
        
        using int_least32_t = integer<int_least32_t>;
        
        using int_least64_t = integer<int_least64_t>;
        
        using uint_least8_t = integer<uint_least8_t>;
        
        using uint_least16_t = integer<uint_least16_t>;
        
        using uint_least32_t = integer<uint_least32_t>;
        
        using uint_least64_t = integer<uint_least64_t>;
        
        using intmax_t = integer<intmax_t>;
        
        using uintmax_t = integer<uintmax_t>;
        
        using intptr_t = integer<intptr_t>;
        
        using uintptr_t = integer<uintptr_t>;
        
        using ptrdiff_t = integer<ptrdiff_t>;
        
        using size_t = integer<size_t>;
        
        using int_t = integer<int>;
        
        using unsigned_t = integer<unsigned>;
        
        inline namespace literals
        {
            template <char ... Digits>
            constexpr ptrdiff_t operator""_isize();
            
            template <char ... Digits>
            constexpr size_t operator""_usize();
            
            template <char ... Digits>
            constexpr int_t operator""_i();
            
            template <char ... Digits>
            constexpr unsigned_t operator""_u();
        }
        
        using float_t = floating_point<std::float_t>;
        
        using double_t = floating_point<std::double_t>;
        
        inline namespace literals
        {
            constexpr float_t operator""_f(long double val);
            
            constexpr double_t operator""_d(long double val);
        }
        
        using bool_t = boolean;
    }
}