File.h

Go to the documentation of this file.

#pragma once
 
#include <stdexcept>
#include <iostream>
#include <fstream>
#include <functional>
#include <map>
#include <memory>
 
#include "../Utils/Assert.h"
#include "Base.h"
#include "Folder.h"
#include "../Filesystem.h"
#include "../IO/Stream.h"
 
#include "Reader.h"
#include "Writer.h"
 
namespace Gorgon { namespace Resource {
 
    class Loader {
    public:
        typedef std::function<Base* (std::weak_ptr<File>, std::shared_ptr<Reader>, unsigned long)> LoaderFunction;
 
        Loader(GID::Type gid, LoaderFunction handler) : GID(gid), Handler(handler) { }
 
        Loader() : GID(Resource::GID::None) { }
 
        Resource::GID::Type GID;
 
        LoaderFunction Handler;
    };
 
 
    class File {
    public:
 
        File();
 
        virtual ~File() {
            delete root;
        }
 
        Folder &Root() { return *root; }
 
        std::unique_ptr<Folder> Release() { 
            std::unique_ptr<Folder> r(root);
            root=new Folder; 
 
            return r;
        }
 
        void Prepare() {
            root->Prepare();
        }
 
        void Discard() {
            root->Discard();
 
            decltype(mapping) temp;
            mapping.swap(temp);
        }
 
        void Destroy() {
            delete root;
            root=new Folder(*this);
            fileversion=0;
            filetype=GID::None;
        }
 
 
        void LoadFile(const std::string &filename) { 
            createfilereader(filename);
 
            load(false, false); 
        }
 
        void LoadFirst(const std::string &filename) { 
            createfilereader(filename);
 
            load(true, false);
        }
 
        void LoadShallow(const std::string &filename) { 
            createfilereader(filename);
 
            load(false, true);
        }
        
        void Save(const std::string &filename) {
            writer.reset(new FileWriter(filename));
            save();
            writer->Close();
        }
        
 
        Base *LoadChunk(Base &self, GID::Type gid, unsigned long size, bool skipobjects=false);
 
 
        Base *LoadChunk(GID::Type gid, unsigned long size);
 
        
        std::weak_ptr<File> Self() const {
            return self;
        }
 
 
        std::map<GID::Type, Loader>  Loaders;
        
 
        mutable std::map<SGuid, Base*> mapping;
 
 
    protected:
        void load(bool first, bool shallow);
        
        void save() const;
 
        Folder *root;
 
        GID::Type filetype = GID::GameFile;
 
        bool keepopen=false;
 
        unsigned long fileversion;
 
        std::shared_ptr<Reader> reader;
        
        std::shared_ptr<Writer> writer;
 
    private:
        void createfilereader(std::string filename);
        std::shared_ptr<File> self;
    };
} }