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     typedef PoolTraits::AdditionalCapSet        AdditionalCapSet;
 195
 196     public:
 197       /** Default ctor */
 198       PoolImpl();
 199       /** Dtor */
 200       ~PoolImpl();
 201
 202       /** \todo no poll, but make ZYpp distribute it. */
 203       Arch targetArch() const
 204       { return getZYpp()->architecture(); }
 205
 206     public:
 207       /**  */
 208       ContainerT & store()
 209       { return _store; }
 210       /**  */
 211       const ContainerT & store() const
 212       { return _store; }
 213
 214       /**  */
 215       bool empty() const
 216       { return _store.empty(); }
 217       /**  */
 218       size_type size() const
 219       { return _store.size(); }
 220
 221       /** */
 222       iterator begin()
 223       { return _store.begin(); }
 224       /** */
 225       const_iterator begin() const
 226       { return _store.begin(); }
 227
 228       /** */
 229       iterator end()
 230       { return _store.end(); }
 231       /** */
 232       const_iterator end() const
 233       { return _store.end(); }
 234
 235       /**
 236        *  Handling additional requirement. E.G. need package "foo" and package
 237        *  "foo1" which has a greater version than 1.0:
 238        *
 239        *  Capset capset;
 240        *  capset.insert (CapFactory().parse( ResTraits<Package>::kind, "foo"));
 241        *  capset.insert (CapFactory().parse( ResTraits<Package>::kind, "foo1 > 1.0"));
 242        *
 243        *  setAdditionalRequire( capset );
 244        */
 245         void setAdditionalRequire( const AdditionalCapSet & capset ) const
 246             { _additionalRequire = capset; }
 247         AdditionalCapSet & additionalRequire() const
 248             { return _additionalRequire; }
 249
 250        /**
 251         *  Handling additional conflicts. E.G. do not install anything which provides "foo":
 252         *
 253         *  Capset capset;
 254         *  capset.insert (CapFactory().parse( ResTraits<Package>::kind, "foo"));
 255         *
 256         *  setAdditionalConflict( capset );
 257         */
 258         void setAdditionalConflict( const AdditionalCapSet & capset ) const
 259             { _additionaConflict = capset; }
 260         AdditionalCapSet & additionaConflict() const
 261             { return _additionaConflict; }
 262
 263         /**
 264          *  Handling additional provides. This is used for ignoring a requirement.
 265          *  e.G. Do ignore the requirement "foo":
 266          *
 267          *  Capset capset;
 268          *  capset.insert (CapFactory().parse( ResTraits<Package>::kind, "foo"));
 269          *
 270          *  setAdditionalProvide( cap );
 271          */
 272         void setAdditionalProvide( const AdditionalCapSet & capset ) const
 273             { _additionaProvide = capset; }
 274         AdditionalCapSet & additionaProvide() const
 275             { return _additionaProvide; }
 276
 277       /** */
 278       void clear()
 279       { _store.clear();
 280         _caphash.clear();
 281         _namehash.clear();
 282         _additionalRequire.clear();
 283         _additionaConflict.clear();
 284         _additionaProvide.clear();
 285
 286         return;
 287       }
 288
 289       /** erase all resolvables coming from the target  */
 290       void eraseInstalled() const;
 291
 292     public:
 293       /** \name Save and restore state. */
 294       //@{
 295       void SaveState( const ResObject::Kind & kind_r );
 296
 297       void RestoreState( const ResObject::Kind & kind_r );
 298       //@}
 299
 300     public:
 301       /** */
 302       ContainerT _store;
 303       NameHash _namehash;
 304       CapHash _caphash;
 305       mutable AdditionalCapSet _additionalRequire;
 306       mutable AdditionalCapSet _additionaConflict;
 307       mutable AdditionalCapSet _additionaProvide;
 308
 309     public:
 310       ResPoolProxy proxy( ResPool self ) const
 311       {
 312         if ( !_poolProxy )
 313           _poolProxy.reset( new ResPoolProxy( self ) );
 314         return *_poolProxy;
 315       }
 316       void invalidateProxy()
 317       { _poolProxy.reset(); }
 318
 319       mutable shared_ptr<ResPoolProxy> _poolProxy;
 320     };
 321     ///////////////////////////////////////////////////////////////////
 322
 323     /** \relates PoolImpl Stream output */
 324     std::ostream & operator<<( std::ostream & str, const PoolImpl & obj );
 325
 326     /////////////////////////////////////////////////////////////////
 327   } // namespace pool
 328   ///////////////////////////////////////////////////////////////////
 329   /////////////////////////////////////////////////////////////////
 330 } // namespace zypp
 331 ///////////////////////////////////////////////////////////////////
 332 #endif // ZYPP_POOL_POOLIMPL_H