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