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 PoolQuery : public sat::SolvIterMixin<PoolQuery, detail::PoolQueryIterator>
  {
  public:
    typedef std::set<ResKind>                               Kinds;
    typedef std::set<std::string>                           StrContainer;
    typedef std::map<sat::SolvAttr, StrContainer>           AttrRawStrMap;
 
    typedef detail::PoolQueryIterator                       const_iterator;
    typedef unsigned int                                    size_type;
 
  public:
    typedef function<bool( const sat::Solvable & )> ProcessResolvable;
 
    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;
#if LEGACY(1722)
    void setComment(const std::string & comment);
#endif
 
 
    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 );
 
  std::ostream & dumpOn( std::ostream & str, const PoolQuery & obj );
 
  namespace detail
  { 
 
  class PoolQueryMatcher;
 
  //
  //  CLASS NAME : PoolQuery::PoolQueryIterator
  //
  class PoolQueryIterator : public boost::iterator_adaptor<
    PoolQueryIterator                  // Derived
    , sat::LookupAttr::iterator        // Base
    , const sat::Solvable              // Value
    , boost::forward_traversal_tag     // CategoryOrTraversal
    , const sat::Solvable              // Reference
  >
  {
      typedef std::vector<sat::LookupAttr::iterator> Matches;
    public:
      typedef Matches::size_type size_type;
      typedef Matches::const_iterator matches_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 );
 
  } //namespace detail
 
  inline detail::PoolQueryIterator PoolQuery::end() const
  { return detail::PoolQueryIterator(); }
 
} // namespace zypp
 
#endif // ZYPP_POOLQUERY_H