buffer.h

#ifndef BUFFER_H
#define BUFFER_H
 
#include <algorithm>
#include <iostream>
#include <string>
#include <variant>
#include <vector>
#include "../common.h"
#include "image.h"
 
namespace Linker
{
    class Reader;
    class Segment;
    class Writer;
 
    class Buffer : public Image
    {
    protected:
        std::vector<uint8_t> data;
 
    public:
        Buffer() = default;
 
        Buffer(size_t size)
        {
            data.resize(size);
        }
 
        Buffer(const std::vector<uint8_t>& data)
            : data(data)
        {
        }
 
        offset_t ImageSize() const override;
        void Resize(offset_t new_size);
        virtual offset_t Expand(offset_t new_size);
        virtual offset_t WriteData(size_t bytes, offset_t offset, const void * buffer);
        virtual offset_t WriteWord(size_t bytes, offset_t offset, uint64_t value, EndianType endiantype);
 
        offset_t WriteWord(size_t bytes, offset_t offset, uint64_t value);
 
        offset_t WriteWord(size_t bytes, uint64_t value, EndianType endiantype);
 
        offset_t WriteWord(size_t bytes, uint64_t value);
 
        virtual offset_t Append(const void * new_data, size_t length);
 
        offset_t Append(const char * new_data);
 
        offset_t Append(std::vector<uint8_t>& additional_data);
 
        virtual void ReadFile(const std::shared_ptr<Reader>& rd);
        void ReadFileRemaining(const std::shared_ptr<Reader>& rd);
        void ReadFile(const std::shared_ptr<Reader>& rd, offset_t count);
        static std::shared_ptr<Buffer> ReadFromFile(const std::shared_ptr<Reader>& rd);
        static std::shared_ptr<Buffer> ReadFromFile(const std::shared_ptr<Reader>& rd, offset_t count);
        using Contents::WriteFile;
        offset_t WriteFile(const std::shared_ptr<Writer>& wr, offset_t count, offset_t offset = 0) const override;
        size_t ReadData(size_t bytes, offset_t offset, void * buffer) const override;
 
        friend class Section;
        friend class Contents;
    };
}
 
#endif /* BUFFER_H */