zypp/pool/PoolImpl.h

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file       zypp/pool/PoolImpl.h
  10  *
  11 */
  12 #ifndef ZYPP_POOL_POOLIMPL_H
  13 #define ZYPP_POOL_POOLIMPL_H
  14
  15 #include <iosfwd>
  16 #include <map>
  17
  18 #include "zypp/pool/PoolTraits.h"
  19 #include "zypp/ResPoolProxy.h"
  20 #include "zypp/ZYppFactory.h"
  21
  22 ///////////////////////////////////////////////////////////////////
  23 namespace zypp
  24 { /////////////////////////////////////////////////////////////////
  25   ///////////////////////////////////////////////////////////////////
  26   namespace pool
  27   { /////////////////////////////////////////////////////////////////
  28
  29
  30     ///////////////////////////////////////////////////////////////////
  31     //
  32     //  CLASS NAME : NameHash
  33     //
  34     /** */
  35     class NameHash
  36     {
  37     public:
  38       /** Default ctor */
  39       NameHash();
  40       /** Dtor */
  41       ~NameHash();
  42
  43       public:
  44
  45       typedef PoolTraits::ItemContainerT        ItemContainerT;
  46       typedef PoolTraits::NameItemContainerT    ContainerT;
  47       typedef PoolTraits::size_type             size_type;
  48       typedef PoolTraits::iterator              iterator;
  49       typedef PoolTraits::const_iterator        const_iterator;
  50
  51       private:
  52         ItemContainerT & getItemContainer( const std::string & tag_r );
  53         const ItemContainerT & getConstItemContainer( const std::string & tag_r ) const;
  54
  55       public:
  56       /**  */
  57       ContainerT & store()
  58       { return _store; }
  59       /**  */
  60       const ContainerT & store() const
  61       { return _store; }
  62
  63       /**  */
  64       bool empty() const
  65       { return _store.empty(); }
  66       /**  */
  67       size_type size() const
  68       { return _store.size(); }
  69
  70       /** */
  71       iterator begin( const std::string & tag_r )
  72       { return getItemContainer( tag_r ).begin(); }
  73       /** */
  74       const_iterator begin( const std::string & tag_r ) const
  75       { return getConstItemContainer( tag_r ).begin(); }
  76
  77       /** */
  78       iterator end( const std::string & tag_r )
  79       { return getItemContainer( tag_r ).end(); }
  80       /** */
  81       const_iterator end( const std::string & tag_r ) const
  82       { return getConstItemContainer( tag_r ).end(); }
  83
  84       /** */
  85       void clear()
  86       { _store.clear(); }
  87
  88       /** */
  89       void insert( const PoolItem & item_r );
  90       /** */
  91       void erase( const PoolItem & item_r );
  92
  93       private:
  94         ContainerT _store;
  95         ItemContainerT _empty;  // for begin(), end() if tag_r can't be found
  96     };
  97
  98     ///////////////////////////////////////////////////////////////////
  99     //
 100     //  CLASS NAME : CapHash
 101     //
 102     /** */
 103     class CapHash
 104     {
 105     public:
 106       /** Default ctor */
 107       CapHash();
 108       /** Dtor */
 109       ~CapHash();
 110
 111       public:
 112
 113       typedef PoolTraits::DepCapItemContainerT  ContainerT;
 114       typedef PoolTraits::capitemsize_type      size_type;
 115       typedef PoolTraits::capitemiterator       iterator;
 116       typedef PoolTraits::const_capitemiterator const_iterator;
 117
 118       private:
 119
 120       typedef PoolTraits::CapItemStoreT         CapItemStoreT;
 121       typedef PoolTraits::CapItemContainerT     CapItemContainerT;
 122
 123       // Dep -> CapItemStoreT
 124       const CapItemStoreT & capItemStore ( Dep cap_r ) const;
 125
 126       // CapItemStoreT, index -> CapItemContainerT
 127       const CapItemContainerT & capItemContainer( const CapItemStoreT & cis, const std::string & tag_r ) const;
 128
 129       public:
 130
 131       /**  */
 132       ContainerT & store()
 133       { return _store; }
 134       /**  */
 135       const ContainerT & store() const
 136       { return _store; }
 137
 138       /**  */
 139       bool empty() const
 140       { return _store.empty(); }
 141       /**  */
 142       size_type size() const
 143       { return _store.size(); }
 144
 145       /** */
 146       iterator begin( const std::string & tag_r, Dep cap_r )
 147       { return _store[cap_r][tag_r].begin(); }
 148       /** */
 149       const_iterator begin( const std::string & tag_r, Dep cap_r ) const
 150       { const CapItemStoreT & capitemstore = capItemStore( cap_r );
 151         const CapItemContainerT & capcontainer = capItemContainer ( capitemstore, tag_r );
 152         return capcontainer.begin(); }
 153
 154       /** */
 155       iterator end( const std::string & tag_r, Dep cap_r )
 156       { return _store[cap_r][tag_r].begin(); }
 157       /** */
 158       const_iterator end( const std::string & tag_r, Dep cap_r ) const
 159       { const CapItemStoreT & capitemstore = capItemStore( cap_r );
 160         const CapItemContainerT & capcontainer = capItemContainer ( capitemstore, tag_r );
 161         return capcontainer.end(); }
 162
 163       /** */
 164       void clear()
 165       { _store.clear(); }
 166
 167       /** */
 168       void insert( const PoolItem & item_r );
 169       /** */
 170       void erase( const PoolItem & item_r );
 171
 172       private:
 173         PoolTraits::DepCapItemContainerT _store;
 174     };
 175
 176     ///////////////////////////////////////////////////////////////////
 177     //
 178     //  CLASS NAME : PoolImpl
 179     //
 180     /** */
 181     class PoolImpl
 182     {
 183       friend std::ostream & operator<<( std::ostream & str, const PoolImpl & obj );
 184
 185     public:
 186     /** */
 187     typedef PoolTraits::Item                    Item;
 188     typedef PoolTraits::ItemContainerT          ContainerT;
 189     typedef PoolTraits::iterator                iterator;
 190     typedef PoolTraits::const_iterator          const_iterator;
 191     typedef PoolTraits::size_type               size_type;
 192     typedef PoolTraits::Inserter                Inserter;
 193     typedef PoolTraits::Deleter                 Deleter;
 194
 195     public:
 196       /** Default ctor */
 197       PoolImpl();
 198       /** Dtor */
 199       ~PoolImpl();
 200
 201       /** \todo no poll, but make ZYpp distribute it. */
 202       Arch targetArch() const
 203       { return getZYpp()->architecture(); }
 204
 205     public:
 206       /**  */
 207       ContainerT & store()
 208       { return _store; }
 209       /**  */
 210       const ContainerT & store() const
 211       { return _store; }
 212
 213       /**  */
 214       bool empty() const
 215       { return _store.empty(); }
 216       /**  */
 217       size_type size() const
 218       { return _store.size(); }
 219
 220       /** */
 221       iterator begin()
 222       { return _store.begin(); }
 223       /** */
 224       const_iterator begin() const
 225       { return _store.begin(); }
 226
 227       /** */
 228       iterator end()
 229       { return _store.end(); }
 230       /** */
 231       const_iterator end() const
 232       { return _store.end(); }
 233
 234       /** */
 235       void clear()
 236       { _store.clear();
 237         _caphash.clear();
 238         _namehash.clear();
 239         return;
 240       }
 241
 242       /** erase all resolvables coming from the target  */
 243       void eraseInstalled();
 244
 245     public:
 246       /** \name Save and restore state. */
 247       //@{
 248       void SaveState( const ResObject::Kind & kind_r );
 249
 250       void RestoreState( const ResObject::Kind & kind_r );
 251       //@}
 252
 253     public:
 254       /** */
 255       ContainerT _store;
 256       NameHash _namehash;
 257       CapHash _caphash;
 258
 259     public:
 260       ResPoolProxy proxy( ResPool self ) const
 261       {
 262         if ( !_poolProxy )
 263           _poolProxy.reset( new ResPoolProxy( self ) );
 264         return *_poolProxy;
 265       }
 266       void invalidateProxy()
 267       { _poolProxy.reset(); }
 268
 269       mutable shared_ptr<ResPoolProxy> _poolProxy;
 270     };
 271     ///////////////////////////////////////////////////////////////////
 272
 273     /** \relates PoolImpl Stream output */
 274     std::ostream & operator<<( std::ostream & str, const PoolImpl & obj );
 275
 276     /////////////////////////////////////////////////////////////////
 277   } // namespace pool
 278   ///////////////////////////////////////////////////////////////////
 279   /////////////////////////////////////////////////////////////////
 280 } // namespace zypp
 281 ///////////////////////////////////////////////////////////////////
 282 #endif // ZYPP_POOL_POOLIMPL_H