Archive.hpp

Go to the documentation of this file.

#ifdef ETK_BUILD_MINIZIP

#include <etk/types.hpp>

#pragma once

#include <map>
#include <mutex>
#include <ememory/memory.hpp>

namespace etk {
    class ArchiveContent {
        private:
            int32_t m_link; 
        public:
            void increaseRef() {
                m_link++;
            }
            void decreaseRef() {
                m_link--;
            }
            int32_t getNumberOfRef() const {
                return m_link;
            }
        private:
            int32_t m_theoricSize; 
        public:
            int32_t getTheoricSize() const {
                return m_theoricSize;
            }
        private:
            std::vector<char> m_data; 
        public:
            ArchiveContent(int32_t _basicSize=0) :
              m_link(-1),
              m_theoricSize(_basicSize) {
                
            }
            int32_t size() const {
                return m_data.size();
            }
            void* data() const {
                return (void*)&m_data[0];
            }
            std::vector<char>& getDataVector() {
                return m_data;
            }
    };
    class Archive {
        private:
            mutable std::mutex m_mutex; 
        public:
            Archive(const std::string& _fileName) :
              m_fileName(_fileName) {
                
            };
            virtual ~Archive() = default;
        protected:
            std::string m_fileName; 
        public:
            const std::string& getFileName() {
                return m_fileName;
            };
        protected:
            std::map<std::string, ArchiveContent> m_content; 
        public:
            int32_t size() const {
                return m_content.size();
            };
            const std::string& getName(size_t _id) const;
            const ArchiveContent& getContent(size_t _id) const;
            const ArchiveContent& getContent(const std::string& _key) const;
            bool exist(const std::string& _key) const;
            void open(const std::string& _key);
            void close(const std::string& _key);
            void display();
        protected:
            virtual void loadFile(const std::map<std::string, ArchiveContent>::iterator& _it) { };
        public:
            static Archive* load(const std::string& _fileName);
            static Archive* loadPackage(const std::string& _fileName);
    };
}
#endif