zypp/sat/Queue.cc

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file       zypp/sat/Queue.cc
  10  */
  11 extern "C"
  12 {
  13 #include <solv/queue.h>
  14 }
  15 #include <iostream>
  16 #include "zypp/base/LogTools.h"
  17
  18 #include "zypp/sat/Queue.h"
  19 #include "zypp/sat/Solvable.h"
  20
  21 using std::endl;
  22
  23 ///////////////////////////////////////////////////////////////////
  24 namespace zypp
  25 {
  26
  27   template<>
  28   struct ::_Queue * rwcowClone<struct ::_Queue>( const struct ::_Queue * rhs )
  29   {
  30     struct ::_Queue * ret = new ::_Queue;
  31     ::queue_init_clone( ret, const_cast<struct ::_Queue *>(rhs) );
  32     return ret;
  33   }
  34
  35   ///////////////////////////////////////////////////////////////////
  36   namespace sat
  37   {
  38
  39     Queue::Queue()
  40       : _pimpl( new ::_Queue )
  41     { ::queue_init( _pimpl.get() ); }
  42
  43     Queue::~Queue()
  44     { ::queue_free( _pimpl.get() ); }
  45
  46     bool Queue::empty() const
  47     { return( _pimpl->count == 0 ); }
  48
  49     Queue::size_type Queue::size() const
  50     { return _pimpl->count; }
  51
  52     Queue::const_iterator Queue::begin() const
  53     { return _pimpl->elements; }
  54
  55     Queue::const_iterator Queue::end() const
  56     { return _pimpl->elements + _pimpl->count;}
  57
  58     Queue::const_iterator Queue::find( value_type val_r ) const
  59     {
  60       for_( it, begin(), end() )
  61         if ( *it == val_r )
  62           return it;
  63       return end();
  64     }
  65
  66     Queue::value_type Queue::first() const
  67     {
  68       if ( _pimpl->count )
  69         return *_pimpl->elements;
  70       return 0;
  71     }
  72
  73     Queue::value_type Queue::last() const
  74     {
  75       if ( _pimpl->count )
  76         return _pimpl->elements[_pimpl->count-1];
  77       return 0;
  78     }
  79
  80 #define M_RANGE_CKECK(IDX,LOC) if ( IDX >= size_type(_pimpl->count) ) throw std::out_of_range( "zypp::sat::Queue::" LOC )
  81
  82     const Queue::value_type & Queue::at( size_type idx_r ) const
  83     { M_RANGE_CKECK( idx_r, "at" ); return _pimpl->elements[idx_r]; }
  84
  85     Queue::value_type & Queue::at( size_type idx_r )
  86     { M_RANGE_CKECK( idx_r, "at" ); return _pimpl->elements[idx_r]; }
  87
  88     const Queue::value_type & Queue::operator[]( size_type idx_r ) const
  89     { return _pimpl->elements[idx_r]; }
  90
  91     Queue::value_type & Queue::operator[]( size_type idx_r )
  92     { return _pimpl->elements[idx_r]; }
  93
  94     void Queue::clear()
  95     { ::queue_empty( *this ); }
  96
  97     void Queue::remove( value_type val_r )
  98     {
  99       for ( const_iterator it( find( val_r ) ); it != end(); it = find( val_r ) )
 100         ::queue_delete( _pimpl.get(), it - begin() );
 101     }
 102
 103     void Queue::push( value_type val_r )
 104     { ::queue_push( _pimpl.get(), val_r ); }
 105
 106     void Queue::pushUnique( value_type val_r )
 107     { ::queue_pushunique( _pimpl.get(), val_r ); }
 108
 109     Queue::value_type Queue::pop()
 110     { return ::queue_pop( _pimpl.get() ); }
 111
 112     void Queue::push_front( value_type val_r )
 113     { ::queue_unshift( _pimpl.get(), val_r ); }
 114
 115     Queue::value_type Queue::pop_front()
 116     { return ::queue_shift( _pimpl.get() ); }
 117
 118     Queue::operator struct ::_Queue *()         // COW: nonconst version can't be inlined
 119     { return _pimpl.get(); }                    // without exposing struct ::_Queue
 120
 121     std::ostream & operator<<( std::ostream & str, const Queue & obj )
 122     { return dumpRangeLine( str << "Queue ", obj.begin(), obj.end() );  }
 123
 124     std::ostream & dumpOn( std::ostream & str, const Queue & obj )
 125     {
 126       str << "Queue {";
 127       if ( ! obj.empty() )
 128       {
 129         str << endl;
 130         for_( it, obj.begin(), obj.end() )
 131           str << "  " << Solvable(*it) << endl;
 132       }
 133       return str << "}";
 134     }
 135
 136     bool operator==( const Queue & lhs, const Queue & rhs )
 137     {
 138       const struct ::_Queue * l = lhs;
 139       const struct ::_Queue * r = rhs;
 140       return( l == r || ( l->count == r->count && ::memcmp( l->elements, r->elements, l->count ) == 0 ) );
 141     }
 142
 143   } // namespace sat
 144   ///////////////////////////////////////////////////////////////////
 145 } // namespace zypp
 146 ///////////////////////////////////////////////////////////////////