Archive.h

Go to the documentation of this file.

#ifndef ARXX_ARCHIVE_H
#define ARXX_ARCHIVE_H

#include <map>
#include <vector>

#include "Common.h"

namespace Arxx
{
    class Item;
    
    class ItemFactory;
    
    class LocalArchiveChannel;
    
    class Reference;
    
    class ReferenceImplementation;
    
    class Rule;
    
    class URI;
    
    class Archive
    {
    public:
        class iterator
        {
        public:
            iterator(std::map< Arxx::u4byte, Arxx::Item * >::iterator iItem);
            
            ~iterator(void);
            
            iterator & operator++(void);
            
            Arxx::Item & operator*(void);
            
            const Arxx::Item & operator*(void) const;
            
            Arxx::Item * operator->(void);
            
            bool operator==(const Arxx::Archive::iterator & iItem) const;
            
            bool operator!=(const Arxx::Archive::iterator & iItem) const;
        private:
            std::map< Arxx::u4byte, Arxx::Item * >::iterator m_iItem;
        };
        
        class const_iterator
        {
        public:
            const_iterator(std::map< Arxx::u4byte, Arxx::Item * >::const_iterator iItem);
            
            ~const_iterator(void);
            
            const_iterator & operator++(void);
            
            const Arxx::Item & operator*(void) const;
            
            const Arxx::Item * operator->(void) const;
            
            bool operator==(const Arxx::Archive::const_iterator & iItem) const;
            
            bool operator!=(const Arxx::Archive::const_iterator & iItem) const;
        private:
            std::map< Arxx::u4byte, Arxx::Item * >::const_iterator m_iItem;
        };
        
        typedef std::map< Arxx::u4byte, Arxx::Item * >::size_type size_type;
        
        Archive(void);
        
        Archive(Arxx::ItemFactory & ItemFactory);
        
        virtual ~Archive(void);
        
        bool bLoad(Arxx::URI URI);
        
        bool bMerge(Arxx::Archive & Archive, std::vector< Arxx::Rule * > & Rules);
        
        void vSave(Arxx::URI URI, bool bAutoCompress = false);
        
        void vClose(void);
        
        void vRegisterItem(Arxx::Item & Item);
        
        void vUnregisterItem(Arxx::Item & Item);
        
        void vSetRootItem(Item * pItem);
        
        Arxx::ItemFactory * pGetItemFactory(void);
        
        Arxx::Item * pGetItem(Arxx::u4byte u4UniqueID);
        
        const Arxx::Item * pGetItem(Arxx::u4byte u4UniqueID) const;
        
        Arxx::Item * pGetRootItem(void);
        
        const Arxx::Item * pGetRootItem(void) const;
        
        Arxx::Reference GetReference(Arxx::u4byte u4UniqueID);
        
        Arxx::Archive::iterator begin(void);
        
        Arxx::Archive::iterator end(void);
        
        Arxx::Archive::const_iterator begin(void) const;
        
        Arxx::Archive::const_iterator end(void) const;
        
        Arxx::Archive::size_type size(void) const;
        
        Arxx::u4byte u4GetNumberOfReferences(void) const;
        
        void vReleaseReference(Arxx::ReferenceImplementation * pReference);
    private:
        Archive(const Archive & Archive);
        
        Archive & operator=(const Archive & Archive);
        
        void vRead(Arxx::LocalArchiveChannel * pLocalArchiveChannel, Arxx::u4byte u4ItemCount);
        
        std::map< Arxx::u4byte, Arxx::Item * > m_Items;
        std::map< Arxx::u4byte, Arxx::Reference > m_References;
        Arxx::Item * m_pRootItem;
        Arxx::ItemFactory * m_pItemFactory;
    };
}

#endif

---