LookupAttr.h

Go to the documentation of this file.

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

#include <iosfwd>

#include "zypp/base/PtrTypes.h"
#include "zypp/base/DefaultIntegral.h"

#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:
        typedef MatchException Exception;

      public:
        typedef unsigned size_type;

        enum Location {
          SOLV_ATTR = 0,  
          REPO_ATTR = -1  
        };

      public:
        LookupAttr();

        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( 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,
                  const 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 )
          {
            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( 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