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 ZYPP_API Solvable : protected detail::PoolMember
    {
    public:
      using IdType = sat::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
      { 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;

      Capability patternProvides() const
      { return dep_provides().findFirstMatch( Capability(patternToken.id()) ); }

      bool isPatternPackage() const
      { return bool(patternProvides()); }

      Capability productProvides() const
      { return dep_provides().findFirstMatch( Capability(productToken.id()) ); }

      bool isProductPackage() const
      { return bool(productProvides()); }

      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 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;

#if __cplusplus < 202002L
      Capabilities provides()    const ZYPP_DEPRECATED; // use dep_ prefixed version instead
      Capabilities requires()    const ZYPP_DEPRECATED; // use dep_ prefixed version instead
      Capabilities conflicts()   const ZYPP_DEPRECATED; // use dep_ prefixed version instead
      Capabilities obsoletes()   const ZYPP_DEPRECATED; // use dep_ prefixed version instead
      Capabilities recommends()  const ZYPP_DEPRECATED; // use dep_ prefixed version instead
      Capabilities suggests()    const ZYPP_DEPRECATED; // use dep_ prefixed version instead
      Capabilities enhances()    const ZYPP_DEPRECATED; // use dep_ prefixed version instead
      Capabilities supplements() const ZYPP_DEPRECATED; // use dep_ prefixed version instead
      Capabilities prerequires() const ZYPP_DEPRECATED; // use dep_ prefixed version instead
#endif

      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 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 ) ZYPP_API;

    std::ostream & dumpOn( std::ostream & str, const Solvable & obj ) ZYPP_API;

    std::ostream & dumpAsXmlOn( std::ostream & str, const Solvable & obj ) ZYPP_API;

    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 ZYPP_API asSolvable
    {
      using result_type = Solvable;

      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