zypp/Capabilities.h

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file       zypp/sat/Capabilities.h
  10  *
  11 */
  12 #ifndef ZYPP_SAT_CAPABILITIES_H
  13 #define ZYPP_SAT_CAPABILITIES_H
  14
  15 #include <iosfwd>
  16
  17 #include "zypp/base/DefaultIntegral.h"
  18 #include "zypp/sat/detail/PoolMember.h"
  19 #include "zypp/Capability.h"
  20
  21 ///////////////////////////////////////////////////////////////////
  22 namespace zypp
  23 { /////////////////////////////////////////////////////////////////
  24
  25   ///////////////////////////////////////////////////////////////////
  26   //
  27   //    CLASS NAME : Capabilities
  28   //
  29   /** Container of \ref Capability (currently read only).
  30    *
  31    * \note libsolv dependency lists may include internal ids
  32    * which must be skipped on iteration or size calculation
  33    * (\see \ref detail::isDepMarkerId).
  34    */
  35   class Capabilities
  36   {
  37     public:
  38       typedef Capability value_type;
  39       typedef unsigned   size_type;
  40
  41       enum Mode { SKIP_TO_INTERNAL };
  42
  43     public:
  44       /** Default ctor */
  45       Capabilities()
  46       : _begin( 0 )
  47       {}
  48
  49       /** Ctor from Id pointer (friend \ref Solvable). */
  50       explicit
  51       Capabilities( const sat::detail::IdType * base_r )
  52       : _begin( base_r )
  53       {}
  54
  55       /** Ctor from Id pointer (friend \ref Solvable).
  56        * Jump behind skip_r (e.g. behind prereqMarker).
  57        */
  58       Capabilities( const sat::detail::IdType * base_r, sat::detail::IdType skip_r );
  59
  60     public:
  61       /** Whether the container is empty. */
  62       bool empty() const
  63       { return ! ( _begin && *_begin ); }
  64
  65       /** Number of capabilities inside. */
  66       size_type size() const;
  67
  68     public:
  69       class const_iterator;
  70
  71       /** Iterator pointing to the first \ref Capability. */
  72       const_iterator begin() const;
  73
  74       /** Iterator pointing behind the last \ref Capability. */
  75       const_iterator end() const;
  76
  77     private:
  78       const sat::detail::IdType * _begin;
  79   };
  80   ///////////////////////////////////////////////////////////////////
  81
  82   /** \relates Capabilities Stream output */
  83   std::ostream & operator<<( std::ostream & str, const Capabilities & obj );
  84
  85   ///////////////////////////////////////////////////////////////////
  86   //
  87   //    CLASS NAME : Capabilities::const_iterator
  88   //
  89   /** \ref Capabilities iterator.
  90    */
  91   class Capabilities::const_iterator : public boost::iterator_adaptor<
  92         const_iterator                   // Derived
  93       , const sat::detail::IdType *      // Base
  94       , const Capability                 // Value
  95       , boost::forward_traversal_tag     // CategoryOrTraversal
  96       , const Capability                 // Reference
  97       >
  98   {
  99     public:
 100       const_iterator()
 101       : const_iterator::iterator_adaptor_( 0 )
 102       {}
 103
 104       explicit const_iterator( const sat::detail::IdType * _idx )
 105       : const_iterator::iterator_adaptor_( _idx )
 106       {
 107         if ( base_reference() && sat::detail::isDepMarkerId( *base_reference() ) )
 108         {
 109           _tagged = true;
 110           ++base_reference();
 111         }
 112       }
 113
 114     public:
 115       /** Return \c true if the \ref Capability is \c tagged.
 116        * The meaning of \c tagged depends on the kind of dependency you
 117        * are processing. It is a hint that the iteratir skipped some
 118        * internal marker, indicating that subsequent cabailities have
 119        * a special property. Within a \ref Solvables requirements e.g.
 120        * the pre-requirements are tagged.
 121        * \code
 122        * Capabilities req( solvable.requires() );
 123        * for_( it, req.begin(), req.end() )
 124        * {
 125        *   if ( it.tagged() )
 126        *     cout << *it << " (is prereq)" << endl;
 127        *   else
 128        *     cout << *it << endl;
 129        * }
 130        * \endcode
 131       */
 132       bool tagged() const { return _tagged; }
 133
 134     private:
 135       friend class boost::iterator_core_access;
 136
 137       reference dereference() const
 138       { return ( base() ) ? Capability( *base() ) : Capability::Null; }
 139
 140       template <class OtherDerived, class OtherIterator, class V, class C, class R, class D>
 141       bool equal( const boost::iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> & rhs ) const
 142       { // NULL pointer is eqal pointer to Id 0
 143         return ( base() == rhs.base() // includes both NULL...
 144                  || ( !rhs.base() && !*base()     )
 145                  || ( !base()     && !*rhs.base() ) );
 146       }
 147
 148       void increment()
 149       { // jump over libsolvs internal ids.
 150         if ( sat::detail::isDepMarkerId( *(++base_reference()) ) )
 151         {
 152           _tagged = true;
 153           ++base_reference();
 154         }
 155       }
 156
 157     private:
 158       DefaultIntegral<bool,false> _tagged;
 159   };
 160   ///////////////////////////////////////////////////////////////////
 161
 162   inline Capabilities::const_iterator Capabilities::begin() const
 163   { return const_iterator( _begin ); }
 164
 165   inline Capabilities::const_iterator Capabilities::end() const
 166   { return const_iterator( 0 ); }
 167
 168   /////////////////////////////////////////////////////////////////
 169 } // namespace zypp
 170 ///////////////////////////////////////////////////////////////////
 171 #endif // ZYPP_SAT_CAPABILITIES_H