byte.hpp

Go to the documentation of this file.

#ifndef BSL_BYTE_HPP
#define BSL_BYTE_HPP

#include "cstdint.hpp"
#include "move.hpp"

#include "enable_if.hpp"
#include "is_integral.hpp"
#include "is_same.hpp"
#include "is_unsigned.hpp"

namespace bsl
{
    class byte final
    {
    public:
        using value_type = bsl::uint8;

        byte() noexcept = default;

        constexpr byte(value_type const val) noexcept    // PRQA S 2180 // NOLINT
            : m_data{val}
        {}

        template<typename T = value_type, enable_if_t<is_integral<T>::value, bool> = true>
        [[nodiscard]] constexpr T
        to_integer() const noexcept
        {
            return static_cast<T>(m_data);
        }

        ~byte() noexcept = default;

        constexpr byte(byte const &o) noexcept = default;

        constexpr byte(byte &&o) noexcept = default;

        constexpr byte &operator=(byte const &o) &noexcept = default;

        constexpr byte &operator=(byte &&o) &noexcept = default;

        template<typename O>
        byte(O val) noexcept = delete;    // PRQA S 2180

    private:
        value_type m_data;
    };

    constexpr bool
    operator==(byte const &lhs, byte const &rhs) noexcept
    {
        return lhs.to_integer() == rhs.to_integer();
    }

    constexpr bool
    operator!=(byte const &lhs, byte const &rhs) noexcept
    {
        return !(lhs == rhs);
    }

    constexpr byte &
    operator<<=(byte &b, bsl::uint32 const shift) noexcept
    {
        b = byte{static_cast<bsl::uint8>(b.to_integer<bsl::uint32>() << shift)};
        return b;
    }

    constexpr byte &
    operator>>=(byte &b, bsl::uint32 const shift) noexcept
    {
        b = byte{static_cast<bsl::uint8>(b.to_integer<bsl::uint32>() >> shift)};
        return b;
    }

    constexpr byte
    operator<<(byte const &b, bsl::uint32 const shift) noexcept
    {
        byte tmp{b};
        tmp <<= shift;
        return tmp;
    }

    constexpr byte
    operator>>(byte const &b, bsl::uint32 const shift) noexcept
    {
        byte tmp{b};
        tmp >>= shift;
        return tmp;
    }

    constexpr byte &
    operator|=(byte &lhs, byte const &rhs) noexcept
    {
        auto const lhs32{lhs.to_integer<bsl::uint32>()};
        auto const rhs32{rhs.to_integer<bsl::uint32>()};

        lhs = byte{static_cast<bsl::uint8>(lhs32 | rhs32)};
        return lhs;
    }

    constexpr byte &
    operator&=(byte &lhs, byte const &rhs) noexcept
    {
        auto const lhs32{lhs.to_integer<bsl::uint32>()};
        auto const rhs32{rhs.to_integer<bsl::uint32>()};

        lhs = byte{static_cast<bsl::uint8>(lhs32 & rhs32)};
        return lhs;
    }

    constexpr byte &
    operator^=(byte &lhs, byte const &rhs) noexcept
    {
        auto const lhs32{lhs.to_integer<bsl::uint32>()};
        auto const rhs32{rhs.to_integer<bsl::uint32>()};

        lhs = byte{static_cast<bsl::uint8>(lhs32 ^ rhs32)};
        return lhs;
    }

    constexpr byte
    operator|(byte const &lhs, byte const &rhs) noexcept
    {
        byte tmp{lhs};
        tmp |= rhs;
        return tmp;
    }

    constexpr byte
    operator&(byte const &lhs, byte const &rhs) noexcept
    {
        byte tmp{lhs};
        tmp &= rhs;
        return tmp;
    }

    constexpr byte
    operator^(byte const &lhs, byte const &rhs) noexcept
    {
        byte tmp{lhs};
        tmp ^= rhs;
        return tmp;
    }

    constexpr byte
    operator~(byte const &b) noexcept
    {
        return byte{static_cast<bsl::uint8>(~b.to_integer<bsl::uint32>())};
    }
}

#endif