Capabilities.h

Go to the documentation of this file.

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

#include <iosfwd>

#include <zypp-core/base/DefaultIntegral>
#include <zypp/Capability.h>

namespace zypp
{ 

  //
  //    CLASS NAME : Capabilities
  //
  class ZYPP_API Capabilities
  {
    public:
      typedef Capability value_type;
      typedef unsigned   size_type;

      enum Mode { SKIP_TO_INTERNAL };

    public:
      Capabilities()
      : _begin( 0 )
      {}

      explicit
      Capabilities( const sat::detail::IdType * base_r )
      : _begin( base_r )
      {}

      Capabilities( const sat::detail::IdType * base_r, sat::detail::IdType skip_r );

    public:
      bool empty() const
      { return ! ( _begin && *_begin ); }

      size_type size() const;

    public:
      class const_iterator;

      const_iterator begin() const;

      const_iterator end() const;

  public:
    bool contains( const Capability & lhs ) const;

    bool matches( const Capability & lhs ) const;

    Capability findFirstMatch( const Capability & lhs ) const;

    private:
      const sat::detail::IdType * _begin;
  };

  std::ostream & operator<<( std::ostream & str, const Capabilities & obj );

  //
  //    CLASS NAME : Capabilities::const_iterator
  //
  class Capabilities::const_iterator : public boost::iterator_adaptor<
        const_iterator                   // Derived
      , const sat::detail::IdType *      // Base
      , const Capability                 // Value
      , boost::forward_traversal_tag     // CategoryOrTraversal
      , const Capability                 // Reference
      >
  {
    public:
      const_iterator()
      : const_iterator::iterator_adaptor_( 0 )
      {}

      explicit const_iterator( const sat::detail::IdType * _idx )
      : const_iterator::iterator_adaptor_( _idx )
      {
        if ( base_reference() && sat::detail::isDepMarkerId( *base_reference() ) )
        {
          _tagged = true;
          ++base_reference();
        }
      }

    public:
      bool tagged() const { return _tagged; }

    private:
      friend class boost::iterator_core_access;

      reference dereference() const
      { return ( base() ) ? Capability( *base() ) : Capability::Null; }

      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
      { // NULL pointer is eqal pointer to Id 0
        return ( base() == rhs.base() // includes both NULL...
                 || ( !rhs.base() && !*base()     )
                 || ( !base()     && !*rhs.base() ) );
      }

      void increment()
      { // jump over libsolvs internal ids.
        if ( sat::detail::isDepMarkerId( *(++base_reference()) ) )
        {
          _tagged = true;
          ++base_reference();
        }
      }

    private:
      DefaultIntegral<bool,false> _tagged;
  };

  inline Capabilities::const_iterator Capabilities::begin() const
  { return const_iterator( _begin ); }

  inline Capabilities::const_iterator Capabilities::end() const
  { return const_iterator( 0 ); }

  inline bool Capabilities::contains( const Capability & lhs ) const
  {
    for ( const Capability & rhs : *this )
      if ( lhs == rhs )
        return true;
    return false;
  }

  inline bool Capabilities::matches( const Capability & lhs ) const
  {
    for ( const Capability & rhs : *this )
      if ( lhs.matches( rhs ) == CapMatch::yes )
        return true;
    return false;
  }

  inline Capability Capabilities::findFirstMatch( const Capability & lhs ) const
  {
    for ( const Capability & rhs : *this )
      if ( lhs.matches( rhs ) == CapMatch::yes )
        return rhs;
    return Capability::Null;
  }

} // namespace zypp
#endif // ZYPP_SAT_CAPABILITIES_H