solvablespec.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_NG_SAT_SOLVABLESPEC_H_INCLUDED
#define ZYPP_NG_SAT_SOLVABLESPEC_H_INCLUDED
 
#include <zypp/ng/idstring.h>
#include <zypp/ng/sat/capability.h>
#include <zypp/ng/sat/poolconstants.h>
#include <zypp-core/base/inputstream.h>
 
#include <unordered_set>
 
namespace zyppng::sat {
 
  class Pool;
  class PreparedPool;
  class Solvable;

  class SolvableSpec
  {
  public:
    SolvableSpec()  = default;
    ~SolvableSpec() = default;
 
    SolvableSpec( const SolvableSpec & ) = default;
    SolvableSpec( SolvableSpec && )      = default;
    SolvableSpec & operator=( const SolvableSpec & ) = default;
    SolvableSpec & operator=( SolvableSpec && )      = default;

    bool empty() const
    { return _idents.empty() && _provides.empty(); }

    void clear()
    { _idents.clear(); _provides.clear(); }


    void addIdent( IdString ident_r )
    { if ( !ident_r.empty() ) _idents.insert( std::move(ident_r) ); }
 
    const IdStringSet & idents() const
    { return _idents; }

    bool containsIdent( const IdString & ident_r ) const
    { return _idents.count( ident_r ) != 0; }



    void addProvides( Capability cap_r )
    { if ( !cap_r.empty() ) _provides.insert( std::move(cap_r) ); }
 
    const CapabilitySet & provides() const
    { return _provides; }

    bool containsProvides( const Capability & cap_r ) const
    { return _provides.count( cap_r ) != 0; }



    void parse( std::string_view spec_r );

    void parseFrom( const zypp::InputStream & istr_r );

    template <class TIterator>
    void parseFrom( TIterator begin, TIterator end )
    { for ( ; begin != end; ++begin ) parse( *begin ); }

    void splitParseFrom( std::string_view multispec_r );

    bool contains( Pool & pool_r, const Solvable & solv_r ) const;
 
  private:
    IdStringSet    _idents;
    CapabilitySet  _provides;
  };

  class EvaluatedSolvableSpec
  {
  public:
    using SolvIdSet = std::unordered_set<detail::SolvableIdType>;

    EvaluatedSolvableSpec( PreparedPool & pp_r, const SolvableSpec & spec_r );
 
    EvaluatedSolvableSpec( const EvaluatedSolvableSpec & ) = default;
    EvaluatedSolvableSpec( EvaluatedSolvableSpec && )      = default;
    EvaluatedSolvableSpec & operator=( const EvaluatedSolvableSpec & ) = default;
    EvaluatedSolvableSpec & operator=( EvaluatedSolvableSpec && )      = default;

    bool empty() const
    { return _ids.empty(); }

    bool contains( const Solvable & solv_r ) const;

    const SolvIdSet & ids() const
    { return _ids; }
 
  private:
    SolvIdSet _ids;
  };
 
} // namespace zyppng::sat
 
#endif // ZYPP_NG_SAT_SOLVABLESPEC_H_INCLUDED