Folder.h

Go to the documentation of this file.

#pragma once
 
#include <map>
#include <memory>
 
#include "Base.h"
 
namespace Gorgon { namespace Resource {
    class File;
    class Reader;
    class Folder;
 
    class Folder : public Base {
        friend class File;
    public:
 
        Folder() { }
 
        Folder(File &file);
 
 
        Folder(std::weak_ptr<File> file);
 
        virtual ~Folder() { }
 
        
        virtual GID::Type GetGID() const override { return GID::Folder; }
        
 
        
        void Add(Base &resource) { children.Add(resource); }
        
        void Add(Base *resource) { 
            children.Add(resource); }
        
        void Insert(Base &resource, long before) {
            children.Insert(resource, before); 
        }
        
        void Insert(Base *resource, long before) {
            children.Insert(resource, before); 
        }
        
        void MoveBefore(long index, long before) {
            children.MoveBefore(index, before);
        }
        
        void MoveBefore(Base &item, long before) {
            children.MoveBefore(item, before);
        }
        
        void Remove(Base &resource) { children.Remove(resource); }
        
        void Delete(Base &resource) { 
            if(children.FindLocation(resource)==-1) 
                return; 
            
            children.Remove(resource);
 
            if(resource.GetParentPtr()==this)
                setparenttonullptr(resource);
            
            resource.DeleteResource();
        }
 
        int GetCount() const { return children.GetCount(); }
        
        Base &GetItem(int Index) const { return children[Index]; }
        
        Base &GetItemPtr(int Index) const { return children[Index]; }
        
        Base &operator [](int Index) const { return (children[Index]); }
        
        bool Exists(int index) const {
            return index>=0 && index<children.GetCount();
        }
 
        bool Exists(const std::string &name) const {
            return namedlist.count(name)>0;
        }
        
        
        
 
        template <typename T_>
        T_ &Get(int index) const {
            return dynamic_cast<T_&>(children[index]);
        }
        
        template <typename T_>
        T_ &Get(const std::string &name) const {
            if(namedlist.count(name)>0 && dynamic_cast<T_*>(namedlist.at(name)))
                return *dynamic_cast<T_*>(namedlist.at(name));
            else
                throw std::runtime_error("Requested item cannot be found");
        }
 
        template <typename T_>
        T_ *GetPtr(int index) {
            return dynamic_cast<T_*>(&children[index]);
        }
 
        template <typename T_>
        T_ *GetPtr(const std::string &name) const {
            if(namedlist.count(name)==0)
                return nullptr;
            else
                return dynamic_cast<T_*>(namedlist.at(name));
        }
        
 
        
        bool Load(bool shallow=false);
        
        bool IsLoaded() const {
            return fullyloaded;
        }
 
        virtual void Prepare() override;
 
        static Folder *LoadResource(std::weak_ptr<File> file, std::shared_ptr<Reader> data, unsigned long size);
 
    protected:
 
        bool load(std::shared_ptr<Reader> data, unsigned long size, bool first, bool shallow, bool load);
 
        void save(Writer &writer) const override;
 
        unsigned long entrypoint = -1;
 
        bool reallyloadnames = false;
        
        std::map<std::string, Base*> namedlist;
 
        bool fullyloaded = false;
 
        std::weak_ptr<File> file;
 
        std::shared_ptr<Reader> reader;
 
 
    };
 
} }