ByteArray.h

Go to the documentation of this file.

 
#pragma once
#include "HexFormatter.h"
#include <array>
 
namespace catapult { namespace utils {
 
    template<size_t N, typename TTag>
    class ByteArray : TTag {
    public:
        using const_iterator = typename std::array<uint8_t, N>::const_iterator;
 
    public:
        constexpr ByteArray() : m_array()
        {}
 
        constexpr ByteArray(const std::array<uint8_t, N>& array) : m_array(array)
        {}
 
        constexpr ByteArray(const ByteArray& rhs) : m_array(rhs.m_array)
        {}
 
    public:
        ByteArray& operator=(const ByteArray& rhs) {
            m_array = rhs.m_array;
            return *this;
        }
 
    public:
        constexpr size_t size() const {
            return m_array.size();
        }
 
        constexpr const uint8_t& operator[](size_t index) const {
            return m_array[index];
        }
 
        constexpr uint8_t& operator[](size_t index) {
            return m_array[index];
        }
 
        constexpr const uint8_t* data() const noexcept {
            return m_array.data();
        }
 
        constexpr uint8_t* data() noexcept {
            return m_array.data();
        }
 
    public:
        constexpr auto cbegin() const noexcept {
            return m_array.cbegin();
        }
 
        constexpr auto cend() const noexcept {
            return m_array.cend();
        }
 
        constexpr auto begin() const noexcept {
            return m_array.begin();
        }
 
        constexpr auto end() const noexcept {
            return m_array.end();
        }
 
        constexpr auto begin() noexcept {
            return m_array.begin();
        }
 
        constexpr auto end() noexcept {
            return m_array.end();
        }
 
    public:
        constexpr bool operator==(const ByteArray& rhs) const {
            return m_array == rhs.m_array;
        }
 
        constexpr bool operator!=(const ByteArray& rhs) const {
            return !(*this == rhs);
        }
 
        constexpr bool operator>=(const ByteArray& rhs) const {
            return m_array >= rhs.m_array;
        }
 
        constexpr bool operator>(const ByteArray& rhs) const {
            return m_array > rhs.m_array;
        }
 
        constexpr bool operator<=(const ByteArray& rhs) const {
            return m_array <= rhs.m_array;
        }
 
        constexpr bool operator<(const ByteArray& rhs) const {
            return m_array < rhs.m_array;
        }
 
        friend std::ostream& operator<<(std::ostream& out, const ByteArray& byteArray) {
            out << HexFormat(byteArray.m_array);
            return out;
        }
 
    private:
        std::array<uint8_t, N> m_array;
    };
 
    // force compilation error if HexFormat is used with ByteArray
    template<size_t N, typename TTag>
    constexpr void HexFormat(const ByteArray<N, TTag>&);
}}