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/sat/AttrMatcher.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);


    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 Edition & edition )
    { addDependency( attr, name, Rel::EQ, edition ); }

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

    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 Edition & edition )
    { addDependency( attr, std::string(), Rel::EQ, edition ); }

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

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

    void setRequireAll( bool require_all = true );



    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 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(); }

    bool requireAll() const;

    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 { return !(*this == b ); }

    // low level API

    Match flags() const;

    void setFlags( const Match & flags );

  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