bytearray.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cstdint>
#include <cstddef>
#include <cstring>
#include <promeki/array.h>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/error.h>
#include <promeki/sharedptr.h>
 
PROMEKI_NAMESPACE_BEGIN
 
template <size_t NumBytes> class ByteArray {
                PROMEKI_SHARED_FINAL(ByteArray)
        public:
                using Ptr = SharedPtr<ByteArray>;
                using DataType = Array<uint8_t, NumBytes>;
 
                ByteArray() : d{} {}
 
                ByteArray(const DataType &val) : d(val) {}
 
                ByteArray(DataType &&val) noexcept : 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";
                        String            ret;
                        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
 
#endif // PROMEKI_ENABLE_CORE