DataTypes.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include <cstddef>
#include <cstdint>
#include <type_traits>
 
namespace CeresEngine {
    using Int8 = std::int8_t;
    using SInt8 = std::int8_t;
    using UInt8 = std::uint8_t;
    using Int16 = std::int16_t;
    using SInt16 = std::int16_t;
    using UInt16 = std::uint16_t;
    using Int32 = std::int32_t;
    using SInt32 = std::int32_t;
    using UInt32 = std::uint32_t;
    using Int64 = std::int64_t;
    using SInt64 = std::int64_t;
    using UInt64 = std::uint64_t;
 
    using Int = Int32;
    using SInt = Int32;
    using UInt = UInt32;
 
    using Float = float;
    using Double = double;
 
    using Bool = bool;
 
#if defined(__cpp_lib_byte)
    using Byte = std::byte;
#else
    enum class Byte : unsigned char {
    };
 
    template<class _IntType, std::enable_if_t<std::is_integral_v<_IntType>, int> = 0>
    [[nodiscard]] constexpr Byte operator<<(const Byte arg,
        const _IntType shift) noexcept { // bitwise LEFT SHIFT, every
        // static_cast is intentional
        return static_cast<Byte>(static_cast<unsigned char>(static_cast<unsigned int>(arg) << shift));
    }
 
    template<class _IntType, std::enable_if_t<std::is_integral_v<_IntType>, int> = 0>
    [[nodiscard]] constexpr Byte operator>>(const Byte arg,
        const _IntType shift) noexcept { // bitwise RIGHT SHIFT, every
        // static_cast is intentional
        return static_cast<Byte>(static_cast<unsigned char>(static_cast<unsigned int>(arg) >> shift));
    }
 
    [[nodiscard]] constexpr Byte operator|(const Byte left,
        const Byte right) noexcept { // bitwise OR, every static_cast is
        // intentional
        return static_cast<Byte>(static_cast<unsigned char>(static_cast<unsigned int>(left) | static_cast<unsigned int>(right)));
    }
 
    [[nodiscard]] constexpr Byte operator&(const Byte left,
        const Byte right) noexcept { // bitwise AND, every static_cast is
        // intentional
        return static_cast<Byte>(static_cast<unsigned char>(static_cast<unsigned int>(left) & static_cast<unsigned int>(right)));
    }
 
    [[nodiscard]] constexpr Byte operator^(const Byte left,
        const Byte right) noexcept { // bitwise XOR, every static_cast is
        // intentional
        return static_cast<Byte>(static_cast<unsigned char>(static_cast<unsigned int>(left) ^ static_cast<unsigned int>(right)));
    }
 
    [[nodiscard]] constexpr Byte operator~(const Byte arg) noexcept { // bitwise NOT, every static_cast is
        // intentional
        return static_cast<Byte>(static_cast<unsigned char>(~static_cast<unsigned int>(arg)));
    }
 
    template<class _IntType, std::enable_if_t<std::is_integral_v<_IntType>, int> = 0>
    constexpr Byte& operator<<=(Byte& arg, const _IntType shift) noexcept { // bitwise LEFT SHIFT
        return arg = arg << shift;
    }
 
    template<class _IntType, std::enable_if_t<std::is_integral_v<_IntType>, int> = 0>
    constexpr Byte& operator>>=(Byte& arg, const _IntType shift) noexcept { // bitwise RIGHT SHIFT
        return arg = arg >> shift;
    }
 
    constexpr Byte& operator|=(Byte& left, const Byte right) noexcept { // bitwise OR
        return left = left | right;
    }
 
    constexpr Byte& operator&=(Byte& left, const Byte right) noexcept { // bitwise AND
        return left = left & right;
    }
 
    constexpr Byte& operator^=(Byte& left, const Byte right) noexcept { // bitwise XOR
        return left = left ^ right;
    }
 
    template<class _IntType, std::enable_if_t<std::is_integral_v<_IntType>, int> = 0>
    [[nodiscard]] constexpr _IntType to_integer(const Byte arg) noexcept { // convert byte to integer
        return static_cast<_IntType>(arg);
    }
#endif
} // namespace CeresEngine