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;