tb_types.hpp

 
#ifndef TurtleBrains_Types_hpp
#define TurtleBrains_Types_hpp
 
#include <turtle_brains/core/tb_configuration.hpp>
#include <turtle_brains/core/tb_defines.hpp>
#include <cstdint>
#include <cstddef>
 
namespace TurtleBrains::Core
{
 
    using int8 = std::int8_t;     
    using uint8 = std::uint8_t;   
    using byte = std::uint8_t;    
    using int16 = std::int16_t;   
    using uint16 = std::uint16_t; 
    using int32 = std::int32_t;   
    using uint32 = std::uint32_t; 
    using int64 = std::int64_t;   
    using uint64 = std::uint64_t; 
 
    class size
    {
    public:
        explicit size(const tbCore::uint32 value) :
            mValue(value)
        {
        }
 
        explicit size(const std::size_t value) :
            mValue(value)
        {
        }
 
        operator tbCore::uint32() const {
            return tbCore::RangedCast<tbCore::uint32>(mValue);
        }
 
        operator int() const {
            return tbCore::RangedCast<int>(mValue);
        }
 
        operator size_t() const {
            return mValue;
        }
 
        std::size_t mValue;
    };
 
    class size32
    {
    public:
        size32(const tbCore::uint32 value) :
            mValue(value)
        {
        }
 
        size32(const std::size_t value) :
            mValue(tbCore::RangedCast<tbCore::uint32>(value))
        {
        }
 
        operator tbCore::uint32() const {
            return mValue;
        }
 
        tbCore::uint32 mValue;
    };
 
    class size64
    {
    public:
        size64(const tbCore::uint32 value) :
            mValue(value)
        {
        }
 
        size64(const std::size_t value) :
            mValue(value)
        {
        }
 
        tbCore::uint64 mValue;
    };
 
    //eh, kinda
    using InputFile = std::istream;
    using OutputFile = std::ostream;
 
}; /* namespace TurtleBrains::Core */
 
namespace TurtleBrains
{
    // Common Buffer Sizes or Sanity Checks... These should return a size() rather than size_t but compiler didn't want
    //   to. Something something...
    inline constexpr size_t OneKilobyte(void) { return 1024; }
    inline constexpr size_t TwoKilobytes(void) { return OneKilobyte() * 2; }
    inline constexpr size_t FourKilobytes(void) { return OneKilobyte() * 4; }
    inline constexpr size_t OneMegabyte(void) { return 1024 * 1024; }
    inline constexpr size_t OneGigabyte(void) { return 1024 * 1024 * 1024; }
};
 
namespace tbCore = TurtleBrains::Core;
 
#endif /* TurtleBrains_Types_hpp */