capabilities.h

Go to the documentation of this file.

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

#include <iosfwd>
#include <iterator>
#include <type_traits>

#include <zypp-core/base/DefaultIntegral>
#include <zypp/ng/sat/capability.h>

namespace zyppng::sat
{
  class 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;
  };

  class Capabilities::const_iterator
  {
    public:
      using iterator_category = std::forward_iterator_tag;
      using value_type        = Capability;
      using difference_type   = std::ptrdiff_t;
      using pointer           = void;        // proxy iterator — no stable address
      using reference         = const Capability;

      const_iterator()
      : _idx( nullptr ), _tagged( false )
      {}

      explicit const_iterator( const sat::detail::IdType * idx )
      : _idx( idx ), _tagged( false )
      {
        // Skip an initial dep-marker if present, tagging subsequent entries.
        if ( _idx && sat::detail::isDepMarkerId( *_idx ) )
        {
          _tagged = true;
          ++_idx;
        }
      }

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

      reference operator*() const
      { return _idx ? Capability( *_idx ) : Capability::Null; }

      const_iterator & operator++()
      {
        // Advance and jump over any libsolv internal dep-marker ids.
        if ( sat::detail::isDepMarkerId( *(++_idx) ) )
        {
          _tagged = true;
          ++_idx;
        }
        return *this;
      }

      const_iterator operator++(int)
      {
        const_iterator tmp( *this );
        ++(*this);
        return tmp;
      }

      bool operator==( const const_iterator & rhs ) const
      {
        // A NULL pointer is equal to a pointer pointing at Id 0 (end sentinel).
        return ( _idx == rhs._idx )
            || ( !rhs._idx && _idx    && !*_idx     )
            || ( !_idx     && rhs._idx && !*rhs._idx );
      }

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

    private:
      const sat::detail::IdType *       _idx;
      zypp::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 zyppng::sat
#endif // ZYPP_NG_SAT_CAPABILITIES_H