ByteArray.hpp

#pragma once
#include <samchon/API.hpp>

#include <vector>
#include <string>

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

        size_t position;//{0};

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

        ByteArray();

        ByteArray(const ByteArray &);

        ByteArray(ByteArray &&);

        auto operator=(const ByteArray &) -> ByteArray&;

        auto operator=(ByteArray &&) -> ByteArray&;

        /* --------------------------------------------------------------
            POSITION
        -------------------------------------------------------------- */
        auto getPosition() const -> size_t;

        void setPosition(size_t);

        auto leftSize() const -> size_t;

        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 &byteArray)
        {
            insert(end(), byteArray.begin(), byteArray.end());
        };

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

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

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