Writer.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"
#include "../Geometry/Point.h"
 
namespace Gorgon { namespace Resource {
    
    class Base;
 
    class WriteError : public std::runtime_error {
    public:
        
        enum ErrorType {
            
            Unknown = 0,
            
            CannotOpenFile = 1,
            
            NoData = 2,
        };
        
        
        WriteError(ErrorType number=Unknown) : runtime_error(ErrorStrings[number]), number(number) {
            
        }
        
        WriteError(ErrorType number, const std::string &text) : runtime_error(text), number(number) {
            
        }
        
        ErrorType number;
        
        static const std::string ErrorStrings[3];
    };
    
    class Writer {
        friend class File;
    public:
        
        class Marker {
            friend class Writer;
        public:
            Marker(const Marker &) = delete;
            Marker(Marker &&other) {
                pos = other.pos;
                other.pos = -1;
            }
 
            Marker &operator =(Marker &&other) {
                pos = other.pos;
                other.pos = -1;
 
                return *this;
            }
            
            ~Marker() { 
                if(pos!=-1) 
                    Utils::ASSERT_FALSE("Marker is not ended.");
            }
            
        private:
            Marker(unsigned long pos) : pos(pos) { }
            
            unsigned long pos = -1;
        };
        
        virtual ~Writer() {
            ASSERT(stream==nullptr, "Stream is not closed by the opener");
        }
        
        std::ostream &GetStream() {
            ASSERT(stream, "Writer is not opened.");
            ASSERT(IsGood(), "Writer is failed.");
 
            return *stream;
        }
        
        bool IsGood() const {
            return stream && stream->good();
        }
 
        void Close() {
            close();
            stream = nullptr;
        }
 
        unsigned long Tell() const {
            ASSERT(stream, "Writer is not opened.");
            ASSERT(IsGood(), "Writer is failed.");
 
            return (unsigned long)stream->tellp();
        }
 
        void Seek(unsigned long pos) {
            ASSERT(stream, "Writer is not opened.");
            ASSERT(IsGood(), "Writer is failed.");
 
            stream->seekp((std::streampos)pos, std::ios::beg);
        }
 
 
 
 
        template<class E_>
        void WriteEnum32(E_ value) {
            ASSERT(stream, "Writer is not opened.");
            ASSERT(IsGood(), "Writer is failed.");
 
            IO::WriteEnum32(*stream, value);
        }
 
        void WriteInt32(long value) {
            ASSERT(stream, "Writer is not opened.");
            ASSERT(IsGood(), "Writer is failed.");
 
            IO::WriteInt32(*stream, value);
        }
 
        void WriteUInt32(unsigned long value) {
            ASSERT(stream, "Writer is not opened.");
            ASSERT(IsGood(), "Writer is failed.");
 
            IO::WriteUInt32(*stream, value);
        }
 
        void WriteInt16(int value) {
            ASSERT(stream, "Writer is not opened.");
            ASSERT(IsGood(), "Writer is failed.");
 
            IO::WriteInt16(*stream, value);
        }
 
        void WriteUInt16(unsigned value) {
            ASSERT(stream, "Writer is not opened.");
            ASSERT(IsGood(), "Writer is failed.");
 
            IO::WriteUInt16(*stream, value);
        }
 
        void WriteInt8(char value) {
            ASSERT(stream, "Writer is not opened.");
            ASSERT(IsGood(), "Writer is failed.");
 
            IO::WriteInt8(*stream, value);
        }
 
        void WriteUInt8(Byte value) {
            ASSERT(stream, "Writer is not opened.");
            ASSERT(IsGood(), "Writer is failed.");
 
            IO::WriteUInt8(*stream, value);
        }
 
        void WriteFloat(float value) {
            ASSERT(stream, "Writer is not opened.");
            ASSERT(IsGood(), "Writer is failed.");
 
            IO::WriteFloat(*stream, value);
        }
 
        void WriteDouble(double value) {
            ASSERT(stream, "Writer is not opened.");
            ASSERT(IsGood(), "Writer is failed.");
 
            IO::WriteDouble(*stream, value);
        }
 
        void WriteBool(bool value) {
            ASSERT(stream, "Writer is not opened.");
            ASSERT(IsGood(), "Writer is failed.");
 
            IO::WriteBool(*stream, value);
        }
 
        void WriteRGBA(Graphics::RGBA value) {
            ASSERT(stream, "Writer is not opened.");
            ASSERT(IsGood(), "Writer is failed.");
 
            IO::WriteRGBA(*stream, value);
        }
 
        void WriteRGBAf(Graphics::RGBAf value) {
            ASSERT(stream, "Writer is not opened.");
            ASSERT(IsGood(), "Writer is failed.");
 
            IO::WriteRGBAf(*stream, value);
        }
        
        void WritePoint(Geometry::Point value) {
            ASSERT(stream, "Writer is not opened.");
            ASSERT(IsGood(), "Writer is failed.");
 
            IO::WritePoint(*stream, value);
        }
        void WritePointf(Geometry::Pointf value) {
            ASSERT(stream, "Writer is not opened.");
            ASSERT(IsGood(), "Writer is failed.");
 
            IO::WritePointf(*stream, value);
        }
        
        void WriteSize(Geometry::Size value) {
            ASSERT(stream, "Writer is not opened.");
            ASSERT(IsGood(), "Writer is failed.");
 
            IO::WriteSize(*stream, value);
        }
 
        void WriteStringWithSize(const std::string &value) {
            ASSERT(stream, "Writer is not opened.");
            ASSERT(IsGood(), "Writer is failed.");
 
            IO::WriteStringWithSize(*stream, value);
        }
 
        void WriteString(const std::string &value) {
            ASSERT(stream, "Writer is not opened.");
            ASSERT(IsGood(), "Writer is failed.");
 
            IO::WriteString(*stream, value);
        }
 
        template<class T_>
        void WriteArray(const T_ *data, unsigned long size) {
            ASSERT(stream, "Writer is not opened.");
            ASSERT(IsGood(), "Writer is failed.");
 
            IO::WriteArray<T_>(*stream, data, size);
        }
 
        template<class T_>
        inline void WriteVector(const std::vector<T_> &data) {
            IO::WriteVector(*stream, data);
        }
        
        void WriteGID(GID::Type value) {
            ASSERT(stream, "Writer is not opened.");
            ASSERT(IsGood(), "Writer is failed.");
 
            WriteUInt32(value.AsInteger());
        }
 
        void WriteGuid(const SGuid &value) {
            ASSERT(stream, "Writer is not opened.");
            ASSERT(IsGood(), "Writer is failed.");
 
            IO::WriteGuid(*stream, value);
        }
        
        void WriteChunkSize(unsigned long value) {
            ASSERT(stream, "Writer is not opened.");
            ASSERT(IsGood(), "Writer is failed.");
 
            WriteUInt32(value);
        }
        
        
        
        Marker WriteObjectStart(const Base &base);
        
        
        Marker WriteObjectStart(const Base *base) {
            ASSERT(base, "Object cannot be nullptr");
            return WriteObjectStart(*base);
        }
        
        Marker WriteObjectStart(const Base &base, GID::Type type);
        
        Marker WriteObjectStart(const Base *base, GID::Type type) {
            ASSERT(base, "Object cannot be nullptr");
            return WriteObjectStart(*base, type);
        }
        
        Marker WriteChunkStart(GID::Type type) {
            ASSERT(stream, "Writer is not opened.");
            ASSERT(IsGood(), "Writer is failed.");
 
            WriteGID(type);
            auto pos=Tell();
            WriteChunkSize(-1);
 
            return {pos};
        }
        
        void WriteChunkHeader(GID::Type type, unsigned long size) {
            ASSERT(stream, "Writer is not opened.");
            ASSERT(IsGood(), "Writer is failed.");
 
            WriteGID(type);
            WriteChunkSize(size);
        }
        
        void WriteEnd(Marker &marker) {
            ASSERT(stream, "Writer is not opened.");
            ASSERT(IsGood(), "Writer is failed.");
 
            auto pos=Tell();
 
            ASSERT(pos>=marker.pos+4, "Seeking before the start of the file.");
            ASSERT(marker.pos<=pos, "Marker is after the current position.");
            
            auto size=pos-marker.pos-4;
            
            Seek(marker.pos);
            WriteChunkSize(size);
            Seek(pos);
            
            marker.pos=-1;
        }
        
    protected:
        virtual void close() = 0;
 
        virtual bool open(bool thrw) = 0;
 
        std::ostream *stream = nullptr;
 
    };
    
    
    class FileWriter : public Writer {
    public:
        FileWriter(const std::string &filename) : filename(filename) {
            try {
                auto path=Filesystem::GetDirectory(filename);
                auto file=Filesystem::GetFilename(filename);
                
                this->filename=Filesystem::Join(Filesystem::Canonical(path), file);
            }
            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 WriteError(WriteError::CannotOpenFile, "Cannot open file: "+filename+" either target path does not exist or access denied.");
                }
                
                return false;
            }
            
            stream = &file;
            
            return true;
        }
    
    private:
        std::ofstream file;
        std::string filename;
    };
    
} }