WhatProvides.cc

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#include <iostream>
 
#include <zypp/base/LogTools.h>
#include <zypp/sat/WhatProvides.h>
#include <zypp/sat/detail/PoolImpl.h>
 
using std::endl;
 
namespace zypp
{ 
  namespace sat
  { 
 
    //
    //  CLASS NAME : WhatProvides::Impl
    //
    class WhatProvides::Impl : protected detail::PoolMember
    {
      public:
        Impl()
        : _offset( 0 ), _private( 0 )
        {}
 
        Impl( unsigned offset_r )
        : _offset( offset_r ), _private( 0 )
        {}
 
        Impl( const std::unordered_set<detail::IdType> & ids_r )
        : _offset( 0 ), _private( 0 )
        {
           // use private data to store the result (incl. trailing NULL)
          _pdata.reserve( ids_r.size()+1 );
          _pdata.insert( _pdata.begin(), ids_r.begin(), ids_r.end() );
          _pdata.push_back( detail::noId );
 
          _private = &_pdata.front(); // ptr to 1st element
        }
 
      public:
        unsigned                         _offset;
        const detail::IdType *           _private;
 
      private:
        std::vector<sat::detail::IdType> _pdata;
    };
 
    namespace
    { 
 
      template <class Iterator>
      void collectProviders( Iterator begin_r, Iterator end_r, std::unordered_set<detail::IdType> & collect_r )
      {
        for_( it, begin_r, end_r )
        {
          WhatProvides providers( *it );
          for_( prv, providers.begin(), providers.end() )
          {
            collect_r.insert( prv->id() );
          }
        }
      }
 
    } //namespace
 
    WhatProvides::WhatProvides()
    {}
 
    WhatProvides::WhatProvides( Capability cap_r )
    {
      unsigned res( myPool().whatProvides( cap_r ) );
      if ( myPool().whatProvidesData( res ) )
      {
        _pimpl.reset( new Impl( res ) );
      }
      // else: no Impl for empty result.
    }
 
    WhatProvides::WhatProvides( Capabilities caps_r )
    {
      std::unordered_set<detail::IdType> ids;
      collectProviders( caps_r.begin(), caps_r.end(), ids );
      if ( ! ids.empty() )
      {
        _pimpl.reset( new Impl( ids ) );
      }
      // else: no Impl for empty result.
   }
 
    WhatProvides::WhatProvides( const CapabilitySet & caps_r )
    {
      std::unordered_set<detail::IdType> ids;
      collectProviders( caps_r.begin(), caps_r.end(), ids );
      if ( ! ids.empty() )
      {
        _pimpl.reset( new Impl( ids ) );
      }
      // else: no Impl for empty result.
   }
 
    bool WhatProvides::empty() const
    {
      return !_pimpl; // Ctor asserts no Impl for empty result.
    }
 
    WhatProvides::size_type WhatProvides::size() const
    {
      if ( !_pimpl )
        return 0;
 
      size_type count = 0;
      for_( it, begin(), end() )
        ++count;
      return count;
    }
 
    WhatProvides::const_iterator WhatProvides::begin() const
    {
      if ( !_pimpl )
        return const_iterator();
 
      if ( _pimpl->_private )
        return const_iterator( _pimpl->_private );
 
      // for libsolvs index use one more indirection, as it might get relocated.
      return const_iterator( &myPool().getPool()->whatprovidesdata, _pimpl->_offset );
    }
 
    /******************************************************************
    **
    **  FUNCTION NAME : operator<<
    **  FUNCTION TYPE : std::ostream &
    */
    std::ostream & operator<<( std::ostream & str, const WhatProvides & obj )
    {
      return dumpRange( str << "(" << obj.size() << ")", obj.begin(), obj.end() );
    }
 
    namespace detail
    { 
 
      std::ostream & operator<<( std::ostream & str, const WhatProvidesIterator & obj )
      {
        str << str::form( "[%5u]", obj._offset );
        str << str::form( "<%p(%p)>", obj.base_reference(), &obj.base_reference() );
        str << str::form( "<%p(%p)>", obj._baseRef, (obj._baseRef ? *obj._baseRef : 0) );
        return str;
      }
 
    } //namespace detail
 
  } // namespace sat
} // namespace zypp