stream.h

#ifndef OE_IO_STREAM_H
#define OE_IO_STREAM_H
 
#include "../util/byte_array.h"
#include "../util/endian.h"
 
#include <string>
#include <vector>
 
namespace oe::io
{
    // Todo: Use deque instead of ByteArray (to allow left-trimming and appending data on the fly)
    class Stream
    {
        public:
            Stream(const ByteArray& data);
 
            size_t read(ByteArray& buffer, const size_t& len);
            size_t write(ByteArray& buffer, const size_t& len);
 
            bool eof();
            bool seek(const size_t& pos);
            size_t tell();
            size_t size();
 
            void align(size_t alignment);
 
            std::string readStringToNull(const size_t& maxLength = 32767);
 
            std::string readString(const size_t& length);
 
            template <typename T>
            T readValue(bool little_endian = true)
            {
                ByteArray data;
                data.reserve(sizeof(T));
 
                read(data, sizeof(T));
 
                T result = oe::util::convertFromByteArray<T>(data);
 
                if (little_endian)
                    return oe::util::endian::convertLittleEndianToHost(result);
                else
                    return oe::util::endian::convertBigEndianToHost(result);
            }
 
            //template <typename T> bool writeValue(const T value, bool little_endian = true);
 
            void trim()
            {
                _data.erase(_data.begin(), _cursor);
            }
 
            void appendData(const ByteArray& data)
            {
                _data.insert(end(_data), begin(data), end(data));
            }
 
            const ByteArray getData() const
            {
                return _data;
            }
 
            /*template <typename T> static Stream buildFromVector(const std::vector<T>& input)
            {
                Stream result;
 
                for (auto& it : input)
                {
                    result.writeValue<T>(it);
                }
 
                return result;
            }*/
        private:
            ByteArray _data;
            ByteArray::iterator _cursor;
    };
 
    template<> bool Stream::readValue<>(bool little_endian);
    template<> uint8_t Stream::readValue<>(bool little_endian);
    template<> int8_t Stream::readValue<>(bool little_endian);
 
    /*template<> bool Stream::writeValue<>(const bool value, bool little_endian);
    template<> bool Stream::writeValue<>(const uint8_t value, bool little_endian);
    template<> bool Stream::writeValue<>(const int8_t value, bool little_endian);*/
}
 
#endif