Reader.h

Go to the documentation of this file.

#pragma once
 
#include <stdexcept>
#include <iostream>
#include <fstream>
#include <map>
#include <memory>
 
#include "../Utils/Assert.h"
#include "../Filesystem.h"
#include "../IO/Stream.h"
 
namespace Gorgon { namespace Resource {
 
    class LoadError : public std::runtime_error {
    public:
 
        enum ErrorType {
            Unknown         = 0,
 
            FileNotFound    = 1,
 
            Signature       = 2,
 
            VersionMismatch = 3,
 
            Containment     = 4,
 
            UnknownNode     = 5,
 
            FileCannotBeOpened = 6,
 
            NoFileObject = 7,
 
            UnsupportedCompression = 8,
        };
 
        LoadError(ErrorType number=Unknown) : runtime_error(ErrorStrings[number]), number(number) {
 
        }
 
        LoadError(ErrorType number, const std::string &text) : runtime_error(text), number(number) {
 
        }
 
        ErrorType number;
 
        static const std::string ErrorStrings[8];
    };
 
    class Reader {
    public:
 
        class Mark {
        public:
            Mark(Reader &reader, unsigned long target) :
                reader(&reader), target(target) {}
 
            Mark(const Mark &) = default;
 
            explicit operator bool() const {
                auto pos=reader->Tell();
                if(pos<target) return false;
 
                ASSERT(pos==target, "Reading operation passed the target.");
 
                return true;
            }
 
            unsigned long Tell() const {
                return target;
            }
 
        private:
            Reader *reader;
            unsigned long target;
        };
 
        Reader() {}
 
        virtual ~Reader() {}
 
        void KeepOpen() {
            keepopenrequests++;
        }
 
        void NoLongerNeeded() {
            if(--keepopenrequests) {
                close();
                stream=nullptr;
            }
        }
 
        void Open() {
            if(!stream) {
                open(true);
            }
 
            ASSERT(stream, "Reader did not set the stream.");
        }
 
        bool IsOpen() const {
            return stream;
        }
 
        bool IsGood() const {
            return stream && stream->good();
        }
 
        bool IsFailed() const {
            return stream && stream->fail();
        }
 
        bool TryOpen() {
            if(!stream) {
                return open(false);
            }
 
            return true;
        }
 
 
        std::istream &GetStream() {
            ASSERT(stream, "Reader is not opened.");
 
            return *stream;
        }
 
        unsigned long Tell() const {
            ASSERT(stream, "Reader is not opened.");
            ASSERT(!IsFailed(), "Reader is failed.");
 
            return (unsigned long)stream->tellg();
        }
 
        void Seek(unsigned long pos) {
            ASSERT(stream, "Reader is not opened.");
            ASSERT(!IsFailed(), "Reader is failed.");
 
            stream->seekg((std::streampos)pos, std::ios::beg);
        }
 
        void Seek(const Mark &pos) {
            ASSERT(stream, "Reader is not opened.");
            ASSERT(!IsFailed(), "Reader is failed.");
 
            stream->seekg((std::streampos)pos.Tell(), std::ios::beg);
        }
 
        Mark Target(unsigned long delta) {
            return Mark(*this, Tell()+delta);
        }
 
        bool ReadCommonChunk(Base &self, GID::Type gid, unsigned long size);
 
 
        template<class E_>
        E_ ReadEnum32() {
            ASSERT(stream, "Reader is not opened.");
            ASSERT(IsGood(), "Reader is failed.");
 
            return IO::ReadEnum32<E_>(*stream);
        }
 
        long ReadInt32() {
            ASSERT(stream, "Reader is not opened.");
            ASSERT(IsGood(), "Reader is failed.");
 
            return IO::ReadInt32(*stream);
        }
 
        unsigned long ReadUInt32() {
            ASSERT(stream, "Reader is not opened.");
            ASSERT(IsGood(), "Reader is failed.");
 
            return IO::ReadUInt32(*stream);
        }
 
        int ReadInt16() {
            ASSERT(stream, "Reader is not opened.");
            ASSERT(IsGood(), "Reader is failed.");
 
            return IO::ReadInt16(*stream);
        }
 
        unsigned ReadUInt16() {
            ASSERT(stream, "Reader is not opened.");
            ASSERT(IsGood(), "Reader is failed.");
 
            return IO::ReadUInt16(*stream);
        }
 
        char ReadInt8() {
            ASSERT(stream, "Reader is not opened.");
            ASSERT(IsGood(), "Reader is failed.");
 
            return IO::ReadInt8(*stream);
        }
 
        Byte ReadUInt8() {
            ASSERT(stream, "Reader is not opened.");
            ASSERT(IsGood(), "Reader is failed.");
 
            return IO::ReadUInt8(*stream);
        }
 
        float ReadFloat() {
            ASSERT(stream, "Reader is not opened.");
            ASSERT(IsGood(), "Reader is failed.");
 
            return IO::ReadFloat(*stream);
        }
 
        double ReadDouble() {
            ASSERT(stream, "Reader is not opened.");
            ASSERT(IsGood(), "Reader is failed.");
 
            return IO::ReadDouble(*stream);
        }
 
        bool ReadBool() {
            ASSERT(stream, "Reader is not opened.");
            ASSERT(IsGood(), "Reader is failed.");
 
            return IO::ReadBool(*stream);
        }
 
        Graphics::RGBA ReadRGBA() {
            ASSERT(stream, "Reader is not opened.");
            ASSERT(IsGood(), "Reader is failed.");
 
            return IO::ReadRGBA(*stream);
        }
 
        Graphics::RGBAf ReadRGBAf() {
            ASSERT(stream, "Reader is not opened.");
            ASSERT(IsGood(), "Reader is failed.");
 
            return IO::ReadRGBAf(*stream);
        }
 
        std::string ReadString() {
            ASSERT(stream, "Reader is not opened.");
            ASSERT(IsGood(), "Reader is failed.");
 
            return IO::ReadString(*stream);
        }
 
        std::string ReadString(unsigned long size) {
            ASSERT(stream, "Reader is not opened.");
            ASSERT(IsGood(), "Reader is failed.");
 
            return IO::ReadString(*stream, size);
        }
 
        template<class T_>
        void ReadArray(T_ *data, unsigned long size) {
            ASSERT(stream, "Reader is not opened.");
            ASSERT(IsGood(), "Reader is failed.");
 
            IO::ReadArray<T_>(*stream, data, size);
        }
 
        GID::Type ReadGID() {
            ASSERT(stream, "Reader is not opened.");
            ASSERT(IsGood(), "Reader is failed.");
 
            return GID::Type(ReadUInt32());
        }
 
        SGuid ReadGuid() {
            ASSERT(stream, "Reader is not opened.");
            ASSERT(IsGood(), "Reader is failed.");
 
            return IO::ReadGuid(*stream);
        }
 
        Geometry::Point ReadPoint() {
            ASSERT(stream, "Reader is not opened.");
            ASSERT(IsGood(), "Reader is failed.");
 
            return IO::ReadPoint(*stream);
        }
        
        Geometry::Point ReadPointf() {
            ASSERT(stream, "Reader is not opened.");
            ASSERT(IsGood(), "Reader is failed.");
 
            return IO::ReadPointf(*stream);
        }
        
        Geometry::Size ReadSize() {
            ASSERT(stream, "Reader is not opened.");
            ASSERT(IsGood(), "Reader is failed.");
 
            return IO::ReadSize(*stream);
        }
 
        unsigned long ReadChunkSize() {
            ASSERT(stream, "Reader is not opened.");
            ASSERT(IsGood(), "Reader is failed.");
 
            return ReadUInt32();
        }
 
        void EatChunk(long size) {
            ASSERT(stream, "Reader is not opened.");
            ASSERT(IsGood(), "Reader is failed.");
 
            stream->seekg(size, std::ios::cur);
        }
 
        void EatChunk() {
            ASSERT(stream, "Reader is not opened.");
            ASSERT(IsGood(), "Reader is failed.");
 
            long size=ReadUInt32();
            stream->seekg(size, std::ios::cur);
        }
 
 
    protected:
        virtual void close() = 0;
 
        virtual bool open(bool thrw) = 0;
 
        std::istream *stream = nullptr;
 
    private:
        int keepopenrequests = 0;
    };
 
    class FileReader : public Reader {
    public:
        FileReader(const std::string &filename) : filename(filename) {
            try {
                this->filename=Filesystem::Canonical(filename);
            }
            catch(...) {}
        }
 
 
    protected:
        virtual void close() override {
            file.close();
        }
 
        virtual bool open(bool thrw) override {
            file.open(filename, std::ios::binary);
 
            if(!file.is_open()) {
                if(thrw) {
                    throw LoadError(LoadError::FileNotFound, "Cannot open file: "+filename);
                }
 
                return false;
            }
 
            stream = &file;
            this->filename=Filesystem::Canonical(filename);
 
            return true;
        }
 
    private:
        std::string filename;
        std::ifstream file;
    };
 
} }