WhatProvides.h

Go to the documentation of this file.

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

#include <iosfwd>
#include <vector>

#include "zypp/base/PtrTypes.h"
#include "zypp/sat/detail/PoolMember.h"
#include "zypp/sat/Solvable.h"
#include "zypp/sat/SolvIterMixin.h"

namespace zypp
{ 

  namespace sat
  { 

    namespace detail
    {
      class WhatProvidesIterator;
    }

    //
    //  CLASS NAME : WhatProvides
    //
    class WhatProvides : public SolvIterMixin<WhatProvides,detail::WhatProvidesIterator>,
                         protected detail::PoolMember
    {
      public:
        typedef Solvable  value_type;
        typedef unsigned  size_type;

      public:
        WhatProvides();

        explicit
        WhatProvides( Capability cap_r );

        explicit
        WhatProvides( Capabilities caps_r );

        explicit
        WhatProvides( const CapabilitySet & caps_r );

     public:
        bool empty() const;

        size_type size() const;

      public:
        typedef detail::WhatProvidesIterator const_iterator;

        const_iterator begin() const;

        const_iterator end() const;

      private:
        struct Impl;
        RW_pointer<Impl> _pimpl;
    };

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

    namespace detail
    {
    //
    //  CLASS NAME : WhatProvides::const_iterator
    //
    class WhatProvidesIterator : public boost::iterator_adaptor<
          WhatProvidesIterator         // Derived
        , const detail::IdType *       // Base
        , const Solvable               // Value
        , boost::forward_traversal_tag // CategoryOrTraversal
        , const Solvable               // Reference
        >
    {
      friend std::ostream & operator<<( std::ostream & str, const WhatProvidesIterator & obj );
      public:
        WhatProvidesIterator()
        : iterator_adaptor_( 0 ), _baseRef( 0 ), _offset( 0 )
        {}

        explicit WhatProvidesIterator( const detail::IdType *const base_r, unsigned offset_r = 0 )
        : iterator_adaptor_( base_r ), _baseRef( base_r ? &base_reference() : 0 ), _offset( offset_r )
        {}

        explicit WhatProvidesIterator( const detail::IdType *const* baseRef_r, unsigned offset_r )
        : iterator_adaptor_( 0 ), _baseRef( baseRef_r ), _offset( offset_r )
        {}

        WhatProvidesIterator( const WhatProvidesIterator & rhs )
        : iterator_adaptor_( rhs.base_reference() )
        , _baseRef( base_reference() ? &base_reference() : rhs._baseRef )
        , _offset( rhs._offset )
        {}

        WhatProvidesIterator & operator=( const WhatProvidesIterator & rhs )
        {
          if ( this != &rhs ) // no self assign
          {
            base_reference() = rhs.base_reference();
            _baseRef = ( base_reference() ? &base_reference() : rhs._baseRef );
            _offset = rhs._offset;
          }
          return *this;
        }

      private:
        friend class boost::iterator_core_access;

        reference dereference() const
        { return Solvable( getId() ); }
#if 0
        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
#endif
        bool equal( const WhatProvidesIterator & rhs ) const
        {
          if ( ! ( getId() || rhs.getId() ) )
            return true; // both @end
          if ( _offset != rhs._offset )
            return false;
          if ( base_reference() )
            return( base_reference() == rhs.base_reference() );
          return( _baseRef == rhs._baseRef );
        }

        void increment()
        { ++_offset; }

        detail::IdType getId() const
        { return _baseRef ? (*_baseRef)[_offset] : detail::noId; }

      private:
        const detail::IdType *const* _baseRef;
        unsigned                     _offset;
    };
    }

    inline WhatProvides::const_iterator WhatProvides::end() const
    { return const_iterator(); }

  } // namespace sat
} // namespace zypp
#endif // ZYPP_SAT_WHATPROVIDES_H