PoolImpl.h

Go to the documentation of this file.
00001 /*---------------------------------------------------------------------\
00002 |                          ____ _   __ __ ___                          |
00003 |                         |__  / \ / / . \ . \                         |
00004 |                           / / \ V /|  _/  _/                         |
00005 |                          / /__ | | | | | |                           |
00006 |                         /_____||_| |_| |_|                           |
00007 |                                                                      |
00008 \---------------------------------------------------------------------*/
00012 #ifndef ZYPP_POOL_POOLIMPL_H
00013 #define ZYPP_POOL_POOLIMPL_H
00014 
00015 #include <iosfwd>
00016 #include <map>
00017 
00018 #include "zypp/pool/PoolTraits.h"
00019 #include "zypp/ResPoolProxy.h"
00020 #include "zypp/ZYppFactory.h"
00021 
00023 namespace zypp
00024 { 
00025 
00026   namespace pool
00027   { 
00028 
00029 
00031     //
00032     //  CLASS NAME : NameHash
00033     //
00035     class NameHash
00036     {
00037     public:
00039       NameHash();
00041       ~NameHash();
00042 
00043       public:
00044 
00045       typedef PoolTraits::ItemContainerT        ItemContainerT;
00046       typedef PoolTraits::NameItemContainerT    ContainerT;
00047       typedef PoolTraits::size_type             size_type;
00048       typedef PoolTraits::iterator              iterator;
00049       typedef PoolTraits::const_iterator        const_iterator;
00050 
00051       private:
00052         ItemContainerT & getItemContainer( const std::string & tag_r );
00053         const ItemContainerT & getConstItemContainer( const std::string & tag_r ) const;
00054 
00055       public:
00057       ContainerT & store()
00058       { return _store; }
00060       const ContainerT & store() const
00061       { return _store; }
00062 
00064       bool empty() const
00065       { return _store.empty(); }
00067       size_type size() const
00068       { return _store.size(); }
00069 
00071       iterator begin( const std::string & tag_r )
00072       { return getItemContainer( tag_r ).begin(); }
00074       const_iterator begin( const std::string & tag_r ) const
00075       { return getConstItemContainer( tag_r ).begin(); }
00076 
00078       iterator end( const std::string & tag_r )
00079       { return getItemContainer( tag_r ).end(); }
00081       const_iterator end( const std::string & tag_r ) const
00082       { return getConstItemContainer( tag_r ).end(); }
00083 
00085       void clear()
00086       { _store.clear(); }
00087 
00089       void insert( const PoolItem & item_r );
00091       void erase( const PoolItem & item_r );
00092 
00093       private:
00094         ContainerT _store;
00095         ItemContainerT _empty;  // for begin(), end() if tag_r can't be found
00096     };
00097 
00099     //
00100     //  CLASS NAME : CapHash
00101     //
00103     class CapHash
00104     {
00105     public:
00107       CapHash();
00109       ~CapHash();
00110 
00111       public:
00112 
00113       typedef PoolTraits::DepCapItemContainerT  ContainerT;
00114       typedef PoolTraits::capitemsize_type      size_type;
00115       typedef PoolTraits::capitemiterator       iterator;
00116       typedef PoolTraits::const_capitemiterator const_iterator;
00117 
00118       private:
00119 
00120       typedef PoolTraits::CapItemStoreT         CapItemStoreT;
00121       typedef PoolTraits::CapItemContainerT     CapItemContainerT;
00122 
00123       // Dep -> CapItemStoreT
00124       const CapItemStoreT & capItemStore ( Dep cap_r ) const;
00125 
00126       // CapItemStoreT, index -> CapItemContainerT
00127       const CapItemContainerT & capItemContainer( const CapItemStoreT & cis, const std::string & tag_r ) const;
00128 
00129       public:
00130 
00132       ContainerT & store()
00133       { return _store; }
00135       const ContainerT & store() const
00136       { return _store; }
00137 
00139       bool empty() const
00140       { return _store.empty(); }
00142       size_type size() const
00143       { return _store.size(); }
00144 
00146       iterator begin( const std::string & tag_r, Dep cap_r )
00147       { return _store[cap_r][tag_r].begin(); }
00149       const_iterator begin( const std::string & tag_r, Dep cap_r ) const
00150       { const CapItemStoreT & capitemstore = capItemStore( cap_r );
00151         const CapItemContainerT & capcontainer = capItemContainer ( capitemstore, tag_r );
00152         return capcontainer.begin(); }
00153 
00155       iterator end( const std::string & tag_r, Dep cap_r )
00156       { return _store[cap_r][tag_r].begin(); }
00158       const_iterator end( const std::string & tag_r, Dep cap_r ) const
00159       { const CapItemStoreT & capitemstore = capItemStore( cap_r );
00160         const CapItemContainerT & capcontainer = capItemContainer ( capitemstore, tag_r );
00161         return capcontainer.end(); }
00162 
00164       void clear()
00165       { _store.clear(); }
00166 
00168       void insert( const PoolItem & item_r );
00170       void erase( const PoolItem & item_r );
00171 
00172       private:
00173         PoolTraits::DepCapItemContainerT _store;
00174     };
00175 
00177     //
00178     //  CLASS NAME : PoolImpl
00179     //
00181     class PoolImpl
00182     {
00183       friend std::ostream & operator<<( std::ostream & str, const PoolImpl & obj );
00184 
00185     public:
00187     typedef PoolTraits::Item                    Item;
00188     typedef PoolTraits::ItemContainerT          ContainerT;
00189     typedef PoolTraits::iterator                iterator;
00190     typedef PoolTraits::const_iterator          const_iterator;
00191     typedef PoolTraits::size_type               size_type;
00192     typedef PoolTraits::Inserter                Inserter;
00193     typedef PoolTraits::Deleter                 Deleter;
00194 
00195     public:
00197       PoolImpl();
00199       ~PoolImpl();
00200 
00202       Arch targetArch() const
00203       { return getZYpp()->architecture(); }
00204 
00205     public:
00207       ContainerT & store()
00208       { return _store; }
00210       const ContainerT & store() const
00211       { return _store; }
00212 
00214       bool empty() const
00215       { return _store.empty(); }
00217       size_type size() const
00218       { return _store.size(); }
00219 
00221       iterator begin()
00222       { return _store.begin(); }
00224       const_iterator begin() const
00225       { return _store.begin(); }
00226 
00228       iterator end()
00229       { return _store.end(); }
00231       const_iterator end() const
00232       { return _store.end(); }
00233 
00235       void clear()
00236       { _store.clear();
00237         _caphash.clear();
00238         _namehash.clear();
00239         return;
00240       }
00241 
00243       void eraseInstalled() const;
00244 
00245     public:
00248       void SaveState( const ResObject::Kind & kind_r );
00249 
00250       void RestoreState( const ResObject::Kind & kind_r );
00252 
00253     public:
00255       ContainerT _store;
00256       NameHash _namehash;
00257       CapHash _caphash;
00258 
00259     public:
00260       ResPoolProxy proxy( ResPool self ) const
00261       {
00262         if ( !_poolProxy )
00263           _poolProxy.reset( new ResPoolProxy( self ) );
00264         return *_poolProxy;
00265       }
00266       void invalidateProxy()
00267       { _poolProxy.reset(); }
00268 
00269       mutable shared_ptr<ResPoolProxy> _poolProxy;
00270     };
00272 
00274     std::ostream & operator<<( std::ostream & str, const PoolImpl & obj );
00275 
00277   } // namespace pool
00280 } // namespace zypp
00282 #endif // ZYPP_POOL_POOLIMPL_H

Generated on Thu Jul 6 00:07:22 2006 for zypp by  doxygen 1.4.6