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