solvable.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_SAT_SOLVABLE_H
#define ZYPP_SAT_SOLVABLE_H
 
#include <iosfwd>
 
#include <zypp-core/ng/meta/type_traits.h>
#include <zypp-core/ng/base/ranges.h>
#include <zypp-core/ByteCount.h>
#include <zypp-core/Date.h>
#include <zypp-core/CheckSum.h>
 
#include <zypp/ng/sat/poolconstants.h>
#include <zypp/ng/sat/poolmember.h>
#include <zypp/ng/sat/solvattr.h>
#include <zypp/ng/restraits.h>
#include <zypp/ng/idstring.h>
#include <zypp/ng/edition.h>
#include <zypp/ng/arch.h>
#include <zypp/ng/cpeid.h>
#include <zypp/ng/dep.h>
#include <zypp/ng/sat/capabilities.h>
#include <zypp/ng/sat/capability.h>
#include <zypp/ng/reskind.h>
#include <zypp/ng/locale.h>
 
 
 
namespace zyppng
{
  namespace sat
  {
    class Solvable;
 
    namespace detail {
      template<> Pool &       poolFromType( Solvable & );
      template<> const Pool & poolFromType( const Solvable & );
    }

    class Solvable : public PoolMember<Solvable>
    {
    public:
      using IdType = detail::SolvableIdType;
 
      static const IdString patternToken;       
      static const IdString productToken;       
 
      static const IdString retractedToken;     
      static const IdString ptfMasterToken;     
      static const IdString ptfPackageToken;    
 
    public:
      Solvable()
        : _id( detail::noSolvableId )
      {}
 
      Solvable(const Solvable &) = default;
      Solvable(Solvable &&) noexcept = default;
      Solvable &operator=(const Solvable &) = default;
      Solvable &operator=(Solvable &&) noexcept = default;

      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
      { return ranges::any_of( begin, end, [this]( const ResKind & k ){ return isKind(k); } ); }

      bool isKind( std::initializer_list<ResKind> range ) const
      { return isKind( range.begin(), range.end() ); }

      std::string name() const;

      Edition edition() const;

      Arch arch() const;

      IdString vendor() const;

      detail::RepoIdType repository() const;

      bool isSystem() const;

      zypp::Date buildtime() const;

      zypp::Date installtime() 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 dep_provides()    const;
      Capabilities dep_requires()    const;
      Capabilities dep_conflicts()   const;
      Capabilities dep_obsoletes()   const;
      Capabilities dep_recommends()  const;
      Capabilities dep_suggests()    const;
      Capabilities dep_enhances()    const;
      Capabilities dep_supplements() const;
      Capabilities dep_prerequires() const;

      Capabilities dep( Dep which_r ) const
      {
        switch( which_r.inSwitch() )
        {
          case Dep::PROVIDES_e:    return dep_provides();    break;
          case Dep::REQUIRES_e:    return dep_requires();    break;
          case Dep::CONFLICTS_e:   return dep_conflicts();   break;
          case Dep::OBSOLETES_e:   return dep_obsoletes();   break;
          case Dep::RECOMMENDS_e:  return dep_recommends();  break;
          case Dep::SUGGESTS_e:    return dep_suggests();    break;
          case Dep::ENHANCES_e:    return dep_enhances();    break;
          case Dep::SUPPLEMENTS_e: return dep_supplements(); break;
          case Dep::PREREQUIRES_e: return dep_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 Solvable &solv ) const;
 
    public:

      bool supportsLocales() const;
      bool supportsLocale( const Locale & locale_r ) const;
      bool supportsLocale( const LocaleSet & locales_r ) const;
      LocaleSet getSupportedLocales() const;
      void getSupportedLocales( LocaleSet & locales_r ) const
      { locales_r = getSupportedLocales(); }

 
    public:
      CpeId cpeId() const;

      unsigned mediaNr() const;

      zypp::ByteCount installSize() const;

      zypp::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:

      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;

      zypp::CheckSum lookupCheckSumAttribute( const SolvAttr & attr ) const;
 
    public:
      Solvable nextInPool() const;
      Solvable nextInRepo() const;
      detail::CSolvable * get() const;
      IdType id() const { return _id; }
 
    private:
      IdType _id;
    };


    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:
          using iterator_category = std::forward_iterator_tag;
          using value_type        = Solvable;         // non-cv-qualified per [iterator.traits]; constness lives on reference
          using difference_type   = std::ptrdiff_t;
          using pointer           = void;             // proxy-by-value: no stable address exists for a temporary
          using reference         = const Solvable;   // operator* returns by value – read-only proxy
 
          SolvableIterator()
          : _base( nullptr )
          {}
 
          explicit SolvableIterator( const Solvable & val_r )
          : _base( nullptr )
          { initialAssignVal( val_r ); }
 
          explicit SolvableIterator( SolvableIdType id_r )
          : _base( nullptr )
          { initialAssignVal( Solvable(id_r) ); }
 
          reference operator*() const
          { return _val; }
 
          SolvableIterator & operator++()
          { increment(); return *this; }
 
          SolvableIterator operator++(int)
          { SolvableIterator tmp = *this; increment(); return tmp; }
 
          bool operator==( const SolvableIterator & rhs ) const
          { return _base == rhs._base; }
 
          bool operator!=( const SolvableIterator & rhs ) const
          { return !(*this == rhs); }
 
          CSolvable * const & base() const
          { return _base; }
 
        private:
          void increment()
          { assignVal( _val.nextInPool() ); }
 
          void initialAssignVal( const Solvable & val_r )
          { assignVal( val_r ? val_r : val_r.nextInPool() ); }
 
          void assignVal( const Solvable & val_r )
          { _val = val_r; _base = _val.get(); }
 
          CSolvable * _base;
          Solvable _val;
      };
    } // namespace detail
 
    namespace detail {
 
      template <typename T>
      using satSolvable_t = decltype(std::declval<T>().satSolvable());
 
      template <typename T>
      constexpr bool has_satSolvable_v = std::is_detected_v<satSolvable_t, T>;
 
      template <typename T, typename = void >
      struct convert_to_solvable{
          // static_assert to force specialization/implementation
          static_assert( always_false_v<T>, "Type must have .satSolvable() or a specialization of detail::convert_to_solvable" );
      };
 
      template <typename T>
      struct convert_to_solvable<T, std::void_t<satSolvable_t<T>>> {
          template <typename SType = T>
          static Solvable asSolvable( SType && obj ) {
            return std::forward<SType>(obj).satSolvable();
          }
      };
    }

    struct asSolvable
    {
      using result_type = Solvable;
 
      Solvable operator()( const Solvable & solv_r ) const
      { return solv_r; }
 
      template <typename T>
      Solvable operator()( T&& obj )const {
        return detail::convert_to_solvable<T>::asSolvable( std::forward<T>(obj));
      }
    };
 
  } // namespace sat
} // namespace zypp
 
ZYPP_DEFINE_ID_HASHABLE( ::zyppng::sat::Solvable );
 
#endif // ZYPP_SAT_SOLVABLE_H