LookupAttr.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_SAT_LOOKUPATTR_H
#define ZYPP_SAT_LOOKUPATTR_H
 
#include <iosfwd>
#include <utility>
 
#include <zypp/base/PtrTypes.h>
#include <zypp-core/base/DefaultIntegral>
 
#include <zypp/sat/detail/PoolMember.h>
#include <zypp/sat/SolvAttr.h>
 
namespace zypp
{ 
 
  class CheckSum;
  class Match;
  struct MatchException;
  class StrMatcher;
 
  namespace sat
  { 
 
    //
    //  CLASS NAME : LookupAttr
    //
    class LookupAttr
    {
      public:
        using Exception = MatchException;
 
      public:
        using size_type = unsigned int;
 
        enum Location {
          SOLV_ATTR = 0,  
          REPO_ATTR = -1  
        };
 
      public:
        LookupAttr();
 
        LookupAttr(const LookupAttr &) = default;
        LookupAttr(LookupAttr &&) noexcept = default;
        LookupAttr &operator=(const LookupAttr &) = default;
        LookupAttr &operator=(LookupAttr &&) noexcept = default;
 
        explicit LookupAttr( SolvAttr attr_r, Location = SOLV_ATTR );
        LookupAttr( SolvAttr attr_r, SolvAttr parent_r, Location = SOLV_ATTR );
 
        LookupAttr( SolvAttr attr_r, Repository repo_r, Location = SOLV_ATTR );
        LookupAttr( SolvAttr attr_r, SolvAttr parent_r, Repository repo_r, Location = SOLV_ATTR );
 
        LookupAttr( SolvAttr attr_r, Solvable solv_r );
        LookupAttr( SolvAttr attr_r, SolvAttr parent_r, Solvable solv_r );
 
      public:
        class iterator;
 
        iterator begin() const;
 
        iterator end() const;
 
        bool empty() const;
 
        size_type size() const;
 
        template<class TResult, class TAttr = TResult>
        class TransformIterator;
 
      public:
        SolvAttr attr() const;
 
        void setAttr( SolvAttr attr_r );
 
        const StrMatcher & strMatcher() const;
 
        void setStrMatcher( const StrMatcher & matcher_r );
 
        void resetStrMatcher();
 
      public:
        bool pool() const;
 
        void setPool( Location = SOLV_ATTR );
 
        Repository repo() const;
 
        void setRepo( Repository repo_r, Location = SOLV_ATTR );
 
        Solvable solvable() const;
 
        void setSolvable( Solvable solv_r );
 
        SolvAttr parent() const;
 
        void setParent( SolvAttr attr_r );
 
      private:
        class Impl;
        RWCOW_pointer<Impl> _pimpl;
    };
 
    std::ostream & operator<<( std::ostream & str, const LookupAttr & obj );
 
    std::ostream & dumpOn( std::ostream & str, const LookupAttr & obj );
 
    //
    //  CLASS NAME : LookupRepoAttr
    //
    class LookupRepoAttr : public LookupAttr
    {
      public:
        LookupRepoAttr()
        {}
        explicit LookupRepoAttr( SolvAttr attr_r )
        : LookupAttr( std::move(attr_r), REPO_ATTR )
        {}
        explicit LookupRepoAttr( SolvAttr attr_r, Repository repo_r );
 
      public:
        void setPool()
        { LookupAttr::setPool( REPO_ATTR ); }
        void setRepo( Repository repo_r );
      private:
        // Hide. You can't look inside and outside Solvables at the same time.
        using LookupAttr::solvable;
        using LookupAttr::setSolvable;
    };
 
    namespace detail
    {
      class DIWrap
      {
        public:
          DIWrap()
          : _dip( 0 )
          {}
          DIWrap( RepoIdType repoId_r, SolvableIdType solvId_r, IdType attrId_r,
                  std::string  mstring_r = std::string(), int flags_r = 0 );
          DIWrap( RepoIdType repoId_r, SolvableIdType solvId_r, IdType attrId_r,
                  const char * mstring_r, int flags_r = 0 );
          DIWrap( const DIWrap & rhs );
          ~DIWrap();
        public:
          void swap( DIWrap & rhs ) noexcept
          {
            if ( &rhs != this ) // prevent self assign!
            {
              std::swap( _dip, rhs._dip );
              std::swap( _mstring, rhs._mstring );
            }
          }
          DIWrap & operator=( const DIWrap & rhs )
          {
            if ( &rhs != this ) // prevent self assign!
              DIWrap( rhs ).swap( *this );
            return *this;
          }
          void reset()
          { DIWrap().swap( *this ); }
        public:
          explicit operator bool() const
          { return _dip; }
 
        public:
          detail::CDataiterator * operator->() const  { return _dip; }
          detail::CDataiterator * get()        const  { return _dip; }
          const std::string & getstr()   const  { return _mstring; }
 
        private:
          detail::CDataiterator * _dip;
          std::string _mstring;
      };
      std::ostream & operator<<( std::ostream & str, const DIWrap & obj );
    }
 
    //
    //  CLASS NAME : LookupAttr::iterator
    //
    class LookupAttr::iterator : public boost::iterator_adaptor<
        iterator                       // Derived
        , detail::CDataiterator *            // Base
        , detail::IdType               // Value
        , boost::forward_traversal_tag // CategoryOrTraversal
        , detail::IdType               // Reference
    >
    {
      public:
        void nextSkipSolvAttr();
 
        void nextSkipSolvable();
 
        void nextSkipRepo();
 
        void skipSolvAttr()
        { nextSkipSolvAttr(); increment(); }
 
        void skipSolvable()
        { nextSkipSolvable(); increment(); }
 
        void skipRepo()
        { nextSkipRepo(); increment(); }
 
        void stayInThisSolvable();
 
        void stayInThisRepo();
 
        Repository inRepo() const;
 
        Solvable inSolvable() const;
 
        SolvAttr inSolvAttr() const;
 
        bool atEnd() const
        { return !_dip; }
 
        detail::IdType solvAttrType() const;
 
        bool solvAttrNumeric() const;
 
        bool solvAttrString() const;
 
        bool solvAttrIdString() const;
 
        bool solvAttrCheckSum() const;
 
        bool solvAttrSubEntry() const;
 
        bool subEmpty() const;
 
        size_type subSize() const;
 
        iterator subBegin() const;
        iterator subEnd() const;
        iterator subFind( const SolvAttr& attr_r ) const;
        iterator subFind( const C_Str & attrname_r ) const;
 
        int asInt() const;
        unsigned asUnsigned() const;
        bool asBool() const;
        unsigned long long asUnsignedLL() const;
 
        const char * c_str() const;
        std::string asString() const;
 
        IdString idStr() const;
        detail::IdType id() const
        { return idStr().id(); }
 
        CheckSum asCheckSum() const;
 
        template<class Tp> Tp asType() const { return Tp(id()); }
 
        // internal stuff below
      public:
        iterator();
 
        iterator( const iterator & rhs );
 
        iterator & operator=( const iterator & rhs );
 
        ~iterator();
 
      public:
        iterator( detail::DIWrap & dip_r );
 
      private:
        friend class boost::iterator_core_access;
 
        template <class OtherDerived, class OtherIterator, class V, class C, class R, class D>
        bool equal( const boost::iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> & rhs ) const
        {
          return ( bool(base()) == bool(rhs.base()) )
              && ( ! base() || dip_equal( *base(), *rhs.base() ) );
        }
 
        bool dip_equal( const detail::CDataiterator & lhs, const detail::CDataiterator & rhs ) const;
 
        detail::IdType dereference() const;
 
        void increment();
 
      public:
        detail::CDataiterator * get() const
        { return _dip.get(); }
      private:
        detail::DIWrap _dip;
    };
 
    std::ostream & operator<<( std::ostream & str, const LookupAttr::iterator & obj );
 
 
    template<> inline int          LookupAttr::iterator::asType<int>()          const { return asInt(); }
    template<> inline unsigned     LookupAttr::iterator::asType<unsigned>()     const { return asUnsigned(); }
    template<> inline unsigned long long LookupAttr::iterator::asType<unsigned long long>()     const { return asUnsignedLL(); }
    template<> inline bool         LookupAttr::iterator::asType<bool>()         const { return asBool(); }
    template<> inline const char * LookupAttr::iterator::asType<const char *>() const { return c_str(); }
    template<> inline std::string  LookupAttr::iterator::asType<std::string>()  const { return asString(); }
    template<> inline IdString     LookupAttr::iterator::asType<IdString>()     const { return idStr(); }
    template<>        CheckSum     LookupAttr::iterator::asType<CheckSum>()     const;
 
    template<class TResult, class TAttr>
    class ArrayAttr;
 
  } // namespace sat
} // namespace zypp
 
std::ostream & operator<<( std::ostream & str, const zypp::sat::detail::CDataiterator * obj );
 
inline std::ostream & operator<<( std::ostream & str, const zypp::sat::detail::CDataiterator & obj )
{ return str << &obj; }
 
#endif // ZYPP_SAT_LOOKUPATTR_H