zypp/ResPoolProxy.h

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file       zypp/ResPoolProxy.h
  10  *
  11 */
  12 #ifndef ZYPP_RESPOOLPROXY_H
  13 #define ZYPP_RESPOOLPROXY_H
  14
  15 #include <iosfwd>
  16
  17 #include "zypp/base/PtrTypes.h"
  18
  19 #include "zypp/ResPool.h"
  20 #include "zypp/ui/Selectable.h"
  21 #include "zypp/ui/SelFilters.h"
  22
  23 ///////////////////////////////////////////////////////////////////
  24 namespace zypp
  25 { /////////////////////////////////////////////////////////////////
  26
  27   ///////////////////////////////////////////////////////////////////
  28   //
  29   //    CLASS NAME : ResPoolProxy
  30   //
  31   /** ResPool::instance().proxy();
  32    * \todo integrate it into ResPool
  33   */
  34   class ResPoolProxy
  35   {
  36     friend std::ostream & operator<<( std::ostream & str, const ResPoolProxy & obj );
  37
  38     typedef std::vector<ui::Selectable::Ptr>  SelectableKinds;
  39     typedef std::map<ResKind,SelectableKinds> SelectablePool;
  40
  41   public:
  42     /** Implementation  */
  43     class Impl;
  44
  45     typedef SelectableKinds::iterator       iterator;
  46     typedef SelectableKinds::const_iterator const_iterator;
  47     typedef SelectableKinds::size_type      size_type;
  48
  49     typedef ResPool::repository_iterator    repository_iterator;
  50
  51   public:
  52
  53     /** Default ctor: no pool
  54      * Nonempty proxies are provided by \ref ResPool.
  55      * \see \ref ResPool::proxy
  56      * \code
  57      * ResPoolProxy p( ResPool::instance().proxy() );
  58      * \endcode
  59      */
  60     ResPoolProxy();
  61
  62     /** Dtor */
  63     ~ResPoolProxy();
  64
  65   public:
  66     /** \name Lookup individual Selectables. */
  67     //@{
  68     ui::Selectable::Ptr lookup( const pool::ByIdent & ident_r ) const;
  69
  70     ui::Selectable::Ptr lookup( IdString ident_r ) const
  71     { return lookup( pool::ByIdent( ident_r ) ); }
  72
  73     ui::Selectable::Ptr lookup( ResKind kind_r, const std::string & name_r ) const
  74     { return lookup( pool::ByIdent( kind_r, name_r ) ); }
  75
  76     ui::Selectable::Ptr lookup( const sat::Solvable & solv_r ) const
  77     { return lookup( pool::ByIdent( solv_r ) ); }
  78
  79     ui::Selectable::Ptr lookup( const ResObject::constPtr & resolvable_r ) const
  80     { return resolvable_r ? lookup( resolvable_r->satSolvable() ) : ui::Selectable::Ptr(); }
  81
  82     ui::Selectable::Ptr lookup( const PoolItem & pi_r ) const
  83     { return lookup( pi_r.satSolvable() ); }
  84     //@}
  85
  86   public:
  87
  88     /** True if there are items of a certain kind. */
  89     bool empty( const ResKind & kind_r ) const;
  90
  91     template<class _Res>
  92       bool empty() const
  93       { return empty( ResTraits<_Res>::kind ); }
  94
  95     /** Number of Items of a certain kind.  */
  96     size_type size( const ResKind & kind_r ) const;
  97
  98     template<class _Res>
  99       size_type size() const
 100       { return size( ResTraits<_Res>::kind ); }
 101
 102     /** \name Iterate through all Selectables of a certain kind. */
 103     //@{
 104     const_iterator byKindBegin( const ResKind & kind_r ) const;
 105
 106     template<class _Res>
 107       const_iterator byKindBegin() const
 108       { return byKindBegin( ResTraits<_Res>::kind ); }
 109
 110
 111     const_iterator byKindEnd( const ResKind & kind_r ) const;
 112
 113     template<class _Res>
 114       const_iterator byKindEnd() const
 115       { return byKindEnd( ResTraits<_Res>::kind ); }
 116     //@}
 117
 118  public:
 119    /** \name Iterate through all Repositories that contribute ResObjects.
 120    */
 121    //@{
 122    size_type knownRepositoriesSize() const;
 123
 124    repository_iterator knownRepositoriesBegin() const;
 125
 126    repository_iterator knownRepositoriesEnd() const;
 127    //@}
 128
 129   public:
 130     /** Test whether there is at least one ui::Selectable with
 131      * an installed object.
 132     */
 133     bool hasInstalledObj( const ResKind & kind_r ) const
 134     {
 135       return(    make_begin<ui::selfilter::ByHasInstalledObj>( kind_r )
 136               != make_end<ui::selfilter::ByHasInstalledObj>( kind_r ) );
 137     }
 138
 139     template<class _Res>
 140       bool hasInstalledObj() const
 141       { return hasInstalledObj( ResTraits<_Res>::kind ); }
 142
 143   public:
 144     /** \name Save and restore state per kind of resolvable.
 145      * Simple version, no savety net. So don't restore or diff,
 146      * if you didn't save before.
 147      *
 148      * Diff returns true, if current stat differs from the saved
 149      * state.
 150     */
 151     //@{
 152     void saveState() const;
 153
 154     void saveState( const ResKind & kind_r ) const;
 155
 156     template<class _Res>
 157       void saveState() const
 158       { return saveState( ResTraits<_Res>::kind ); }
 159
 160     void restoreState() const;
 161
 162     void restoreState( const ResKind & kind_r ) const;
 163
 164     template<class _Res>
 165       void restoreState() const
 166       { return restoreState( ResTraits<_Res>::kind ); }
 167
 168     bool diffState() const;
 169
 170     bool diffState( const ResKind & kind_r ) const;
 171
 172     template<class _Res>
 173       bool diffState() const
 174       { return diffState( ResTraits<_Res>::kind ); }
 175     //@}
 176
 177   private:
 178     template<class _Filter>
 179       filter_iterator<_Filter,const_iterator>
 180       make_begin( _Filter filter_r, const ResKind & kind_r ) const
 181       {
 182         return make_filter_iterator( filter_r,
 183                                      byKindBegin(kind_r),
 184                                      byKindEnd(kind_r) );
 185       }
 186     template<class _Filter>
 187       filter_iterator<_Filter,const_iterator>
 188       make_begin( const ResKind & kind_r ) const
 189       {
 190         return make_begin( _Filter(), kind_r );
 191       }
 192
 193
 194     template<class _Filter>
 195       filter_iterator<_Filter,const_iterator>
 196       make_end( _Filter filter_r, const ResKind & kind_r ) const
 197       {
 198         return make_filter_iterator( filter_r,
 199                                      byKindEnd(kind_r),
 200                                      byKindEnd(kind_r) );
 201       }
 202     template<class _Filter>
 203       filter_iterator<_Filter,const_iterator>
 204       make_end( const ResKind & kind_r ) const
 205       {
 206         return make_end( _Filter(), kind_r );
 207       }
 208
 209   private:
 210     friend class pool::PoolImpl;
 211     /** Ctor */
 212     ResPoolProxy( ResPool pool_r, const pool::PoolImpl & poolImpl_r );
 213     /** Pointer to implementation */
 214     RW_pointer<Impl> _pimpl;
 215   };
 216   ///////////////////////////////////////////////////////////////////
 217
 218   /** \relates ResPoolProxy Stream output */
 219   std::ostream & operator<<( std::ostream & str, const ResPoolProxy & obj );
 220
 221   /////////////////////////////////////////////////////////////////
 222 } // namespace zypp
 223 ///////////////////////////////////////////////////////////////////
 224 #endif // ZYPP_RESPOOLPROXY_H