bytearray.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
#include <cstddef>
#include <cstring>
#include <array>
#include <promeki/core/namespace.h>
#include <promeki/core/string.h>
#include <promeki/core/error.h>
#include <promeki/core/sharedptr.h>
 
PROMEKI_NAMESPACE_BEGIN
 
template <size_t NumBytes> class ByteArray {
        PROMEKI_SHARED_FINAL(ByteArray)
        public:
                using Ptr = SharedPtr<ByteArray>;
                using DataType = std::array<uint8_t, NumBytes>;
 
                ByteArray() : d{} {}
 
                ByteArray(const DataType &val) : d(val) {}
 
                ByteArray(const DataType &&val) : d(std::move(val)) {}
 
                explicit ByteArray(const uint8_t *src) {
                        std::memcpy(d.data(), src, NumBytes);
                }
 
                ~ByteArray() {}
 
                constexpr size_t size() const { return NumBytes; }
 
                uint8_t &operator[](size_t index) { return d[index]; }
 
                const uint8_t &operator[](size_t index) const { return d[index]; }
 
                uint8_t *data() { return d.data(); }
 
                const uint8_t *data() const { return d.data(); }
 
                bool isZero() const {
                        for(size_t i = 0; i < NumBytes; i++) {
                                if(d[i] != 0) return false;
                        }
                        return true;
                }
 
                friend bool operator==(const ByteArray &lhs, const ByteArray &rhs) {
                        return lhs.d == rhs.d;
                }
 
                friend bool operator!=(const ByteArray &lhs, const ByteArray &rhs) {
                        return lhs.d != rhs.d;
                }
 
                String toHexString() const {
                        static const char digits[] = "0123456789abcdef";
                        std::string ret;
                        ret.reserve(NumBytes * 2);
                        for(size_t i = 0; i < NumBytes; i++) {
                                ret += digits[d[i] >> 4];
                                ret += digits[d[i] & 0x0F];
                        }
                        return ret;
                }
 
                static ByteArray fromHexString(const char *str, Error *err = nullptr) {
                        ByteArray ret;
                        if(str == nullptr) {
                                if(err != nullptr) *err = Error::Invalid;
                                return ret;
                        }
                        for(size_t i = 0; i < NumBytes; i++) {
                                int hi = hexCharToVal(str[i * 2]);
                                int lo = hexCharToVal(str[i * 2 + 1]);
                                if(hi < 0 || lo < 0) {
                                        if(err != nullptr) *err = Error::Invalid;
                                        return ByteArray();
                                }
                                ret.d[i] = static_cast<uint8_t>((hi << 4) | lo);
                        }
                        if(err != nullptr) *err = Error::Ok;
                        return ret;
                }
 
                static ByteArray fromHexString(const String &str, Error *err = nullptr) {
                        return fromHexString(str.cstr(), err);
                }
 
        private:
                DataType d;
 
                static int hexCharToVal(char c) {
                        if(c >= '0' && c <= '9') return c - '0';
                        if(c >= 'a' && c <= 'f') return c - 'a' + 10;
                        if(c >= 'A' && c <= 'F') return c - 'A' + 10;
                        return -1;
                }
};
 
PROMEKI_NAMESPACE_END