ByteArray.hpp

#pragma once

#include <vector>
#include <string>

namespace samchon
{
    class ByteArray
        : public std::vector<unsigned char>
    {
    private:
        typedef std::vector<unsigned char> super;

        size_t position;//{0};

    public:
        /* --------------------------------------------------------------
            CONSTRUCTROS
        -------------------------------------------------------------- */
        //using super::super;

        ByteArray() : super()
        {
            position = 0;
        };

        ByteArray(const ByteArray &obj) : super(obj)
        {
            position = 0;
        };

        ByteArray(ByteArray &&obj) : super(move(obj))
        {
            position = 0;
        };

        auto operator=(const ByteArray &obj) -> ByteArray&
        {
            assign(obj.begin(), obj.end());
            position = obj.position;

            return *this;
        };

        auto operator=(ByteArray &&obj) -> ByteArray&
        {
            super::operator=(move(obj));
            position = obj.position;

            return *this;
        };

        /* --------------------------------------------------------------
            POSITION
        -------------------------------------------------------------- */
        auto get_position() const -> size_t
        {
            return position;
        };

        void set_position(size_t val)
        {
            position = val;
        };

        auto left_size() const -> size_t
        {
            return this->size() - position;
        };

        template <typename T> static auto reverse(const T &val) -> T
        {
            T res;
            int size = sizeof(T);

            unsigned char *originalBytes = (unsigned char*)&val;
            unsigned char *reversedBytes = (unsigned char*)&res;

            for (int i = 0; i < size; i++)
                reversedBytes[i] = originalBytes[size - i - 1];

            return res;
        };

        /* --------------------------------------------------------------
            READ BYTES
        -------------------------------------------------------------- */
        template <typename T> auto read() const -> T
        {
            T *ptr = (T*)(data() + position);
            ((ByteArray*)this)->position += sizeof(T);

            return *ptr;
        };
        template<> auto read() const -> std::string
        {
            if (position >= size())
                return "";

            std::string str = (char*)(data() + position);
            ((ByteArray*)this)->position = str.size();

            return str;
        };

        template <typename T> auto readReversely() const -> T
        {
            T val = read<T>();
            return reverse(val);
        }

        /* --------------------------------------------------------------
            WRITE BYTES
        -------------------------------------------------------------- */
        template <typename T> void write(const T &val)
        {
            unsigned char *ptr = (unsigned char*)&val;
            insert(end(), ptr, ptr + sizeof(T));
        };
        template<> void write(const std::string &str)
        {
            unsigned char *begin = (unsigned char*)str.data();
            insert(end(), begin, begin + str.size());
        };
        template<> void write(const ByteArray &byte_array)
        {
            insert(end(), byte_array.begin(), byte_array.end());
        };

        template<typename T> void writeReversely(const T &val)
        {
            write(reverse(val));
        };

        /* --------------------------------------------------------------
            COMPRESS & DECOMPRESS
        -------------------------------------------------------------- */
        auto compress() const -> ByteArray
        {
            return{};
        };

        auto decompress() const -> ByteArray
        {
            return{};
        };
    };
};