Pattern.cc
Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00012 #include <iostream>
00013 #include "zypp/base/LogTools.h"
00014
00015 #include "zypp/ResPool.h"
00016 #include "zypp/Pattern.h"
00017 #include "zypp/Filter.h"
00018
00019 using std::endl;
00020
00022 namespace zypp
00023 {
00024
00026 namespace
00027 {
00028
00029
00030
00031
00038 class PatternExpander
00039 {
00040 public:
00041 typedef std::map<Pattern::constPtr, DefaultIntegral<bool, false> > PatternMap;
00042 typedef PatternMap::size_type size_type;
00043 typedef PatternMap::key_type value_type;
00044 typedef MapKVIteratorTraits<PatternMap>::Key_const_iterator const_iterator;
00045
00046 public:
00047 PatternExpander()
00048 {}
00049
00051 size_type doExpand( Pattern::constPtr pat_r )
00052 {
00053
00054 _patternMap.clear();
00055 if ( pat_r )
00056 {
00057 _patternMap[pat_r];
00058 Pattern::constPtr unprocessed( pat_r );
00059
00060 do {
00061 expandIncludes( unprocessed );
00062 expandExtending( unprocessed );
00063 _patternMap[unprocessed] = true;
00064
00065 } while( (unprocessed = nextUnprocessed()) );
00066 }
00067
00068 return _patternMap.size();
00069 }
00070
00071 const_iterator begin() const
00072 { return make_map_key_begin( _patternMap ); }
00073
00074 const_iterator end() const
00075 { return make_map_key_end( _patternMap ); }
00076
00077 private:
00079 Pattern::constPtr nextUnprocessed() const
00080 {
00081 for_( it, _patternMap.begin(), _patternMap.end() )
00082 {
00083 if ( ! it->second )
00084 return it->first;
00085 }
00086 return NULL;
00087 }
00088
00089 private:
00091 void expandIncludes( const Pattern::constPtr & pat_r )
00092 {
00093 Pattern::NameList c( pat_r->includes() );
00094 for_( it, c.begin(), c.end() )
00095 {
00096 expandInclude( Capability( it->c_str() ) );
00097 }
00098 }
00099
00101 void expandInclude( const Capability & include_r )
00102 {
00103 sat::WhatProvides w( include_r );
00104 for_( it, w.begin(), w.end() )
00105 {
00106 _patternMap[asKind<Pattern>(PoolItem(*it))];
00107 }
00108 }
00109
00110 private:
00112 void expandExtending( const Pattern::constPtr & pat_r )
00113 {
00114 ResPool pool( ResPool::instance() );
00115 for_( it, pool.byKindBegin<Pattern>(), pool.byKindEnd<Pattern>() )
00116 {
00117 expandIfExtends( pat_r, *it );
00118 }
00119 }
00120
00122 void expandIfExtends( const Pattern::constPtr & pat_r, const PoolItem & extending_r )
00123 {
00124 Pattern::constPtr extending( asKind<Pattern>(extending_r) );
00125 Pattern::NameList c( extending->extends() );
00126 for_( it, c.begin(), c.end() )
00127 {
00128 if ( providedBy( pat_r, Capability( it->c_str() ) ) )
00129 {
00130
00131 _patternMap[extending];
00132 break;
00133 }
00134 }
00135 }
00136
00138 bool providedBy( const Pattern::constPtr & pat_r, const Capability & extends_r )
00139 {
00140 if ( !pat_r )
00141 return false;
00142
00143 sat::Solvable pat( pat_r->satSolvable() );
00144 sat::WhatProvides w( extends_r );
00145 for_( it, w.begin(), w.end() )
00146 {
00147 if ( pat == *it )
00148 return true;
00149 }
00150 return false;
00151 }
00152
00153 private:
00154 PatternMap _patternMap;
00155 };
00157 }
00159 IMPL_PTR_TYPE(Pattern);
00160
00162
00163
00164
00165
00166 Pattern::Pattern( const sat::Solvable & solvable_r )
00167 : ResObject( solvable_r )
00168 {}
00169
00171
00172
00173
00174
00175 Pattern::~Pattern()
00176 {}
00177
00179
00180
00181
00183
00184 bool Pattern::isDefault() const
00185 { return lookupBoolAttribute( sat::SolvAttr::isdefault ); }
00187 bool Pattern::userVisible() const
00188 { return lookupBoolAttribute( sat::SolvAttr::isvisible ); }
00190 std::string Pattern::category( const Locale & lang_r ) const
00191 { return lookupStrAttribute( sat::SolvAttr::category, lang_r ); }
00193 Pathname Pattern::icon() const
00194 { return lookupStrAttribute( sat::SolvAttr::icon ); }
00196 Pathname Pattern::script() const
00197 { return lookupStrAttribute( sat::SolvAttr::script ); }
00198
00199 std::string Pattern::order() const
00200 { return lookupStrAttribute( sat::SolvAttr::order ); }
00201
00202 Pattern::NameList Pattern::includes() const
00203 { return NameList( sat::SolvAttr::includes, satSolvable() ); }
00204
00205 Pattern::NameList Pattern::extends() const
00206 { return NameList( sat::SolvAttr::extends, satSolvable() ); }
00207
00208 Pattern::Contents Pattern::core() const
00209 {
00210
00211 sat::WhatProvides prv( requires() );
00212
00213 return Pattern::Contents( make_filter_begin( filter::byKind<Package>(), prv ),
00214 make_filter_end( filter::byKind<Package>(), prv ) );
00215 }
00216
00217 Pattern::Contents Pattern::depends() const
00218 {
00219
00220 CapabilitySet caps;
00221 {
00222 Capabilities c( requires() );
00223 caps.insert( c.begin(),c.end() );
00224 c = recommends();
00225 caps.insert( c.begin(),c.end() );
00226 c = suggests();
00227 caps.insert( c.begin(),c.end() );
00228 }
00229
00230 sat::WhatProvides prv( caps );
00231
00232 return Pattern::Contents( make_filter_begin( filter::byKind<Package>(), prv ),
00233 make_filter_end( filter::byKind<Package>(), prv ) );
00234 }
00235
00236 Pattern::Contents Pattern::contents() const
00237 {
00238 PatternExpander expander;
00239 if ( ! expander.doExpand( this ) )
00240 return Contents();
00241
00242 Contents result;
00243 for_( it, expander.begin(), expander.end() )
00244 {
00245 Contents c( (*it)->depends() );
00246 result.get().insert( c.begin(), c.end() );
00247 }
00248 return result;
00249 }
00250
00252 }