Queue.cc

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
extern "C"
{
#include <solv/queue.h>
}
#include <iostream>
#include <zypp/base/LogTools.h>
 
#include <zypp/sat/Queue.h>
#include <zypp/sat/Solvable.h>
 
using std::endl;
 
namespace zypp
{
 
  template<>
  sat::detail::CQueue * rwcowClone<sat::detail::CQueue>( const sat::detail::CQueue * rhs )
  {
    sat::detail::CQueue * ret = new sat::detail::CQueue;
    ::queue_init_clone( ret, const_cast<sat::detail::CQueue *>(rhs) );
    return ret;
  }
 
  namespace sat
  {
 
    Queue::Queue()
      : _pimpl( new detail::CQueue )
    { ::queue_init( _pimpl.get() ); }
 
    Queue::~Queue()
    { ::queue_free( _pimpl.get() ); }
 
    bool Queue::empty() const
    { return( _pimpl->count == 0 ); }
 
    Queue::size_type Queue::size() const
    { return _pimpl->count; }
 
    Queue::const_iterator Queue::begin() const
    { return _pimpl->elements; }
 
    Queue::const_iterator Queue::end() const
    { return _pimpl->elements + _pimpl->count;}
 
    Queue::const_iterator Queue::find( value_type val_r ) const
    {
      for_( it, begin(), end() )
        if ( *it == val_r )
          return it;
      return end();
    }
 
    Queue::value_type Queue::first() const
    {
      if ( _pimpl->count )
        return *_pimpl->elements;
      return 0;
    }
 
    Queue::value_type Queue::last() const
    {
      if ( _pimpl->count )
        return _pimpl->elements[_pimpl->count-1];
      return 0;
    }
 
#define M_RANGE_CKECK(IDX,LOC) if ( IDX >= size_type(_pimpl->count) ) throw std::out_of_range( "zypp::sat::Queue::" LOC )
 
    const Queue::value_type & Queue::at( size_type idx_r ) const
    { M_RANGE_CKECK( idx_r, "at" ); return _pimpl->elements[idx_r]; }
 
    Queue::value_type & Queue::at( size_type idx_r )
    { M_RANGE_CKECK( idx_r, "at" ); return _pimpl->elements[idx_r]; }
 
    const Queue::value_type & Queue::operator[]( size_type idx_r ) const
    { return _pimpl->elements[idx_r]; }
 
    Queue::value_type & Queue::operator[]( size_type idx_r )
    { return _pimpl->elements[idx_r]; }
 
    void Queue::clear()
    { ::queue_empty( *this ); }
 
    void Queue::remove( value_type val_r )
    {
      for ( const_iterator it( find( val_r ) ); it != end(); it = find( val_r ) )
        ::queue_delete( _pimpl.get(), it - begin() );
    }
 
    void Queue::push( value_type val_r )
    { ::queue_push( _pimpl.get(), val_r ); }
 
    void Queue::pushUnique( value_type val_r )
    { ::queue_pushunique( _pimpl.get(), val_r ); }
 
    Queue::value_type Queue::pop()
    { return ::queue_pop( _pimpl.get() ); }
 
    void Queue::push_front( value_type val_r )
    { ::queue_unshift( _pimpl.get(), val_r ); }
 
    Queue::value_type Queue::pop_front()
    { return ::queue_shift( _pimpl.get() ); }
 
    Queue::operator detail::CQueue *()          // COW: nonconst version can't be inlined
    { return _pimpl.get(); }                    // without exposing detail::CQueue
 
    std::ostream & operator<<( std::ostream & str, const Queue & obj )
    { return dumpRangeLine( str << "Queue ", obj.begin(), obj.end() );  }
 
    std::ostream & dumpOn( std::ostream & str, const Queue & obj )
    {
      str << "Queue {";
      if ( ! obj.empty() )
      {
        str << endl;
        for_( it, obj.begin(), obj.end() )
          str << "  " << Solvable(*it) << endl;
      }
      return str << "}";
    }
 
    bool operator==( const Queue & lhs, const Queue & rhs )
    {
      const detail::CQueue * l = lhs;
      const detail::CQueue * r = rhs;
      return( l == r || ( l->count == r->count && ::memcmp( l->elements, r->elements, l->count ) == 0 ) );
    }
 
  } // namespace sat
} // namespace zypp