reader.h

#ifndef READER_H
#define READER_H
 
#include <cstring>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include "../common.h"
 
namespace Linker
{
    class ReadOverflow
    {
    };
 
    class Reader : public std::enable_shared_from_this<Reader>
    {
    public:
        EndianType endiantype;
 
        enum OverflowHandlingMode
        {
            IgnoreOnOverflow,
            ReportOnOverflow,
            TerminateOnOverflow,
        };
        OverflowHandlingMode on_overflow = TerminateOnOverflow;
 
        enum class OverflowHandlingRequest
        {
            Default,
            Force,
            Report,
        };
        static OverflowHandlingRequest global_overflow_behavior;
 
        inline OverflowHandlingMode GetActionOnOverflow()
        {
            switch(global_overflow_behavior)
            {
            case OverflowHandlingRequest::Default:
            default:
                return on_overflow;
            case OverflowHandlingRequest::Force:
                return IgnoreOnOverflow;
            case OverflowHandlingRequest::Report:
                return TerminateOnOverflow;
            }
        }
 
        Reader(EndianType endiantype)
            : endiantype(endiantype)
        {
        }
 
        std::shared_ptr<Reader> CreateWindow(offset_t new_start_offset, offset_t new_maximum_size = offset_t(-1), offset_t displacement = 0);
 
        virtual ~Reader() = default;
 
        virtual size_t Read(void * data, size_t max_count = size_t(-1)) = 0;
 
        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);
 
        template <typename Clock>
            Timestamp<Clock> ReadTimestamp(EndianType endiantype)
        {
            if constexpr(std::is_signed_v<typename Clock::rep>)
                return Clock::to_time_point(ReadSigned(sizeof(typename Clock::rep), endiantype));
            else
                return Clock::to_time_point(ReadUnsigned(sizeof(typename Clock::rep), endiantype));
        }
 
        template <typename Clock>
            Timestamp<Clock> ReadTimestamp()
        {
            if constexpr(std::is_signed_v<typename Clock::rep>)
                return Clock::to_time_point(ReadSigned(sizeof(typename Clock::rep)));
            else
                return Clock::to_time_point(ReadUnsigned(sizeof(typename Clock::rep)));
        }
 
        virtual void Seek(offset_t offset) = 0;
 
        virtual void Skip(relative_offset_t offset) = 0;
 
        virtual void SeekEnd(relative_offset_t offset = 0) = 0;
 
        virtual offset_t Tell() = 0;
 
        virtual offset_t GetImageEnd();
 
        offset_t GetRemainingCount();
    };
 
    class StreamReader : public Reader
    {
    public:
        std::istream * in;
 
        StreamReader(EndianType endiantype, std::istream * in = nullptr)
            : Reader(endiantype), in(in)
        {
        }
 
        StreamReader(EndianType endiantype, std::istream& in)
            : Reader(endiantype), in(&in)
        {
        }
 
        size_t Read(void * data, size_t max_count = size_t(-1)) override;
        void Seek(offset_t offset) override;
        void Skip(relative_offset_t offset) override;
        void SeekEnd(relative_offset_t offset = 0) override;
        offset_t Tell() override;
    };
 
    class WindowReader : public Reader
    {
    public:
        std::shared_ptr<Reader> reader;
 
        offset_t start_offset;
        offset_t maximum_size;
        offset_t window_offset;
 
        // The WindowReader offsets [window_offset, window_offset + maximum_size) is mapped to [start_offset, start_offset + maximum_size)
        // everything outside the window is treated as out of bounds
 
    protected:
        void _ValidateParameters()
        {
            if(maximum_size != offset_t(-1))
            {
                assert(start_offset <= offset_t(-1) - maximum_size);
                assert(window_offset <= offset_t(-1) - maximum_size);
            }
        }
 
        void _ShiftStartOffset(offset_t addend)
        {
            if(window_offset > addend)
            {
                window_offset -= addend;
            }
            else
            {
                if(maximum_size != offset_t(-1) && maximum_size <= addend - window_offset)
                {
                    maximum_size = 0;
                }
                else
                {
                    maximum_size -= addend - window_offset;
                    start_offset += addend - window_offset; // TODO: overflow
                }
                window_offset = 0;
            }
 
            _ValidateParameters();
        }
 
        void _RestrictMaximumSize(offset_t new_maximum)
        {
            if(new_maximum < maximum_size)
            {
                maximum_size = new_maximum;
                _ValidateParameters();
            }
        }
 
        void _AddDisplacement(offset_t displacement)
        {
            window_offset += displacement; // TODO: overflow
            _ValidateParameters();
        }
 
        static std::shared_ptr<Reader> _GetReader(std::shared_ptr<Reader> reader)
        {
            if(auto window_reader = std::dynamic_pointer_cast<WindowReader>(reader))
            {
                return window_reader->reader;
            }
            else
            {
                return reader;
            }
        }
 
        static offset_t _GetStartOffset(std::shared_ptr<Reader> reader)
        {
            if(auto window_reader = std::dynamic_pointer_cast<WindowReader>(reader))
            {
                return window_reader->start_offset;
            }
            else
            {
                return 0;
            }
        }
 
        static offset_t _GetMaximumSize(std::shared_ptr<Reader> reader)
        {
            if(auto window_reader = std::dynamic_pointer_cast<WindowReader>(reader))
            {
                return window_reader->maximum_size;
            }
            else
            {
                return offset_t(-1);
            }
        }
 
        static offset_t _GetWindowOffset(std::shared_ptr<Reader> reader)
        {
            if(auto window_reader = std::dynamic_pointer_cast<WindowReader>(reader))
            {
                return window_reader->window_offset;
            }
            else
            {
                return 0;
            }
        }
 
    public:
        WindowReader(EndianType endiantype, std::shared_ptr<Reader> reader, offset_t start_offset, offset_t maximum_size, offset_t displacement = 0)
            : Reader(endiantype), reader(_GetReader(reader)), start_offset(_GetStartOffset(reader)), maximum_size(_GetMaximumSize(reader)), window_offset(_GetWindowOffset(reader))
        {
            _ShiftStartOffset(start_offset);
            _RestrictMaximumSize(maximum_size);
            _AddDisplacement(displacement);
        }
 
        WindowReader(std::shared_ptr<Reader> reader, offset_t start_offset, offset_t maximum_size, offset_t displacement = 0)
            : Reader(reader->endiantype), reader(_GetReader(reader)), start_offset(_GetStartOffset(reader)), maximum_size(_GetMaximumSize(reader)), window_offset(_GetWindowOffset(reader))
        {
            _ShiftStartOffset(start_offset);
            _RestrictMaximumSize(maximum_size);
            _AddDisplacement(displacement);
        }
 
        size_t Read(void * data, size_t max_count = size_t(-1)) override;
        void Seek(offset_t offset) override;
        void Skip(relative_offset_t offset) override;
        void SeekEnd(relative_offset_t offset = 0) override;
        offset_t Tell() override;
 
        offset_t GetImageEnd() override;
    };
 
    class Image;
 
    // TODO: untested
    class ImageReader : public Reader
    {
    public:
        std::shared_ptr<Image> image;
        offset_t position = 0;
 
        ImageReader(EndianType endiantype, std::shared_ptr<Image> image)
            : Reader(endiantype), image(image)
        {
        }
 
        size_t Read(void * data, size_t max_count = size_t(-1)) override;
        void Seek(offset_t offset) override;
        void Skip(relative_offset_t offset) override;
        void SeekEnd(relative_offset_t offset = 0) override;
        offset_t Tell() override;
 
        offset_t GetImageEnd() override;
    };
}
 
#endif /* READER_H */