lookupattr.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPPNG_SAT_LOOKUPATTR_H
#define ZYPPNG_SAT_LOOKUPATTR_H

#include <iosfwd>
#include <utility>

#include <zypp-core/base/PtrTypes.h>
#include <zypp-core/base/defaultintegral.h>
#include <zypp-core/Globals.h>
#include <zypp-core/ng/base/ranges.h>

#include <zypp/ng/sat/solvattr.h>
#include <zypp/ng/sat/solvable.h>
#include <zypp/ng/sat/repository.h>
#include <zypp/ng/idstring.h>

namespace zypp
{
  class CheckSum;
  class Match;
  struct MatchException;
  class StrMatcher;
}

namespace zyppng::sat
{
    class Pool;
    class LookupAttrValue; 

    using zypp::MatchException;
    using zypp::StrMatcher;
    using zypp::CheckSum;

    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( Pool & pool, SolvAttr attr_r, Location = SOLV_ATTR );
        LookupAttr( Pool & pool, 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;
        zypp::RWCOW_pointer<Impl> _pimpl;
    };

    class LookupRepoAttr : public LookupAttr
    {
      public:
        LookupRepoAttr()
        {}
        explicit LookupRepoAttr( Pool & pool, SolvAttr attr_r )
        : LookupAttr( pool, 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 )
          , _pool( 0 )
          {}
          DIWrap( detail::CPool * pool, RepoIdType repoId_r, SolvableIdType solvId_r, IdType attrId_r,
                  std::string  mstring_r = std::string(), int flags_r = 0 );
          DIWrap( detail::CPool * pool, 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( _pool, rhs._pool );
              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; }
          detail::CPool * pool()               const  { return _pool; }
          const std::string & getstr()         const  { return _mstring; }

        private:
          detail::CDataiterator * _dip;
          detail::CPool * _pool;
          std::string _mstring;
      };
    }

    class LookupAttr::iterator
    {
      public:
        using iterator_category = std::forward_iterator_tag;
        using value_type        = LookupAttrValue;
        using difference_type   = std::ptrdiff_t;
        using pointer           = void;        
        using reference         = LookupAttrValue;

        void nextSkipSolvAttr();

        void nextSkipSolvable();

        void nextSkipRepo();

        void skipSolvAttr()
        { nextSkipSolvAttr(); increment(); }

        void skipSolvable()
        { nextSkipSolvable(); increment(); }

        void skipRepo()
        { nextSkipRepo(); increment(); }

        void stayInThisSolvable();

        void stayInThisRepo();

        bool atEnd() const
        { return !_dip; }

      public:
        iterator();

        iterator( const iterator & rhs );

        iterator & operator=( const iterator & rhs );

        ~iterator();

      public:
        iterator( detail::DIWrap & dip_r );

        reference operator*() const;
        iterator& operator++();
        iterator operator++(int);

        bool operator==( const iterator & rhs ) const;
        bool operator!=( const iterator & rhs ) const
        { return !(*this == rhs); }

      private:
        bool dip_equal( const detail::CDataiterator & lhs, const detail::CDataiterator & rhs ) const;
        void increment();

      public:
        detail::CDataiterator * get() const
        { return _dip.get(); }
      private:
        detail::DIWrap _dip;
    };

    template<class TResult, class TAttr>
    class ArrayAttr;

    template<class TResult, class TAttr>
    class ArrayAttr;

    // -----------------------------------------------------------------------

    class LookupAttrValue
    {
      public:
        using size_type = LookupAttr::size_type;

        LookupAttrValue( detail::CDataiterator * dip, detail::CPool * pool )
        : _dip( dip ), _pool( pool )
        {}

      public:
        Repository inRepo() const;

        Solvable inSolvable() const;

        SolvAttr inSolvAttr() const;

        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;

        LookupAttr::iterator subBegin() const;

        LookupAttr::iterator subEnd() const;

        LookupAttr::iterator subFind( const SolvAttr & attr_r ) const;

        LookupAttr::iterator subFind( const zypp::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() ); }

      private:
        detail::CDataiterator *       _dip;   
        detail::CPool *               _pool;  
    };

    // asType<> specialisations for LookupAttrValue (mirrors those on iterator)
    template<> inline int                LookupAttrValue::asType<int>()               const { return asInt(); }
    template<> inline unsigned           LookupAttrValue::asType<unsigned>()          const { return asUnsigned(); }
    template<> inline unsigned long long LookupAttrValue::asType<unsigned long long>()const { return asUnsignedLL(); }
    template<> inline bool               LookupAttrValue::asType<bool>()              const { return asBool(); }
    template<> inline const char *       LookupAttrValue::asType<const char *>()      const { return c_str(); }
    template<> inline std::string        LookupAttrValue::asType<std::string>()       const { return asString(); }
    template<> inline IdString           LookupAttrValue::asType<IdString>()          const { return idStr(); }
    template<>        CheckSum           LookupAttrValue::asType<CheckSum>()          const;

} // namespace zyppng::sat

#endif // ZYPPNG_SAT_LOOKUPATTR_H