zypp/Pattern.cc

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file       zypp/Pattern.cc
  10  *
  11 */
  12 #include <iostream>
  13 #include "zypp/base/LogTools.h"
  14
  15 #include "zypp/ResPool.h"
  16 #include "zypp/Pattern.h"
  17 #include "zypp/Filter.h"
  18
  19 using std::endl;
  20
  21 ///////////////////////////////////////////////////////////////////
  22 namespace zypp
  23 { /////////////////////////////////////////////////////////////////
  24
  25   ///////////////////////////////////////////////////////////////////
  26   namespace
  27   { /////////////////////////////////////////////////////////////////
  28     ///////////////////////////////////////////////////////////////////
  29     //
  30     //  CLASS NAME : PatternExpander
  31     //
  32     /** Recursively expand a Pattern.
  33      *
  34      * This means recursively expanding Patterns included by this or
  35      * extending this. The result is a \c set of <tt>Pattern::constPtr</tt>
  36      * accessible via iterator.
  37      */
  38     class PatternExpander
  39     {
  40       public:
  41         typedef std::map<Pattern::constPtr, DefaultIntegral<bool, false> > PatternMap;
  42         typedef PatternMap::size_type size_type;
  43         typedef PatternMap::key_type  value_type;
  44         typedef MapKVIteratorTraits<PatternMap>::Key_const_iterator const_iterator;
  45
  46       public:
  47         PatternExpander()
  48         {}
  49
  50         /** Recursively expand Pattern. */
  51         size_type doExpand( Pattern::constPtr pat_r )
  52         {
  53           // INT << "+++ " << pat_r << " ++++++++++++++++++++++++++++++++++" << endl;
  54           _patternMap.clear();
  55           if ( pat_r )
  56           {
  57             _patternMap[pat_r];
  58             Pattern::constPtr unprocessed( pat_r );
  59             // MIL << _patternMap << endl;
  60             do {
  61               expandIncludes( unprocessed );
  62               expandExtending( unprocessed );
  63               _patternMap[unprocessed] = true;
  64               // MIL << _patternMap << endl;
  65             } while( (unprocessed = nextUnprocessed()) );
  66           }
  67           // SEC << "--- " << _patternMap.size() << " ----------------------------------" << endl;
  68           return _patternMap.size();
  69         }
  70
  71         const_iterator begin() const
  72         { return make_map_key_begin( _patternMap ); }
  73
  74         const_iterator end() const
  75         { return make_map_key_end( _patternMap ); }
  76
  77       private:
  78         /** Get the next unprocessed Pattern in \c _patternMap. */
  79         Pattern::constPtr nextUnprocessed() const
  80         {
  81           for_( it, _patternMap.begin(), _patternMap.end() )
  82           {
  83             if ( ! it->second )
  84               return it->first;
  85           }
  86           return NULL;
  87         }
  88
  89       private:
  90         /** Store all included patterns in \c _patternMap. */
  91         void expandIncludes( const Pattern::constPtr & pat_r )
  92         {
  93           Pattern::NameList c( pat_r->includes() );
  94           for_( it, c.begin(), c.end() )
  95           {
  96             expandInclude( Capability( it->c_str()/*, *ResKind::pattern*/ ) );
  97           }
  98         }
  99
 100         /** Store Patterns matching an \c Includes capability in \c _patternMap. */
 101         void expandInclude( const Capability & include_r )
 102         {
 103           sat::WhatProvides w( include_r );
 104           for_( it, w.begin(), w.end() )
 105           {
 106             _patternMap[asKind<Pattern>(PoolItem(*it))];
 107           }
 108         }
 109
 110       private:
 111         /** Store all patterns extending \c pat_r in \c _patternMap. */
 112         void expandExtending( const Pattern::constPtr & pat_r )
 113         {
 114           ResPool pool( ResPool::instance() );
 115           for_( it, pool.byKindBegin<Pattern>(), pool.byKindEnd<Pattern>() )
 116           {
 117             expandIfExtends( pat_r, *it );
 118           }
 119         }
 120
 121         /** Store \c extending_r if it extends \c pat_r. */
 122         void expandIfExtends( const Pattern::constPtr & pat_r, const PoolItem & extending_r )
 123         {
 124           Pattern::constPtr extending( asKind<Pattern>(extending_r) );
 125           Pattern::NameList c( extending->extends() );
 126           for_( it, c.begin(), c.end() )
 127           {
 128             if ( providedBy( pat_r, Capability( it->c_str()/*, *ResKind::pattern*/ ) ) )
 129             {
 130               // an extends matches the Pattern
 131               _patternMap[extending];
 132               break;
 133             }
 134           }
 135         }
 136
 137         /** Return true if Capability \c extends_r is provided by Pattern. */
 138         bool providedBy( const Pattern::constPtr & pat_r, const Capability & extends_r )
 139         {
 140           if ( !pat_r )
 141             return false;
 142
 143           sat::Solvable pat( pat_r->satSolvable() );
 144           sat::WhatProvides w( extends_r );
 145           for_( it, w.begin(), w.end() )
 146           {
 147             if ( pat == *it )
 148               return true;
 149           }
 150           return false;
 151         }
 152
 153       private:
 154         PatternMap _patternMap;
 155     };
 156     /////////////////////////////////////////////////////////////////
 157   } // namespace
 158   ///////////////////////////////////////////////////////////////////
 159   IMPL_PTR_TYPE(Pattern);
 160
 161   ///////////////////////////////////////////////////////////////////
 162   //
 163   //    METHOD NAME : Pattern::Pattern
 164   //    METHOD TYPE : Ctor
 165   //
 166   Pattern::Pattern( const sat::Solvable & solvable_r )
 167   : ResObject( solvable_r )
 168   {}
 169
 170   ///////////////////////////////////////////////////////////////////
 171   //
 172   //    METHOD NAME : Pattern::~Pattern
 173   //    METHOD TYPE : Dtor
 174   //
 175   Pattern::~Pattern()
 176   {}
 177
 178   ///////////////////////////////////////////////////////////////////
 179   //
 180   //    Pattern interface forwarded to implementation
 181   //
 182   ///////////////////////////////////////////////////////////////////
 183   /** */
 184   bool Pattern::isDefault() const
 185   { return lookupBoolAttribute( sat::SolvAttr::isdefault ); }
 186   /** */
 187   bool Pattern::userVisible() const
 188   { return lookupBoolAttribute( sat::SolvAttr::isvisible ); }
 189   /** */
 190   std::string Pattern::category( const Locale & lang_r ) const
 191   { return lookupStrAttribute( sat::SolvAttr::category, lang_r ); }
 192   /** */
 193   Pathname Pattern::icon() const
 194   { return lookupStrAttribute( sat::SolvAttr::icon ); }
 195   /** */
 196   Pathname Pattern::script() const
 197   { return lookupStrAttribute( sat::SolvAttr::script ); }
 198
 199   std::string Pattern::order() const
 200   { return lookupStrAttribute( sat::SolvAttr::order ); }
 201
 202   Pattern::NameList Pattern::includes() const
 203   { return NameList( sat::SolvAttr::includes, satSolvable() ); }
 204
 205   Pattern::NameList Pattern::extends() const
 206   { return NameList( sat::SolvAttr::extends, satSolvable() ); }
 207
 208   Pattern::Contents Pattern::core() const
 209   {
 210     // get items providing the requirements
 211     sat::WhatProvides prv( requires() );
 212     // return packages only.
 213     return Pattern::Contents( make_filter_begin( filter::byKind<Package>(), prv ),
 214                               make_filter_end( filter::byKind<Package>(), prv ) );
 215   }
 216
 217   Pattern::Contents Pattern::depends() const
 218   {
 219     // load requires, recommends, suggests
 220     CapabilitySet caps;
 221     {
 222       Capabilities c( requires() );
 223       caps.insert( c.begin(),c.end() );
 224       c = recommends();
 225       caps.insert( c.begin(),c.end() );
 226       c = suggests();
 227       caps.insert( c.begin(),c.end() );
 228     }
 229     // get items providing the above
 230     sat::WhatProvides prv( caps );
 231     // return packages only.
 232     return Pattern::Contents( make_filter_begin( filter::byKind<Package>(), prv ),
 233                               make_filter_end( filter::byKind<Package>(), prv ) );
 234   }
 235
 236   Pattern::Contents Pattern::contents() const
 237   {
 238     PatternExpander expander;
 239     if ( ! expander.doExpand( this ) )
 240       return Contents(); // empty pattern set
 241
 242     Contents result;
 243     for_( it, expander.begin(), expander.end() )
 244     {
 245       Contents c( (*it)->depends() );
 246       result.get().insert( c.begin(), c.end() );
 247     }
 248     return result;
 249   }
 250
 251   /////////////////////////////////////////////////////////////////
 252 } // namespace zypp
 253 ///////////////////////////////////////////////////////////////////