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/base/Easy.h"
  19 #include "zypp/base/SerialNumber.h"
  20 #include "zypp/base/Deprecated.h"
  21
  22 #include "zypp/pool/PoolTraits.h"
  23 #include "zypp/ResPoolProxy.h"
  24
  25 #include "zypp/sat/Pool.h"
  26
  27 ///////////////////////////////////////////////////////////////////
  28 namespace zypp
  29 { /////////////////////////////////////////////////////////////////
  30   ///////////////////////////////////////////////////////////////////
  31   namespace pool
  32   { /////////////////////////////////////////////////////////////////
  33
  34     ///////////////////////////////////////////////////////////////////
  35     //
  36     //  CLASS NAME : PoolImpl
  37     //
  38     /** */
  39     class PoolImpl
  40     {
  41       friend std::ostream & operator<<( std::ostream & str, const PoolImpl & obj );
  42
  43       public:
  44         /** */
  45         typedef PoolTraits::ItemContainerT              ContainerT;
  46         typedef PoolTraits::size_type                   size_type;
  47         typedef PoolTraits::const_iterator              const_iterator;
  48
  49         typedef sat::detail::SolvableIdType             SolvableIdType;
  50
  51         typedef PoolTraits::AdditionalCapabilities      AdditionalCapabilities;
  52         typedef PoolTraits::RepoContainerT              KnownRepositories;
  53
  54       public:
  55         /** Default ctor */
  56         PoolImpl();
  57         /** Dtor */
  58         ~PoolImpl();
  59
  60       public:
  61         /** convenience. */
  62         const sat::Pool satpool() const
  63         { return sat::Pool::instance(); }
  64
  65         /** Housekeeping data serial number. */
  66         const SerialNumber & serial() const
  67         { return satpool().serial(); }
  68
  69         ///////////////////////////////////////////////////////////////////
  70         //
  71         ///////////////////////////////////////////////////////////////////
  72       public:
  73         /**  */
  74         bool empty() const
  75         { return satpool().solvablesEmpty(); }
  76
  77         /**  */
  78         size_type size() const
  79         { return satpool().solvablesSize(); }
  80
  81         /** */
  82         const_iterator begin() const
  83         { return make_map_value_begin( store() ); }
  84
  85         /** */
  86         const_iterator end() const
  87         { return make_map_value_end( store() ); }
  88
  89       public:
  90         /** Return the corresponding \ref PoolItem.
  91          * Pool and sat pool should be in sync. Returns an empty
  92          * \ref PoolItem if there is no corresponding \ref PoolItem.
  93          * \see \ref PoolItem::satSolvable.
  94          */
  95         PoolItem find( const sat::Solvable & slv_r ) const
  96         {
  97           const ContainerT & c( store() );
  98           ContainerT::const_iterator it( c.find( slv_r ) );
  99           if ( it != c.end() )
 100             return it->second;
 101           return PoolItem();
 102         }
 103
 104         ///////////////////////////////////////////////////////////////////
 105         //
 106         ///////////////////////////////////////////////////////////////////
 107       public:
 108         /** \name Save and restore state. */
 109         //@{
 110         void SaveState( const ResObject::Kind & kind_r );
 111
 112         void RestoreState( const ResObject::Kind & kind_r );
 113         //@}
 114
 115         ///////////////////////////////////////////////////////////////////
 116         //
 117         ///////////////////////////////////////////////////////////////////
 118       public:
 119         /**
 120          *  Handling additional requirement. E.G. need package "foo" and package
 121          *  "foo1" which has a greater version than 1.0:
 122          *
 123          *  Capset capset;
 124          *  capset.insert (CapFactory().parse( ResTraits<Package>::kind, "foo"));
 125          *  capset.insert (CapFactory().parse( ResTraits<Package>::kind, "foo1 > 1.0"));
 126          *
 127          *  setAdditionalRequire( capset );
 128          */
 129         void setAdditionalRequire( const AdditionalCapabilities & capset ) const
 130         { _additionalRequire = capset; }
 131         AdditionalCapabilities & additionalRequire() const
 132         { return _additionalRequire; }
 133
 134         /**
 135          *  Handling additional conflicts. E.G. do not install anything which provides "foo":
 136          *
 137          *  Capset capset;
 138          *  capset.insert (CapFactory().parse( ResTraits<Package>::kind, "foo"));
 139          *
 140          *  setAdditionalConflict( capset );
 141          */
 142         void setAdditionalConflict( const AdditionalCapabilities & capset ) const
 143         { _additionaConflict = capset; }
 144         AdditionalCapabilities & additionaConflict() const
 145         { return _additionaConflict; }
 146
 147         /**
 148          *  Handling additional provides. This is used for ignoring a requirement.
 149          *  e.G. Do ignore the requirement "foo":
 150          *
 151          *  Capset capset;
 152          *  capset.insert (CapFactory().parse( ResTraits<Package>::kind, "foo"));
 153          *
 154          *  setAdditionalProvide( cap );
 155          */
 156         void setAdditionalProvide( const AdditionalCapabilities & capset ) const
 157         { _additionaProvide = capset; }
 158         AdditionalCapabilities & additionaProvide() const
 159         { return _additionaProvide; }
 160
 161         ///////////////////////////////////////////////////////////////////
 162         //
 163         ///////////////////////////////////////////////////////////////////
 164       public:
 165         ResPoolProxy proxy( ResPool self ) const
 166         {
 167           checkSerial();
 168           if ( !_poolProxy )
 169             _poolProxy.reset( new ResPoolProxy( self ) );
 170           return *_poolProxy;
 171         }
 172
 173       public:
 174         /** Access list of Repositories that contribute ResObjects.
 175          * Built on demand.
 176          */
 177         const KnownRepositories & knownRepositories() const
 178         {
 179           checkSerial();
 180           if ( ! _knownRepositoriesPtr )
 181           {
 182             _knownRepositoriesPtr.reset( new KnownRepositories );
 183             const ContainerT & c( store() );
 184             for_( it, c.begin(), c.end() )
 185             {
 186               if ( (*it).second->repository() != Repository::noRepository )
 187               {
 188                 _knownRepositoriesPtr->insert( (*it).second->repository() );
 189               }
 190             }
 191           }
 192           return *_knownRepositoriesPtr;
 193         }
 194
 195         ///////////////////////////////////////////////////////////////////
 196         //
 197         ///////////////////////////////////////////////////////////////////
 198       private:
 199         const ContainerT & store() const
 200         {
 201           checkSerial();
 202           if ( _storeDirty )
 203           {
 204             // pass 1: delete no longer existing solvables
 205             for ( ContainerT::iterator it = _store.begin(); it != _store.end(); /**/ )
 206             {
 207               if ( ! it->first ) // solvable became invalid
 208                 _store.erase( it++ ); // postfix! Incrementing before erase
 209               else
 210                 ++it;
 211             }
 212
 213             // pass 2: add new solvables
 214             sat::Pool pool( satpool() );
 215             if ( _store.size() != pool.solvablesSize() )
 216             {
 217               for_( it, pool.solvablesBegin(), pool.solvablesEnd() )
 218               {
 219                 PoolItem & pi( _store[*it] );
 220                 if ( ! pi ) // newly created
 221                 {
 222                   pi = PoolItem( *it );
 223                 }
 224               }
 225             }
 226
 227             _storeDirty = false;
 228           }
 229           return _store;
 230         }
 231
 232         ///////////////////////////////////////////////////////////////////
 233         //
 234         ///////////////////////////////////////////////////////////////////
 235       private:
 236         void checkSerial() const
 237         {
 238           if ( _watcher.remember( serial() ) )
 239             invalidate();
 240         }
 241
 242         void invalidate() const
 243         {
 244           _storeDirty = true;
 245           _poolProxy.reset();
 246           _knownRepositoriesPtr.reset();
 247         }
 248
 249       private:
 250         /** Watch sat pools serial number. */
 251         SerialNumberWatcher                   _watcher;
 252         mutable ContainerT                    _store;
 253         mutable DefaultIntegral<bool,true>    _storeDirty;
 254
 255       private:
 256         mutable AdditionalCapabilities        _additionalRequire;
 257         mutable AdditionalCapabilities        _additionaConflict;
 258         mutable AdditionalCapabilities        _additionaProvide;
 259
 260         mutable shared_ptr<ResPoolProxy>      _poolProxy;
 261         mutable scoped_ptr<KnownRepositories> _knownRepositoriesPtr;
 262
 263       public:
 264         /** \bug FAKE capindex */
 265         const PoolTraits::CapItemContainerT   _caphashfake;
 266     };
 267     ///////////////////////////////////////////////////////////////////
 268
 269     /** \relates PoolImpl Stream output */
 270     std::ostream & operator<<( std::ostream & str, const PoolImpl & obj );
 271
 272     /////////////////////////////////////////////////////////////////
 273   } // namespace pool
 274   ///////////////////////////////////////////////////////////////////
 275   /////////////////////////////////////////////////////////////////
 276 } // namespace zypp
 277 ///////////////////////////////////////////////////////////////////
 278 #endif // ZYPP_POOL_POOLIMPL_H