zypp/ResPoolProxy.cc

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file       zypp/ResPoolProxy.cc
  10  *
  11 */
  12 #include <iostream>
  13 #include "zypp/base/LogTools.h"
  14
  15 #include "zypp/base/Iterator.h"
  16 #include "zypp/base/Algorithm.h"
  17 #include "zypp/base/Functional.h"
  18
  19 #include "zypp/ResPoolProxy.h"
  20 #include "zypp/pool/PoolImpl.h"
  21 #include "zypp/ui/SelectableImpl.h"
  22
  23 using std::endl;
  24
  25 ///////////////////////////////////////////////////////////////////
  26 namespace zypp
  27 { /////////////////////////////////////////////////////////////////
  28
  29   /** Tem. friend of PoolItem */
  30   struct PoolItemSaver
  31   {
  32     void saveState( ResPool pool_r )
  33     {
  34       std::for_each( pool_r.begin(), pool_r.end(),
  35                      std::mem_fun_ref(&PoolItem::saveState) );
  36     }
  37
  38     void saveState( ResPool pool_r, const ResKind & kind_r )
  39     {
  40       std::for_each( pool_r.byKindBegin(kind_r), pool_r.byKindEnd(kind_r),
  41                      std::mem_fun_ref(&PoolItem::saveState) );
  42     }
  43
  44     void restoreState( ResPool pool_r )
  45     {
  46       std::for_each( pool_r.begin(), pool_r.end(),
  47                      std::mem_fun_ref(&PoolItem::restoreState) );
  48     }
  49
  50     void restoreState( ResPool pool_r, const ResKind & kind_r )
  51     {
  52       std::for_each( pool_r.byKindBegin(kind_r), pool_r.byKindEnd(kind_r),
  53                      std::mem_fun_ref(&PoolItem::restoreState) );
  54     }
  55
  56     bool diffState( ResPool pool_r ) const
  57     {
  58       // return whether some PoolItem::sameState reported \c false.
  59       return( invokeOnEach( pool_r.begin(), pool_r.end(),
  60                             std::mem_fun_ref(&PoolItem::sameState) ) < 0 );
  61     }
  62
  63     bool diffState( ResPool pool_r, const ResKind & kind_r ) const
  64     {
  65       // return whether some PoolItem::sameState reported \c false.
  66       return( invokeOnEach( pool_r.byKindBegin(kind_r), pool_r.byKindEnd(kind_r),
  67                             std::mem_fun_ref(&PoolItem::sameState) ) < 0 );
  68     }
  69   };
  70
  71   namespace
  72   {
  73     ui::Selectable::Ptr makeSelectablePtr( pool::PoolImpl::Id2ItemT::const_iterator begin_r,
  74                                            pool::PoolImpl::Id2ItemT::const_iterator end_r )
  75     {
  76       pool::PoolTraits::byIdent_iterator begin( begin_r, pool::PoolTraits::Id2ItemValueSelector() );
  77       pool::PoolTraits::byIdent_iterator end( end_r, pool::PoolTraits::Id2ItemValueSelector() );
  78       sat::Solvable solv( begin->satSolvable() );
  79
  80       return new ui::Selectable( ui::Selectable::Impl_Ptr( new ui::Selectable::Impl( solv.kind(), solv.name(), begin, end ) ) );
  81     }
  82   } // namespace
  83
  84   ///////////////////////////////////////////////////////////////////
  85   //
  86   //    CLASS NAME : ResPoolProxy::Impl
  87   //
  88   /** ResPoolProxy implementation.
  89    * \todo Seedup as it is still using old index
  90   */
  91   struct ResPoolProxy::Impl
  92   {
  93     friend std::ostream & operator<<( std::ostream & str, const Impl & obj );
  94     friend std::ostream & dumpOn( std::ostream & str, const Impl & obj );
  95
  96     typedef std::tr1::unordered_map<sat::detail::IdType,ui::Selectable::Ptr> SelectableIndex;
  97     typedef ResPoolProxy::const_iterator const_iterator;
  98
  99   public:
 100     Impl()
 101     :_pool( ResPool::instance() )
 102     {}
 103
 104     Impl( ResPool pool_r, const pool::PoolImpl & poolImpl_r )
 105     : _pool( pool_r )
 106     {
 107       const pool::PoolImpl::Id2ItemT & id2item( poolImpl_r.id2item() );
 108       if ( ! id2item.empty() )
 109       {
 110         // set startpoint
 111         pool::PoolImpl::Id2ItemT::const_iterator cbegin = id2item.begin();
 112
 113         for_( it, id2item.begin(), id2item.end() )
 114         {
 115           if ( it->first != cbegin->first )
 116           {
 117             // starting a new Selectable, create the previous one
 118             ui::Selectable::Ptr p( makeSelectablePtr( cbegin, it ) );
 119             _selPool.insert( SelectablePool::value_type( p->kind(), p ) );
 120             _selIndex[cbegin->first] = p;
 121             // remember new startpoint
 122             cbegin = it;
 123           }
 124         }
 125         // create the final one
 126         ui::Selectable::Ptr p( makeSelectablePtr( cbegin, id2item.end() ) );
 127         _selPool.insert( SelectablePool::value_type( p->kind(), p ) );
 128         _selIndex[cbegin->first] = p;
 129       }
 130     }
 131
 132   public:
 133     ui::Selectable::Ptr lookup( const pool::ByIdent & ident_r ) const
 134     {
 135       SelectableIndex::const_iterator it( _selIndex.find( ident_r.get() ) );
 136       if ( it != _selIndex.end() )
 137         return it->second;
 138       return ui::Selectable::Ptr();
 139     }
 140
 141   public:
 142     bool empty() const
 143     { return _selPool.empty(); }
 144
 145     size_type size() const
 146     { return _selPool.size(); }
 147
 148     const_iterator begin() const
 149     { return make_map_value_begin( _selPool ); }
 150
 151     const_iterator end() const
 152     { return make_map_value_end( _selPool ); }
 153
 154   public:
 155     bool empty( const ResKind & kind_r ) const
 156     { return( _selPool.count( kind_r ) == 0 );  }
 157
 158     size_type size( const ResKind & kind_r ) const
 159     { return _selPool.count( kind_r ); }
 160
 161     const_iterator byKindBegin( const ResKind & kind_r ) const
 162     { return make_map_value_lower_bound( _selPool, kind_r ); }
 163
 164     const_iterator byKindEnd( const ResKind & kind_r ) const
 165     { return make_map_value_upper_bound( _selPool, kind_r ); }
 166
 167   public:
 168     size_type knownRepositoriesSize() const
 169     { return _pool.knownRepositoriesSize(); }
 170
 171     repository_iterator knownRepositoriesBegin() const
 172     { return _pool.knownRepositoriesBegin(); }
 173
 174     repository_iterator knownRepositoriesEnd() const
 175     { return _pool.knownRepositoriesEnd(); }
 176
 177   public:
 178
 179     void saveState() const
 180     { PoolItemSaver().saveState( _pool ); }
 181
 182     void saveState( const ResKind & kind_r ) const
 183     { PoolItemSaver().saveState( _pool, kind_r ); }
 184
 185     void restoreState() const
 186     { PoolItemSaver().restoreState( _pool ); }
 187
 188     void restoreState( const ResKind & kind_r ) const
 189     { PoolItemSaver().restoreState( _pool, kind_r ); }
 190
 191     bool diffState() const
 192     { return PoolItemSaver().diffState( _pool ); }
 193
 194     bool diffState( const ResKind & kind_r ) const
 195     { return PoolItemSaver().diffState( _pool, kind_r ); }
 196
 197   private:
 198     ResPool _pool;
 199     mutable SelectablePool _selPool;
 200     mutable SelectableIndex _selIndex;
 201
 202   public:
 203     /** Offer default Impl. */
 204     static shared_ptr<Impl> nullimpl()
 205     {
 206       static shared_ptr<Impl> _nullimpl( new Impl );
 207       return _nullimpl;
 208     }
 209   };
 210   ///////////////////////////////////////////////////////////////////
 211
 212   /** \relates ResPoolProxy::Impl Stream output */
 213   inline std::ostream & operator<<( std::ostream & str, const ResPoolProxy::Impl & obj )
 214   {
 215     return str << "ResPoolProxy (" << obj._pool.serial() << ") [" << obj._pool.size()
 216                << "solv/" << obj.size()<< "sel]";
 217   }
 218
 219   namespace detail
 220   {
 221     struct DumpFilter
 222     {
 223       bool operator()( const ui::Selectable::Ptr & selp ) const
 224       { return selp->toModify(); }
 225     };
 226   }
 227
 228   /** \relates ResPoolProxy::Impl Verbose stream output */
 229   inline std::ostream & dumpOn( std::ostream & str, const ResPoolProxy::Impl & obj )
 230   {
 231     detail::DumpFilter f;
 232     return dumpRange( str << obj << " toModify: ",
 233                       make_filter_begin( f, obj ),
 234                       make_filter_end( f, obj ) );
 235   }
 236
 237   ///////////////////////////////////////////////////////////////////
 238   //
 239   //    CLASS NAME : ResPoolProxy
 240   //
 241   ///////////////////////////////////////////////////////////////////
 242
 243   ///////////////////////////////////////////////////////////////////
 244   //
 245   //    METHOD NAME : ResPoolProxy::ResPoolProxy
 246   //    METHOD TYPE : Ctor
 247   //
 248   ResPoolProxy::ResPoolProxy()
 249   : _pimpl( Impl::nullimpl() )
 250   {}
 251
 252   ///////////////////////////////////////////////////////////////////
 253   //
 254   //    METHOD NAME : ResPoolProxy::ResPoolProxy
 255   //    METHOD TYPE : Ctor
 256   //
 257   ResPoolProxy::ResPoolProxy( ResPool pool_r, const pool::PoolImpl & poolImpl_r )
 258   : _pimpl( new Impl( pool_r, poolImpl_r ) )
 259   {}
 260
 261   ///////////////////////////////////////////////////////////////////
 262   //
 263   //    METHOD NAME : ResPoolProxy::~ResPoolProxy
 264   //    METHOD TYPE : Dtor
 265   //
 266   ResPoolProxy::~ResPoolProxy()
 267   {}
 268
 269   ///////////////////////////////////////////////////////////////////
 270   //
 271   // forward to implementation
 272   //
 273   ///////////////////////////////////////////////////////////////////
 274
 275   ui::Selectable::Ptr ResPoolProxy::lookup( const pool::ByIdent & ident_r ) const
 276   { return _pimpl->lookup( ident_r ); }
 277
 278   bool ResPoolProxy::empty() const
 279   { return _pimpl->empty(); }
 280
 281   ResPoolProxy::size_type ResPoolProxy::size() const
 282   { return _pimpl->size(); }
 283
 284   ResPoolProxy::const_iterator ResPoolProxy::begin() const
 285   { return _pimpl->begin(); }
 286
 287   ResPoolProxy::const_iterator ResPoolProxy::end() const
 288   { return _pimpl->end(); }
 289
 290   bool ResPoolProxy::empty( const ResKind & kind_r ) const
 291   { return _pimpl->empty( kind_r ); }
 292
 293   ResPoolProxy::size_type ResPoolProxy::size( const ResKind & kind_r ) const
 294   { return _pimpl->size( kind_r ); }
 295
 296   ResPoolProxy::const_iterator ResPoolProxy::byKindBegin( const ResKind & kind_r ) const
 297   { return _pimpl->byKindBegin( kind_r ); }
 298
 299   ResPoolProxy::const_iterator ResPoolProxy::byKindEnd( const ResKind & kind_r ) const
 300   { return _pimpl->byKindEnd( kind_r ); }
 301
 302   ResPoolProxy::size_type ResPoolProxy::knownRepositoriesSize() const
 303   { return _pimpl->knownRepositoriesSize(); }
 304
 305   ResPoolProxy::repository_iterator ResPoolProxy::knownRepositoriesBegin() const
 306   { return _pimpl->knownRepositoriesBegin(); }
 307
 308   ResPoolProxy::repository_iterator ResPoolProxy::knownRepositoriesEnd() const
 309   { return _pimpl->knownRepositoriesEnd(); }
 310
 311   void ResPoolProxy::saveState() const
 312   { _pimpl->saveState(); }
 313
 314   void ResPoolProxy::saveState( const ResKind & kind_r ) const
 315   { _pimpl->saveState( kind_r ); }
 316
 317   void ResPoolProxy::restoreState() const
 318   { _pimpl->restoreState(); }
 319
 320   void ResPoolProxy::restoreState( const ResKind & kind_r ) const
 321   { _pimpl->restoreState( kind_r ); }
 322
 323   bool ResPoolProxy::diffState() const
 324   { return _pimpl->diffState(); }
 325
 326   bool ResPoolProxy::diffState( const ResKind & kind_r ) const
 327   { return _pimpl->diffState( kind_r ); }
 328
 329   std::ostream & operator<<( std::ostream & str, const ResPoolProxy & obj )
 330   { return str << *obj._pimpl; }
 331
 332   std::ostream & dumpOn( std::ostream & str, const ResPoolProxy & obj )
 333   { return dumpOn( str, *obj._pimpl ); }
 334
 335   /////////////////////////////////////////////////////////////////
 336 } // namespace zypp
 337 ///////////////////////////////////////////////////////////////////