#include <iosfwd>
-#include "zypp/base/SafeBool.h"
-
#include "zypp/sat/detail/PoolMember.h"
#include "zypp/sat/SolvAttr.h"
#include "zypp/ResTraits.h"
//
/** A \ref Solvable object within the sat \ref Pool.
*
- * \note Unfortunately libsatsolver combines the objects kind and
+ * \note Unfortunately libsolv combines the objects kind and
* name in a single identifier \c "pattern:kde_multimedia",
* \b except for packages and source packes. They are not prefixed
* by any kind string. Instead the architecture is abused to store
* packages as an own kind of solvable and map their arch to
* \ref Arch_noarch.
*/
- class Solvable : protected detail::PoolMember,
- private base::SafeBool<Solvable>
+ class Solvable : protected detail::PoolMember
{
public:
typedef sat::detail::SolvableIdType IdType;
/** Represents no \ref Solvable. */
static const Solvable noSolvable;
-#ifndef SWIG // Swig treats it as syntax error
/** Evaluate \ref Solvable in a boolean context (\c != \c noSolvable). */
- using base::SafeBool<Solvable>::operator bool_type;
-#endif
+ explicit operator bool() const
+ { return get(); }
/** Return whether this \ref Solvable belongs to the system repo.
* \note This includes the otherwise hidden systemSolvable.
- */
+ */
bool isSystem() const;
+ /** Whether this is known to be installed on behalf of a user request.
+ * \note This is a hint guessed by evaluating an available install history.
+ * Returns \c false for non-system (uninstalled) solvables, or if no history
+ * is available.
+ */
+ bool onSystemByUser() const;
+
/** The \ref Repository this \ref Solvable belongs to. */
Repository repository() const;
std::string lookupStrAttribute( const SolvAttr & attr ) const;
/** \overload Trying to look up a translated string attribute.
*
- * Returns the translation for \c lang_r (\b no fallback locales).
+ * Returns the translation for \c lang_r.
*
* Passing an empty \ref Locale will return the string for the
* current default locale (\see \ref ZConfig::TextLocale),
* returns the numeric attribute value for \ref attr
* or 0 if it does not exists.
*/
- unsigned lookupNumAttribute( const SolvAttr & attr ) const;
+ unsigned long long lookupNumAttribute( const SolvAttr & attr ) const;
/**
* returns the boolean attribute value for \ref attr
IdString vendor() const;
- bool installOnly() const;
+ /** Whether different versions of this package can be installed at the same time.
+ * Per default \c false. \see also \ref ZConfig::multiversion.
+ */
+ bool multiversionInstall() const;
/** String representation <tt>"ident-edition.arch"</tt> or \c "noSolvable"
* \code
*/
std::string asString() const;
+ /** String representation <tt>"ident-edition.arch(repo)"</tt> or \c "noSolvable" */
+ std::string asUserString() const;
+
/** Test whether two Solvables have the same content.
* Basically the same name, edition, arch, vendor and buildtime.
*/
bool identical( Solvable rhs ) const;
- public:
+ /** Test for same name-version-release.arch */
+ bool sameNVRA( Solvable rhs ) const
+ { return( ident() == rhs.ident() && edition() == rhs.edition() && arch() == rhs.arch() ); }
+
+ public:
/** \name Access to the \ref Solvable dependencies.
*
Solvable nextInRepo() const;
/** Helper that splits an identifier into kind and name or vice versa.
+ * \note In case \c name_r is preceded by a well known kind spec, the
+ * \c kind_r argument is ignored, and kind is derived from name.
* \see \ref ident
- */
+ */
class SplitIdent
{
public:
IdString ident() const { return _ident; }
ResKind kind() const { return _kind; }
IdString name() const { return _name; }
+
private:
IdString _ident;
ResKind _kind;
::_Solvable * get() const;
/** Expert backdoor. */
IdType id() const { return _id; }
- private:
-#ifndef SWIG // Swig treats it as syntax error
- friend base::SafeBool<Solvable>::operator bool_type() const;
-#endif
- bool boolTest() const { return get(); }
+
private:
IdType _id;
};
/** \relates Solvable More verbose stream output including dependencies */
std::ostream & dumpOn( std::ostream & str, const Solvable & obj );
+ /** \relates Solvable XML output */
+ std::ostream & dumpAsXmlOn( std::ostream & str, const Solvable & obj );
+
/** \relates Solvable */
inline bool operator==( const Solvable & lhs, const Solvable & rhs )
{ return lhs.get() == rhs.get(); }
inline bool identical( Solvable lhs, Solvable rhs )
{ return lhs.identical( rhs ); }
+ /** \relates Solvable Test for same name version release and arch. */
+ inline bool sameNVRA( Solvable lhs, Solvable rhs )
+ { return lhs.sameNVRA( rhs ); }
+
+
+ /** \relates Solvable Compare according to \a kind and \a name. */
+ inline int compareByN( const Solvable & lhs, const Solvable & rhs )
+ {
+ int res = 0;
+ if ( lhs != rhs )
+ {
+ if ( (res = lhs.kind().compare( rhs.kind() )) == 0 )
+ res = lhs.name().compare( rhs.name() );
+ }
+ return res;
+ }
+
+ /** \relates Solvable Compare according to \a kind, \a name and \a edition. */
+ inline int compareByNVR( const Solvable & lhs, const Solvable & rhs )
+ {
+ int res = compareByN( lhs, rhs );
+ if ( res == 0 )
+ res = lhs.edition().compare( rhs.edition() );
+ return res;
+ }
+
+ /** \relates Solvable Compare according to \a kind, \a name, \a edition and \a arch. */
+ inline int compareByNVRA( const Solvable & lhs, const Solvable & rhs )
+ {
+ int res = compareByNVR( lhs, rhs );
+ if ( res == 0 )
+ res = lhs.arch().compare( rhs.arch() );
+ return res;
+ }
///////////////////////////////////////////////////////////////////
namespace detail
projects / platform / upstream / libzypp.git / blobdiff