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   public:
  78     /** Return whether the set contains \a lhs (the Id)*/
  79     bool contains( const Capability & lhs ) const;
  80
  81     /** Return whether \a lhs matches at least one capability in set. */
  82     bool matches( const Capability & lhs ) const;
  83
  84     private:
  85       const sat::detail::IdType * _begin;
  86   };
  87   ///////////////////////////////////////////////////////////////////
  88
  89   /** \relates Capabilities Stream output */
  90   std::ostream & operator<<( std::ostream & str, const Capabilities & obj );
  91
  92   ///////////////////////////////////////////////////////////////////
  93   //
  94   //    CLASS NAME : Capabilities::const_iterator
  95   //
  96   /** \ref Capabilities iterator.
  97    */
  98   class Capabilities::const_iterator : public boost::iterator_adaptor<
  99         const_iterator                   // Derived
 100       , const sat::detail::IdType *      // Base
 101       , const Capability                 // Value
 102       , boost::forward_traversal_tag     // CategoryOrTraversal
 103       , const Capability                 // Reference
 104       >
 105   {
 106     public:
 107       const_iterator()
 108       : const_iterator::iterator_adaptor_( 0 )
 109       {}
 110
 111       explicit const_iterator( const sat::detail::IdType * _idx )
 112       : const_iterator::iterator_adaptor_( _idx )
 113       {
 114         if ( base_reference() && sat::detail::isDepMarkerId( *base_reference() ) )
 115         {
 116           _tagged = true;
 117           ++base_reference();
 118         }
 119       }
 120
 121     public:
 122       /** Return \c true if the \ref Capability is \c tagged.
 123        * The meaning of \c tagged depends on the kind of dependency you
 124        * are processing. It is a hint that the iteratir skipped some
 125        * internal marker, indicating that subsequent cabailities have
 126        * a special property. Within a \ref Solvables requirements e.g.
 127        * the pre-requirements are tagged.
 128        * \code
 129        * Capabilities req( solvable.requires() );
 130        * for_( it, req.begin(), req.end() )
 131        * {
 132        *   if ( it.tagged() )
 133        *     cout << *it << " (is prereq)" << endl;
 134        *   else
 135        *     cout << *it << endl;
 136        * }
 137        * \endcode
 138       */
 139       bool tagged() const { return _tagged; }
 140
 141     private:
 142       friend class boost::iterator_core_access;
 143
 144       reference dereference() const
 145       { return ( base() ) ? Capability( *base() ) : Capability::Null; }
 146
 147       template <class OtherDerived, class OtherIterator, class V, class C, class R, class D>
 148       bool equal( const boost::iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> & rhs ) const
 149       { // NULL pointer is eqal pointer to Id 0
 150         return ( base() == rhs.base() // includes both NULL...
 151                  || ( !rhs.base() && !*base()     )
 152                  || ( !base()     && !*rhs.base() ) );
 153       }
 154
 155       void increment()
 156       { // jump over libsolvs internal ids.
 157         if ( sat::detail::isDepMarkerId( *(++base_reference()) ) )
 158         {
 159           _tagged = true;
 160           ++base_reference();
 161         }
 162       }
 163
 164     private:
 165       DefaultIntegral<bool,false> _tagged;
 166   };
 167   ///////////////////////////////////////////////////////////////////
 168
 169   inline Capabilities::const_iterator Capabilities::begin() const
 170   { return const_iterator( _begin ); }
 171
 172   inline Capabilities::const_iterator Capabilities::end() const
 173   { return const_iterator( 0 ); }
 174
 175   inline bool Capabilities::contains( const Capability & lhs ) const
 176   {
 177     for ( const Capability & rhs : *this )
 178       if ( lhs == rhs )
 179         return true;
 180     return false;
 181   }
 182
 183   inline bool Capabilities::matches( const Capability & lhs ) const
 184   {
 185     for ( const Capability & rhs : *this )
 186       if ( lhs.matches( rhs ) == CapMatch::yes )
 187         return true;
 188     return false;
 189   }
 190   /////////////////////////////////////////////////////////////////
 191 } // namespace zypp
 192 ///////////////////////////////////////////////////////////////////
 193 #endif // ZYPP_SAT_CAPABILITIES_H