PoolQuery.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_POOLQUERY_H
#define ZYPP_POOLQUERY_H
 
#include <iosfwd>
#include <set>
#include <map>
 
#include <zypp/base/Regex.h>
#include <zypp/base/PtrTypes.h>
#include <zypp/base/Function.h>
 
#include <zypp/sat/SolvIterMixin.h>
#include <zypp/sat/LookupAttr.h>
#include <zypp/base/StrMatcher.h>
#include <zypp/sat/Pool.h>

namespace zypp
{ 
 
  namespace detail
  {
    class PoolQueryIterator;
  }

  //
  //  CLASS NAME : PoolQuery
  //
  class ZYPP_API PoolQuery : public sat::SolvIterMixin<PoolQuery, detail::PoolQueryIterator>
  {
  public:
    using Kinds = std::set<ResKind>;
    using StrContainer = std::set<std::string>;
    using AttrRawStrMap = std::map<sat::SolvAttr, StrContainer>;
 
    using const_iterator = detail::PoolQueryIterator;
    using size_type = unsigned int;
 
  public:
    using ProcessResolvable = function<bool (const sat::Solvable &)>;
 
    PoolQuery();
    ~PoolQuery();


    const_iterator begin() const;

    const_iterator end() const;

    bool empty() const;

    size_type size() const;

    void execute(ProcessResolvable fnc);

    void addKind(const ResKind & kind);

    void addRepo(const std::string &repoalias);

    void setComment(const std::string & comment) const;


    enum StatusFilter {
      ALL = 0, // both install filter and uninstall filter bits are 0
      INSTALLED_ONLY = 1,
      UNINSTALLED_ONLY = 2
    };

    void setInstalledOnly();
    void setUninstalledOnly();
    void setStatusFilterFlags( StatusFilter flags );


    void addString(const std::string & value);

    void addAttribute( const sat::SolvAttr & attr, const std::string & value = "" );


    void addDependency( const sat::SolvAttr & attr, const std::string & name, const Rel & op, const Edition & edition );
    void addDependency( const sat::SolvAttr & attr, const std::string & name, const Rel & op, const Edition & edition, const Arch & arch );
    void addDependency( const sat::SolvAttr & attr, const std::string & name, const Rel & op, const Edition & edition, const Arch & arch, Match::Mode mode );

    void addDependency( const sat::SolvAttr & attr, const std::string & name, const Edition & edition )
    { addDependency( attr, name, Rel::EQ, edition ); }

    void addDependency( const sat::SolvAttr & attr, const std::string & name, const Edition & edition, const Arch & arch )
    { addDependency( attr, name, Rel::EQ, edition, arch ); }

    void addDependency( const sat::SolvAttr & attr, const std::string & name )
    { addDependency( attr, name, Rel::ANY, Edition() ); }

    void addDependency( const sat::SolvAttr & attr, const std::string & name, const Arch & arch )
    { addDependency( attr, name, Rel::ANY, Edition(), arch ); }

    void addDependency( const sat::SolvAttr & attr, const Rel & op, const Edition & edition )
    { addDependency( attr, std::string(), op, edition ); }

    void addDependency( const sat::SolvAttr & attr, const Rel & op, const Edition & edition, const Arch & arch )
    { addDependency( attr, std::string(), op, edition, arch ); }

    void addDependency( const sat::SolvAttr & attr, const Edition & edition )
    { addDependency( attr, std::string(), Rel::EQ, edition ); }

    void addDependency( const sat::SolvAttr & attr, const Edition & edition, const Arch & arch )
    { addDependency( attr, std::string(), Rel::EQ, edition, arch ); }

    void addDependency( const sat::SolvAttr & attr )
    { addDependency( attr, std::string(), Rel::ANY, Edition() ); }

    void addDependency( const sat::SolvAttr & attr, const Arch & arch )
    { addDependency( attr, std::string(), Rel::ANY, Edition(), arch ); }

    void addDependency( const sat::SolvAttr & attr, Capability cap_r );

    void setEdition(const Edition & edition, const Rel & op = Rel::EQ);


    void setCaseSensitive( bool value = true );

    void setFilesMatchFullPath( bool value = true );
    void setFilesMatchBasename( bool value = true )
    { setFilesMatchFullPath( !value ); }

    void setMatchExact();
    void setMatchSubstring();
    void setMatchGlob();
    void setMatchRegex();
    void setMatchWord();
    //void setLocale(const Locale & locale);


    const StrContainer & strings() const;
    const AttrRawStrMap & attributes() const;
 
    const StrContainer & attribute(const sat::SolvAttr & attr) const;
 
    const Kinds & kinds() const;
 
    const StrContainer & repos() const;
 
    const std::string & comment() const;
 
    const Edition edition() const;
    const Rel editionRel() const;

    bool caseSensitive() const;

    bool filesMatchFullPath() const;
    bool filesMatchBasename() const
    { return !filesMatchFullPath(); }
 
    bool matchExact() const;
    bool matchSubstring() const;
    bool matchGlob() const;
    bool matchRegex() const;
    bool matchWord() const;

    Match::Mode matchMode() const
    { return flags().mode(); }
 
    StatusFilter statusFilterFlags() const;

    bool recover( std::istream &str, char delim = '\n' );

    void serialize( std::ostream &str, char delim = '\n' ) const;

    std::string asString() const;
 
    bool operator<(const PoolQuery& b) const;
    bool operator==(const PoolQuery& b) const;
    bool operator!=(const PoolQuery& b) const { return !(*this == b ); }
 
    // low level API

    Match flags() const;

    void setFlags( const Match & flags );
 
  public:
    void setRequireAll( bool require_all = true ) ZYPP_DEPRECATED;
    bool requireAll() const ZYPP_DEPRECATED;
 
  public:
    class Impl;
  private:
    RW_pointer<Impl> _pimpl;
  };


  std::ostream & operator<<( std::ostream & str, const PoolQuery & obj ) ZYPP_API;

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

  namespace detail
  { 
 
  class PoolQueryMatcher;

  //
  //  CLASS NAME : PoolQuery::PoolQueryIterator
  //
  class ZYPP_API PoolQueryIterator : public boost::iterator_adaptor<
    PoolQueryIterator                  // Derived
    , sat::LookupAttr::iterator        // Base
    , const sat::Solvable              // Value
    , boost::forward_traversal_tag     // CategoryOrTraversal
    , const sat::Solvable              // Reference
  >
  {
      using Matches = std::vector<sat::LookupAttr::iterator>;
    public:
      using size_type = Matches::size_type;
      using matches_iterator = Matches::const_iterator;
    public:
      PoolQueryIterator()
      {}

      PoolQueryIterator( const shared_ptr<PoolQueryMatcher> & matcher_r )
      : _matcher( matcher_r )
      { increment(); }


      bool matchesEmpty() const                     { return ! _matcher; }
      size_type matchesSize() const         { return matches().size(); }
      matches_iterator matchesBegin() const { return matches().begin(); }
      matches_iterator matchesEnd() const     { return matches().end(); }
 
    private:
      friend class boost::iterator_core_access;
 
      sat::Solvable dereference() const
      { return base_reference().inSolvable(); }
 
      void increment();
 
    private:
      const Matches & matches() const;
 
    private:
      shared_ptr<PoolQueryMatcher> _matcher;
      mutable shared_ptr<Matches>  _matches;
  };


  inline std::ostream & operator<<( std::ostream & str, const PoolQueryIterator & obj )
  { return str << obj.base(); }

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

  } //namespace detail
 
  inline detail::PoolQueryIterator PoolQuery::end() const
  { return detail::PoolQueryIterator(); }

} // namespace zypp
 
#endif // ZYPP_POOLQUERY_H