zypp/ui/PatternExpander.cc

   1 /*---------------------------------------------------------------------\
   2  |                          ____ _   __ __ ___                          |
   3  |                         |__  / \ / / . \ . \                         |
   4  |                           / / \ V /|  _/  _/                         |
   5  |                          / /__ | | | | | |                           |
   6  |                         /_____||_| |_| |_|                           |
   7  |                                                                      |
   8  \---------------------------------------------------------------------*/
   9 /** \file       zypp/ui/PatternExpander.cc
  10  *
  11 */
  12 #include <iostream>
  13 //#include "zypp/base/LogTools.h"
  14
  15 #include "zypp/ui/PatternExpander.h"
  16
  17 #include "zypp/base/Algorithm.h"
  18 #include "zypp/base/Function.h"
  19 #include "zypp/ResPool.h"
  20
  21 using std::endl;
  22
  23 ///////////////////////////////////////////////////////////////////
  24 namespace zypp
  25 { /////////////////////////////////////////////////////////////////
  26   ///////////////////////////////////////////////////////////////////
  27   namespace ui
  28   { /////////////////////////////////////////////////////////////////
  29
  30     ///////////////////////////////////////////////////////////////////
  31     //
  32     //  CLASS NAME : PatternExpander::Impl
  33     //
  34     /** PatternExpander implementation. */
  35     class PatternExpander::Impl
  36     {
  37     public:
  38       Impl( const ResPool & pool_r )
  39       : _pool( pool_r )
  40       {}
  41
  42       /** Recursively expand Pattern. */
  43       size_type doExpand( Pattern::constPtr pat_r )
  44       {
  45         //INT << "+++ " << pat_r << " ++++++++++++++++++++++++++++++++++" << endl;
  46         _patternMap.clear();
  47         if ( pat_r )
  48           {
  49             _patternMap[pat_r];
  50             Pattern::constPtr unprocessed( pat_r );
  51             //MIL << _patternMap << endl;
  52             do {
  53               expandIncludes( unprocessed );
  54               expandExtending( unprocessed );
  55               _patternMap[unprocessed] = true;
  56               //MIL << _patternMap << endl;
  57             } while( (unprocessed = nextUnprocessed()) );
  58           }
  59         //SEC << "--- " << _patternMap.size() << " ----------------------------------" << endl;
  60         return _patternMap.size();
  61       }
  62
  63       const PatternMap & patternMap() const
  64       { return _patternMap; }
  65
  66     private:
  67       /** Get the next unprocessed Pattern \c _patternMap. */
  68       Pattern::constPtr nextUnprocessed() const
  69       {
  70         for ( PatternMap::const_iterator it = _patternMap.begin(); it != _patternMap.end(); ++it )
  71           {
  72             if ( ! it->second )
  73               return it->first;
  74           }
  75         return NULL;
  76       }
  77
  78     private:
  79       /** Store all included patterns in \c _patternMap. */
  80       void expandIncludes( const Pattern::constPtr & pat_r )
  81       {
  82         Pattern::NameList c( pat_r->includes() );
  83         for_( it, c.begin(), c.end() )
  84         {
  85           expandInclude( Capability( it->c_str(), ResKind::pattern ) );
  86         }
  87       }
  88
  89       /** Store Patterns matching an \c Includes capability in \c _patternMap. */
  90       void expandInclude( const Capability & include_r )
  91       {
  92         sat::WhatProvides w( include_r );
  93         for_( it, w.begin(), w.end() )
  94         {
  95           _patternMap[asKind<Pattern>(PoolItem(*it))];
  96         }
  97       }
  98
  99     private:
 100       /** Store all patterns extending \c pat_r in \c _patternMap. */
 101       void expandExtending( const Pattern::constPtr & pat_r )
 102       {
 103         Pattern::NameList c( pat_r->extends() );
 104         for_( it, c.begin(), c.end() )
 105         {
 106 #warning TBD
 107           //expandIfExtends( pat_r, Capability( it->c_str(), ResKind::pattern ) );
 108         }
 109       }
 110
 111       /** Store \c extending_r if it extends \c pat_r. */
 112       void expandIfExtends( const Pattern::constPtr & pat_r, const PoolItem & extending_r )
 113       {
 114         Pattern::constPtr extending( asKind<Pattern>(extending_r) );
 115
 116         if ( ! extending->extends().empty() )
 117           {
 118 #warning TBD
 119 #if 0
 120             if ( std::find_if( extending->extends().begin(),
 121                                extending->extends().end(),
 122                                bind( &Impl::providedBy, this, pat_r, _1 ) )
 123                  != extending->extends().end() )
 124               {
 125                 // an extends matches the Pattern
 126                 _patternMap[extending];
 127                 //DBG << mapEntry(*_patternMap.find(extending)) << endl;
 128               }
 129 #endif
 130           }
 131       }
 132
 133       /** Return true if Capability \c extends_r is provided by Pattern. */
 134       bool providedBy( const Pattern::constPtr & pat_r, const Capability & extends_r )
 135       {
 136         if ( !pat_r )
 137           return false;
 138
 139         sat::Solvable pat( pat_r->satSolvable() );
 140         sat::WhatProvides w( extends_r );
 141         for_( it, w.begin(), w.end() )
 142         {
 143           if ( pat == *it )
 144             return true;
 145         }
 146         return false;
 147       }
 148
 149     private:
 150       ResPool    _pool;
 151       PatternMap _patternMap;
 152     };
 153     ///////////////////////////////////////////////////////////////////
 154
 155     ///////////////////////////////////////////////////////////////////
 156     //
 157     //  CLASS NAME : PatternExpander
 158     //
 159     ///////////////////////////////////////////////////////////////////
 160
 161     ///////////////////////////////////////////////////////////////////
 162     //
 163     //  METHOD NAME : PatternExpander::PatternExpander
 164     //  METHOD TYPE : Ctor
 165     //
 166     PatternExpander::PatternExpander( const ResPool & pool_r )
 167     : _pimpl( new Impl( pool_r ) )
 168     {}
 169
 170     PatternExpander::size_type PatternExpander::expand( const Pattern::constPtr & pat_r )
 171     { return _pimpl->doExpand( pat_r ); }
 172
 173     PatternExpander::size_type PatternExpander::size() const
 174     { return _pimpl->patternMap().size(); }
 175
 176     bool PatternExpander::empty() const
 177     { return _pimpl->patternMap().empty(); }
 178
 179     PatternExpander::const_iterator PatternExpander::begin() const
 180     { return make_map_key_begin( _pimpl->patternMap() ); }
 181
 182     PatternExpander::const_iterator PatternExpander::end() const
 183     { return make_map_key_end( _pimpl->patternMap() ); }
 184
 185     /////////////////////////////////////////////////////////////////
 186   } // namespace ui
 187   ///////////////////////////////////////////////////////////////////
 188   /////////////////////////////////////////////////////////////////
 189 } // namespace zypp
 190 ///////////////////////////////////////////////////////////////////