zypp/pool/PoolImpl.cc

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file       zypp/pool/PoolImpl.cc
  10  *
  11 */
  12 #include <iostream>
  13 //#include "zypp/base/Logger.h"
  14
  15 #include "zypp/pool/PoolImpl.h"
  16 #include "zypp/CapSet.h"
  17
  18 using std::endl;
  19
  20 ///////////////////////////////////////////////////////////////////
  21 namespace zypp
  22 { /////////////////////////////////////////////////////////////////
  23
  24     std::ostream & operator<<( std::ostream & str, const CapAndItem & obj )
  25     {
  26         return str << "{" << obj.cap << ", " << obj.item << "}";
  27     }
  28
  29   ///////////////////////////////////////////////////////////////////
  30   namespace pool
  31   { /////////////////////////////////////////////////////////////////
  32
  33     ///////////////////////////////////////////////////////////////////
  34     //
  35     //  METHOD NAME : NameHash::NameHash
  36     //  METHOD TYPE : Ctor
  37     //
  38     NameHash::NameHash()
  39     {}
  40
  41     ///////////////////////////////////////////////////////////////////
  42     //
  43     //  METHOD NAME : NameHash::~NameHash
  44     //  METHOD TYPE : Dtor
  45     //
  46     NameHash::~NameHash()
  47     {}
  48
  49     void
  50     NameHash::insert( const PoolItem & item_r )
  51     {
  52       _store[item_r->name()].insert( item_r );
  53     }
  54
  55     void
  56     NameHash::erase( const PoolItem & item_r )
  57     {
  58       PoolTraits::ItemContainerT items = _store[item_r->name()];
  59       for (PoolTraits::iterator nit = items.begin();
  60                     nit != items.end(); ++nit)
  61       {
  62         if (*nit == item_r)
  63             items.erase( nit );
  64       }
  65     }
  66
  67     NameHash::ItemContainerT & NameHash::getItemContainer( const std::string & tag_r )
  68         { ContainerT::iterator it = _store.find( tag_r );
  69           if (it == _store.end()) {
  70 XXX << "item container for " << tag_r << " not found" << endl;
  71             return _empty;
  72           }
  73 XXX << "item container for " << tag_r << " contains " << it->second.size() << " items" << endl;
  74           return it->second;
  75         }
  76
  77     const NameHash::ItemContainerT & NameHash::getConstItemContainer( const std::string & tag_r ) const
  78         { ContainerT::const_iterator it = _store.find( tag_r );
  79           if (it == _store.end()) {
  80 XXX << "const item container for " << tag_r << " not found" << endl;
  81             return _empty;
  82           }
  83 XXX << "const item container for " << tag_r << " contains " << it->second.size() << " items" << endl;
  84           return it->second;
  85         }
  86
  87     ///////////////////////////////////////////////////////////////////
  88     //
  89     //  METHOD NAME : CapHash::CapHash
  90     //  METHOD TYPE : Ctor
  91     //
  92     CapHash::CapHash()
  93     {}
  94
  95     ///////////////////////////////////////////////////////////////////
  96     //
  97     //  METHOD NAME : CapHash::~CapHash
  98     //  METHOD TYPE : Dtor
  99     //
 100     CapHash::~CapHash()
 101     {}
 102
 103     static void
 104     storeInsert( CapHash::ContainerT & store_r, const PoolItem & item_r, Dep cap_r )
 105     {
 106       CapSet caps = item_r->dep( cap_r );
 107       for (CapSet::iterator ic = caps.begin(); ic != caps.end(); ++ic) {
 108         store_r[cap_r][ic->index()].push_back( CapAndItem( *ic, item_r ) );
 109       }
 110     }
 111
 112     void CapHash::insert( const PoolItem & item_r )
 113     {
 114       storeInsert( _store, item_r, Dep::PROVIDES );
 115       storeInsert( _store, item_r, Dep::REQUIRES );
 116       storeInsert( _store, item_r, Dep::CONFLICTS );
 117       storeInsert( _store, item_r, Dep::OBSOLETES );
 118       storeInsert( _store, item_r, Dep::FRESHENS );
 119       storeInsert( _store, item_r, Dep::SUPPLEMENTS );
 120     }
 121
 122     static void
 123     storeDelete( PoolTraits::DepCapItemContainerT & store_r, const PoolItem & item_r, Dep cap_r )
 124     {
 125       CapSet caps = item_r->dep( cap_r );
 126       for (CapSet::iterator ic = caps.begin(); ic != caps.end(); ++ic) {
 127         PoolTraits::CapItemContainerT capitems = store_r[cap_r][ic->index()];
 128         for (PoolTraits::CapItemContainerT::iterator pos = capitems.begin();
 129                                              pos != capitems.end(); ++pos)
 130         {
 131             if (pos->item == item_r)
 132                 capitems.erase( pos );
 133         }
 134       }
 135     }
 136
 137     void CapHash::erase( const PoolItem & item_r )
 138     {
 139       storeDelete( _store, item_r, Dep::PROVIDES );
 140       storeDelete( _store, item_r, Dep::REQUIRES );
 141       storeDelete( _store, item_r, Dep::CONFLICTS );
 142       storeDelete( _store, item_r, Dep::OBSOLETES );
 143       storeDelete( _store, item_r, Dep::FRESHENS );
 144       storeDelete( _store, item_r, Dep::SUPPLEMENTS );
 145     }
 146
 147       const CapHash::CapItemStoreT & CapHash::capItemStore ( Dep cap_r ) const
 148       { static CapItemStoreT capitemstore;
 149         ContainerT::const_iterator it = store().find( cap_r );
 150         if (it == store().end()) {
 151 XXX << "CapItemStoreT for " << cap_r << " not found" << endl;
 152             return capitemstore;
 153         }
 154 XXX << "CapItemStoreT for " << cap_r << " contains " << it->second.size() << " items" << endl;
 155         return it->second;
 156       }
 157
 158       // CapItemStoreT, index -> CapItemContainerT
 159       const CapHash::CapItemContainerT & CapHash::capItemContainer( const CapItemStoreT & cis, const std::string & tag_r ) const
 160       { static CapItemContainerT captemcontainer;
 161         CapItemStoreT::const_iterator it = cis.find( tag_r );
 162         if (it == cis.end()) {
 163 XXX << "CapItemContainerT for " << tag_r << " not found" << endl;
 164             return captemcontainer;
 165         }
 166 XXX << "CapItemContainerT for " << tag_r << " contains " << it->second.size() << " items" << endl;
 167 for (CapItemContainerT::const_iterator cai = it->second.begin(); cai != it->second.end(); ++cai) XXX << *cai << endl;
 168         return it->second;
 169       }
 170
 171     ///////////////////////////////////////////////////////////////////
 172     //
 173     //  METHOD NAME : PoolImpl::PoolImpl
 174     //  METHOD TYPE : Ctor
 175     //
 176     PoolImpl::PoolImpl()
 177     {}
 178
 179     ///////////////////////////////////////////////////////////////////
 180     //
 181     //  METHOD NAME : PoolImpl::~PoolImpl
 182     //  METHOD TYPE : Dtor
 183     //
 184     PoolImpl::~PoolImpl()
 185     {}
 186
 187     /******************************************************************
 188     **
 189     **  FUNCTION NAME : operator<<
 190     **  FUNCTION TYPE : std::ostream &
 191     */
 192     std::ostream & operator<<( std::ostream & str, const PoolImpl & obj )
 193     {
 194       return str << "PoolImpl " << obj.size();
 195     }
 196
 197     void PoolImplInserter::operator()( ResObject::constPtr ptr_r )
 198     {
 199       PoolImpl::Item item ( ptr_r, ResStatus (_installed) );
 200       _poolImpl._store.insert( item );
 201       _poolImpl._namehash.insert( item );
 202       _poolImpl._caphash.insert( item );
 203
 204       // don't miss to invalidate ResPoolProxy
 205       _poolImpl.invalidateProxy();
 206     }
 207
 208     void PoolImplDeleter::operator()( ResObject::constPtr ptr_r )
 209     {
 210       PoolImpl::Item item( ptr_r );
 211       _poolImpl._store.erase( item );
 212       _poolImpl._namehash.erase( item );
 213       _poolImpl._caphash.erase( item );
 214
 215       // don't miss to invalidate ResPoolProxy
 216       _poolImpl.invalidateProxy();
 217     }
 218
 219
 220     /////////////////////////////////////////////////////////////////
 221   } // namespace pool
 222   ///////////////////////////////////////////////////////////////////
 223   /////////////////////////////////////////////////////////////////
 224 } // namespace zypp
 225 ///////////////////////////////////////////////////////////////////