memorystream.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
#include <string>
#include <memory>
#include <assert.h>
#include <cstring>
 
namespace nap
{
    namespace utility
    {
        class MemoryStream
        {
        public:
            MemoryStream(const uint8_t* buffer, uint32_t length) :
                mBuffer(buffer),
                mLength(length),
                mReadPos(buffer)
            {
            }
 
            bool isDone() const
            {
                return mReadPos >= (mBuffer + mLength);
            }
 
            bool hasAvailable(uint32_t size)
            {
                return (mLength - (mReadPos - mBuffer)) >= size;
            }
 
            void read(void* data, uint32_t length)
            {
                assert(hasAvailable(length));
 
                std::memcpy(data, mReadPos, length);
                mReadPos += length;
            }
 
            template<class T>
            void read(T& data)
            {
                read(&data, sizeof(T));
            }
 
            template<class T>
            const T read()
            {
                T value;
                read(value);
 
                return value;
            }
 
            void readString(std::string& string)
            {
                // Read the length of the string
                size_t length;
                read(length);
 
                // Resize string and read data
                string.resize(length);
                read((void*)string.data(), length);
            }
 
        private:
            const uint8_t*  mBuffer;    // The buffer we're reading from
            uint32_t        mLength;    // The length of the buffer
            const uint8_t*  mReadPos;   // Current position in the buffer we're reading from
        };
    }
}