reader.h

#ifndef READER_H
#define READER_H
 
#include <cstring>
#include <iostream>
#include <string>
#include <vector>
#include "../common.h"
 
namespace Linker
{
    class ReadOverflow
    {
    };
 
    class Reader
    {
    public:
        EndianType endiantype;
        std::istream * in;
 
        enum OverflowHandlingMode
        {
            IgnoreOnOverflow,
            ReportOnOverflow,
            TerminateOnOverflow,
        };
        OverflowHandlingMode on_overflow = TerminateOnOverflow;
 
        const offset_t start_offset;
        const offset_t maximum_size;
 
        Reader(EndianType endiantype, std::istream * in = nullptr)
            : endiantype(endiantype), in(in), start_offset(0), maximum_size(offset_t(-1))
        {
        }
 
        Reader(offset_t start_offset, offset_t maximum_size, EndianType endiantype, std::istream * in = nullptr)
            : endiantype(endiantype), in(in), start_offset(start_offset), maximum_size(maximum_size)
        {
        }
 
        Reader CreateWindow(offset_t new_start_offset, offset_t new_maximum_size = offset_t(-1));
 
        void ReadData(size_t count, void * data);
 
        void ReadData(size_t count, std::vector<uint8_t>& data, size_t offset = 0);
 
        void ReadData(std::vector<uint8_t>& data, size_t offset = 0);
 
        std::string ReadData(size_t count, bool terminate_at_null = false);
 
        std::string ReadUTF16Data(size_t count, bool terminate_at_null = false);
 
        template <class T, std::size_t N>
            void ReadData(std::array<T, N>& data, size_t offset = 0)
        {
            if(offset >= N)
                return;
            ReadData(N - offset, reinterpret_cast<char *>(data.data()) + offset);
        }
 
        std::string ReadASCII(char terminator, size_t maximum = size_t(-1));
 
        std::string ReadASCIIZ(size_t maximum = size_t(-1));
 
        std::string ReadUTF16Data(const char terminator[2], size_t maximum = size_t(-1));
 
        std::string ReadUTF16Data(char16_t terminator, size_t maximum, EndianType endiantype);
 
        std::string ReadUTF16Data(char16_t terminator, size_t maximum = size_t(-1));
 
        std::string ReadUTF16Data(char16_t terminator, EndianType endiantype);
 
        std::string ReadUTF16ZData(size_t maximum = size_t(-1));
 
        uint64_t ReadUnsigned(size_t bytes, EndianType endiantype);
 
        uint64_t ReadUnsigned(size_t bytes);
 
        uint64_t ReadSigned(size_t bytes, EndianType endiantype);
 
        uint64_t ReadSigned(size_t bytes);
 
        void Seek(offset_t offset);
 
        void Skip(offset_t offset);
 
        void SeekEnd(relative_offset_t offset = 0);
 
        offset_t Tell();
 
        offset_t GetImageEnd();
 
        offset_t GetRemainingCount();
    };
}
 
#endif /* READER_H */