Solvable.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_SAT_SOLVABLE_H
#define ZYPP_SAT_SOLVABLE_H
 
#include <iosfwd>
 
#include <zypp/sat/detail/PoolMember.h>
#include <zypp/sat/SolvAttr.h>
#include <zypp/ResTraits.h>
#include <zypp/IdString.h>
#include <zypp/Edition.h>
#include <zypp/Arch.h>
#include <zypp/Dep.h>
#include <zypp/Capabilities.h>
#include <zypp/Capability.h>
#include <zypp/Locale.h>
 
namespace zypp
{
  class ByteCount;
  class CheckSum;
  class CpeId;
  class Date;
  class OnMediaLocation;
  namespace sat
  {
    class Solvable : protected detail::PoolMember
    {
    public:
      typedef sat::detail::SolvableIdType IdType;
 
      static const IdString retractedToken;     
      static const IdString ptfMasterToken;     
      static const IdString ptfPackageToken;    
 
    public:
      Solvable()
      : _id( detail::noSolvableId )
      {}
 
      explicit Solvable( IdType id_r )
      : _id( id_r )
      {}
 
    public:
      static const Solvable noSolvable;
 
      explicit operator bool() const
      { return get(); }
 
    public:
      IdString ident()const;
 
      ResKind kind()const;
 
      bool isKind( const ResKind & kind_r ) const;
      template<class TRes>
      bool isKind() const
      { return isKind( resKind<TRes>() ); }
      template<class TIterator>
      bool isKind( TIterator begin, TIterator end ) const
      { for_( it, begin, end ) if ( isKind( *it ) ) return true; return false; }
 
      std::string name() const;
 
      Edition edition() const;
 
      Arch arch() const;
 
      IdString vendor() const;
 
      Repository repository() const;
      RepoInfo repoInfo() const;
 
      bool isSystem() const;
 
      bool onSystemByUser() const;
 
      bool onSystemByAuto() const;
 
      bool identIsAutoInstalled() const
      { return identIsAutoInstalled( ident() ); }
      static bool identIsAutoInstalled( const IdString & ident_r );
 
      bool multiversionInstall() const;
 
      bool isNeedreboot() const;
 
      bool isBlacklisted() const;
 
      bool isRetracted() const;
 
      bool isPtf() const;
 
      bool isPtfMaster() const;
 
      bool isPtfPackage() const;
 
      Date buildtime() const;
 
      Date installtime() const;
 
    public:
      std::string asString() const;
 
      std::string asUserString() const;
 
      bool identical( const Solvable & rhs ) const;
 
      bool sameNVRA( const Solvable & rhs ) const
      { return( get() == rhs.get() || ( ident() == rhs.ident() && edition() == rhs.edition() && arch() == rhs.arch() ) ); }
 
    public:
      Capabilities provides()    const;
      Capabilities requires()    const;
      Capabilities conflicts()   const;
      Capabilities obsoletes()   const;
      Capabilities recommends()  const;
      Capabilities suggests()    const;
      Capabilities enhances()    const;
      Capabilities supplements() const;
      Capabilities prerequires() const;
 
      Capabilities dep( Dep which_r ) const
      {
        switch( which_r.inSwitch() )
        {
          case Dep::PROVIDES_e:    return provides();    break;
          case Dep::REQUIRES_e:    return requires();    break;
          case Dep::CONFLICTS_e:   return conflicts();   break;
          case Dep::OBSOLETES_e:   return obsoletes();   break;
          case Dep::RECOMMENDS_e:  return recommends();  break;
          case Dep::SUGGESTS_e:    return suggests();    break;
          case Dep::ENHANCES_e:    return enhances();    break;
          case Dep::SUPPLEMENTS_e: return supplements(); break;
          case Dep::PREREQUIRES_e: return prerequires(); break;
        }
        return Capabilities();
      }
      Capabilities operator[]( Dep which_r ) const
      { return dep( which_r ); }
 
 
      CapabilitySet providesNamespace( const std::string & namespace_r ) const;
 
      CapabilitySet valuesOfNamespace( const std::string & namespace_r ) const;
 
      std::pair<bool, CapabilitySet> matchesSolvable ( const SolvAttr &attr, const sat::Solvable &solv ) const;
 
    public:
      bool supportsLocales() const;
      bool supportsLocale( const Locale & locale_r ) const;
      bool supportsLocale( const LocaleSet & locales_r ) const;
      bool supportsRequestedLocales() const;
      LocaleSet getSupportedLocales() const;
      void getSupportedLocales( LocaleSet & locales_r ) const
      { locales_r = getSupportedLocales(); }
 
    public:
      CpeId cpeId() const;
 
      unsigned mediaNr() const;
 
      ByteCount installSize() const;
 
      ByteCount downloadSize() const;
 
      std::string distribution() const;
 
      std::string summary( const Locale & lang_r = Locale() ) const;
 
      std::string description( const Locale & lang_r = Locale() ) const;
 
      std::string insnotify( const Locale & lang_r = Locale() ) const;
      std::string delnotify( const Locale & lang_r = Locale() ) const;
 
      std::string licenseToConfirm( const Locale & lang_r = Locale() ) const;
      bool needToAcceptLicense() const;
 
    public:
      class SplitIdent
      {
      public:
        SplitIdent() {}
        SplitIdent( IdString ident_r );
        SplitIdent( const char * ident_r );
        SplitIdent( const std::string & ident_r );
        SplitIdent( ResKind kind_r, IdString name_r );
        SplitIdent( ResKind kind_r, const C_Str & name_r );
 
        IdString ident() const { return _ident; }
        ResKind  kind()  const { return _kind; }
        IdString name()  const { return _name; }
 
      private:
        IdString  _ident;
        ResKind   _kind;
        IdString  _name;
      };
 
    public:
      std::string lookupStrAttribute( const SolvAttr & attr ) const;
      std::string lookupStrAttribute( const SolvAttr & attr, const Locale & lang_r ) const;
 
      unsigned long long lookupNumAttribute( const SolvAttr & attr ) const;
      unsigned long long lookupNumAttribute( const SolvAttr & attr, unsigned long long notfound_r ) const;
 
      bool lookupBoolAttribute( const SolvAttr & attr ) const;
 
      detail::IdType lookupIdAttribute( const SolvAttr & attr ) const;
 
      CheckSum lookupCheckSumAttribute( const SolvAttr & attr ) const;
 
      OnMediaLocation lookupLocation() const;
 
    public:
      Solvable nextInPool() const;
      Solvable nextInRepo() const;
      detail::CSolvable * get() const;
      IdType id() const { return _id; }
 
    private:
      IdType _id;
    };
 
    std::ostream & operator<<( std::ostream & str, const Solvable & obj );
 
    std::ostream & dumpOn( std::ostream & str, const Solvable & obj );
 
    std::ostream & dumpAsXmlOn( std::ostream & str, const Solvable & obj );
 
    inline bool operator==( const Solvable & lhs, const Solvable & rhs )
    { return lhs.get() == rhs.get(); }
 
    inline bool operator!=( const Solvable & lhs, const Solvable & rhs )
    { return lhs.get() != rhs.get(); }
 
    inline bool operator<( const Solvable & lhs, const Solvable & rhs )
    { return lhs.get() < rhs.get(); }
 
    template<class TRes>
    inline bool isKind( const Solvable & solvable_r )
    { return solvable_r.isKind( ResTraits<TRes>::kind ); }
 
    inline bool identical( const Solvable & lhs, const Solvable & rhs )
    { return lhs.identical( rhs ); }
 
    inline bool sameNVRA( const Solvable & lhs, const Solvable & rhs )
    { return lhs.sameNVRA( rhs ); }
 
 
    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;
    }
 
    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;
    }
 
    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
    {
      class SolvableIterator : public boost::iterator_adaptor<
          SolvableIterator                   // Derived
          , CSolvable*                       // Base
          , const Solvable                   // Value
          , boost::forward_traversal_tag     // CategoryOrTraversal
          , const Solvable                   // Reference
          >
      {
        public:
          SolvableIterator()
          : SolvableIterator::iterator_adaptor_( nullptr )
          {}
 
          explicit SolvableIterator( const Solvable & val_r )
          : SolvableIterator::iterator_adaptor_( nullptr )
          { initialAssignVal( val_r ); }
 
          explicit SolvableIterator( SolvableIdType id_r )
          : SolvableIterator::iterator_adaptor_( nullptr )
          { initialAssignVal( Solvable(id_r) ); }
 
        private:
          friend class boost::iterator_core_access;
 
          Solvable dereference() const
          { return _val; }
 
          void increment()
          { assignVal( _val.nextInPool() ); }
 
        private:
          void initialAssignVal( const Solvable & val_r )
          { assignVal( val_r ? val_r : val_r.nextInPool() ); }
 
          void assignVal( const Solvable & val_r )
          { _val = val_r; base_reference() = _val.get(); }
 
          Solvable _val;
      };
    } // namespace detail
  } // namespace sat
 
  class PoolItem;
  namespace sat
  {
    struct asSolvable
    {
      typedef Solvable result_type;
 
      Solvable operator()( const Solvable & solv_r ) const
      { return solv_r; }
 
      Solvable operator()( const PoolItem & pi_r ) const;
 
      Solvable operator()( const ResObject_constPtr & res_r ) const;
    };
  } // namespace sat
} // namespace zypp
 
ZYPP_DEFINE_ID_HASHABLE( ::zypp::sat::Solvable );
 
#endif // ZYPP_SAT_SOLVABLE_H