1 /*---------------------------------------------------------------------\
3 | |__ / \ / / . \ . \ |
8 \---------------------------------------------------------------------*/
9 /** \file zypp/sat/Solvable.h
12 #ifndef ZYPP_SAT_SOLVABLE_H
13 #define ZYPP_SAT_SOLVABLE_H
17 #include "zypp/base/SafeBool.h"
19 #include "zypp/sat/detail/PoolMember.h"
20 #include "zypp/sat/SolvAttr.h"
21 #include "zypp/ResTraits.h"
22 #include "zypp/IdString.h"
23 #include "zypp/Edition.h"
24 #include "zypp/Arch.h"
26 #include "zypp/Capabilities.h"
27 #include "zypp/Capability.h"
28 #include "zypp/Locale.h"
30 ///////////////////////////////////////////////////////////////////
32 { /////////////////////////////////////////////////////////////////
35 class OnMediaLocation;
37 ///////////////////////////////////////////////////////////////////
39 { /////////////////////////////////////////////////////////////////
41 ///////////////////////////////////////////////////////////////////
43 // CLASS NAME : Solvable
45 /** A \ref Solvable object within the sat \ref Pool.
47 * \note Unfortunately libsatsolver combines the objects kind and
48 * name in a single identifier \c "pattern:kde_multimedia",
49 * \b except for packages and source packes. They are not prefixed
50 * by any kind string. Instead the architecture is abused to store
51 * \c "src" and \c "nosrc" values.
53 * \ref Solvable will hide this inconsistency by treating source
54 * packages as an own kind of solvable and map their arch to
57 class Solvable : protected detail::PoolMember,
58 private base::SafeBool<Solvable>
61 typedef sat::detail::SolvableIdType IdType;
64 /** Default ctor creates \ref noSolvable.*/
66 : _id( detail::noSolvableId ) {}
68 /** \ref PoolImpl ctor. */
69 explicit Solvable( IdType id_r )
73 /** Represents no \ref Solvable. */
74 static const Solvable noSolvable;
76 #ifndef SWIG // Swig treats it as syntax error
77 /** Evaluate \ref Solvable in a boolean context (\c != \c noSolvable). */
78 using base::SafeBool<Solvable>::operator bool_type;
81 /** Return whether this \ref Solvable belongs to the system repo.
82 * \note This includes the otherwise hidden systemSolvable.
84 bool isSystem() const;
86 /** The \ref Repository this \ref Solvable belongs to. */
87 Repository repository() const;
91 /** \name Attribute lookup.
92 * \see \ref LookupAttr and \ref ArrayAttr providing a general, more
93 * query like interface for attribute retrieval.
97 * returns the string attribute value for \ref attr
98 * or an empty string if it does not exists.
100 std::string lookupStrAttribute( const SolvAttr & attr ) const;
101 /** \overload Trying to look up a translated string attribute.
103 * Returns the translation for \c lang_r (\b no fallback locales).
105 * Passing an empty \ref Locale will return the string for the
106 * current default locale (\see \ref ZConfig::TextLocale),
107 * \b considering all fallback locales.
109 * Returns an empty string if no translation is available.
111 std::string lookupStrAttribute( const SolvAttr & attr, const Locale & lang_r ) const;
114 * returns the numeric attribute value for \ref attr
115 * or 0 if it does not exists.
117 unsigned lookupNumAttribute( const SolvAttr & attr ) const;
120 * returns the boolean attribute value for \ref attr
121 * or \c false if it does not exists.
123 bool lookupBoolAttribute( const SolvAttr & attr ) const;
126 * returns the id attribute value for \ref attr
127 * or \ref detail::noId if it does not exists.
129 detail::IdType lookupIdAttribute( const SolvAttr & attr ) const;
132 * returns the CheckSum attribute value for \ref attr
133 * or an empty CheckSum if ir does not exist.
135 CheckSum lookupCheckSumAttribute( const SolvAttr & attr ) const;
138 * returns OnMediaLocation data: This is everything we need to
139 * download e.g. an rpm (path, checksum, downloadsize, etc.).
141 OnMediaLocation lookupLocation() const;
146 * This is the solvables \ref name, \b except for packages and
147 * source packes, prefixed by it's \ref kind.
149 IdString ident() const;
151 ResKind kind() const;
152 /** Test whether a Solvable is of a certain \ref ResKind. */
153 bool isKind( const ResKind & kind_r ) const;
157 { return isKind( resKind<_Res>() ); }
159 std::string name() const;
160 Edition edition() const;
163 IdString vendor() const;
165 bool installOnly() const;
169 /** \name Access to the \ref Solvable dependencies.
171 * \note Prerequires are a subset of requires.
174 Capabilities operator[]( Dep which_r ) const;
176 Capabilities provides() const;
177 Capabilities requires() const;
178 Capabilities conflicts() const;
179 Capabilities obsoletes() const;
180 Capabilities recommends() const;
181 Capabilities suggests() const;
182 Capabilities enhances() const;
183 Capabilities supplements() const;
184 Capabilities prerequires() const;
188 /** \name Locale support. */
190 /** Whether this \c Solvable claims to support locales. */
191 bool supportsLocales() const;
192 /** Whether this \c Solvable supports a specific \ref Locale. */
193 bool supportsLocale( const Locale & locale_r ) const;
194 /** Whether this \c Solvable supports at least one of the specified locales. */
195 bool supportsLocale( const LocaleSet & locales_r ) const;
196 /** Whether this \c Solvable supports at least one requested locale.
197 * \see \ref Pool::setRequestedLocales
199 bool supportsRequestedLocales() const;
200 /** Return the supported locales via locales_r. */
201 void getSupportedLocales( LocaleSet & locales_r ) const;
203 LocaleSet getSupportedLocales() const
204 { LocaleSet ret; getSupportedLocales( ret ); return ret; }
208 /** Return next Solvable in \ref Pool (or \ref noSolvable). */
209 Solvable nextInPool() const;
210 /** Return next Solvable in \ref Repo (or \ref noSolvable). */
211 Solvable nextInRepo() const;
213 /** Helper that splits an identifier into kind and name or vice versa.
220 SplitIdent( IdString ident_r );
221 SplitIdent( ResKind kind_r, IdString name_r );
222 SplitIdent( ResKind kind_r, const C_Str & name_r );
224 IdString ident() const { return _ident; }
225 ResKind kind() const { return _kind; }
226 IdString name() const { return _name; }
234 /** Expert backdoor. */
235 ::_Solvable * get() const;
236 /** Expert backdoor. */
237 IdType id() const { return _id; }
239 #ifndef SWIG // Swig treats it as syntax error
240 friend base::SafeBool<Solvable>::operator bool_type() const;
242 bool boolTest() const { return get(); }
246 ///////////////////////////////////////////////////////////////////
248 /** \relates Solvable Stream output */
249 std::ostream & operator<<( std::ostream & str, const Solvable & obj );
251 /** \relates Solvable More verbose stream output including dependencies */
252 std::ostream & dumpOn( std::ostream & str, const Solvable & obj );
254 /** \relates Solvable */
255 inline bool operator==( const Solvable & lhs, const Solvable & rhs )
256 { return lhs.get() == rhs.get(); }
258 /** \relates Solvable */
259 inline bool operator!=( const Solvable & lhs, const Solvable & rhs )
260 { return lhs.get() != rhs.get(); }
262 /** \relates Solvable */
263 inline bool operator<( const Solvable & lhs, const Solvable & rhs )
264 { return lhs.get() < rhs.get(); }
266 ///////////////////////////////////////////////////////////////////
268 { /////////////////////////////////////////////////////////////////
269 ///////////////////////////////////////////////////////////////////
271 // CLASS NAME : SolvableIterator
274 class SolvableIterator : public boost::iterator_adaptor<
275 SolvableIterator // Derived
276 , ::_Solvable* // Base
277 , const Solvable // Value
278 , boost::forward_traversal_tag // CategoryOrTraversal
279 , const Solvable // Reference
284 : SolvableIterator::iterator_adaptor_( 0 )
287 explicit SolvableIterator( const Solvable & val_r )
288 : SolvableIterator::iterator_adaptor_( 0 )
289 { assignVal( val_r ); }
291 explicit SolvableIterator( SolvableIdType id_r )
292 : SolvableIterator::iterator_adaptor_( 0 )
293 { assignVal( Solvable( id_r ) ); }
296 friend class boost::iterator_core_access;
298 Solvable dereference() const
302 { assignVal( _val.nextInPool() ); }
305 void assignVal( const Solvable & val_r )
306 { _val = val_r; base_reference() = _val.get(); }
310 ///////////////////////////////////////////////////////////////////
311 /////////////////////////////////////////////////////////////////
312 } // namespace detail
313 ///////////////////////////////////////////////////////////////////
315 /////////////////////////////////////////////////////////////////
317 ///////////////////////////////////////////////////////////////////
319 /** \relates sat::Solvable Test whether a \ref sat::Solvable is of a certain Kind. */
321 inline bool isKind( const sat::Solvable & solvable_r )
322 { return solvable_r.isKind( ResTraits<_Res>::kind ); }
324 /////////////////////////////////////////////////////////////////
326 ///////////////////////////////////////////////////////////////////
328 ZYPP_DEFINE_ID_HASHABLE( ::zypp::sat::Solvable );
330 #endif // ZYPP_SAT_SOLVABLE_H