libzypp  17.5.0
Queue.cc
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
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 
24 namespace zypp
25 {
26 
27  template<>
28  sat::detail::CQueue * rwcowClone<sat::detail::CQueue>( const sat::detail::CQueue * rhs )
29  {
31  ::queue_init_clone( ret, const_cast<sat::detail::CQueue *>(rhs) );
32  return ret;
33  }
34 
36  namespace sat
37  {
38 
40  : _pimpl( new detail::CQueue )
41  { ::queue_init( _pimpl.get() ); }
42 
44  { ::queue_free( _pimpl.get() ); }
45 
46  bool Queue::empty() const
47  { return( _pimpl->count == 0 ); }
48 
50  { return _pimpl->count; }
51 
53  { return _pimpl->elements; }
54 
56  { return _pimpl->elements + _pimpl->count;}
57 
59  {
60  for_( it, begin(), end() )
61  if ( *it == val_r )
62  return it;
63  return end();
64  }
65 
67  {
68  if ( _pimpl->count )
69  return *_pimpl->elements;
70  return 0;
71  }
72 
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 
86  { M_RANGE_CKECK( idx_r, "at" ); return _pimpl->elements[idx_r]; }
87 
89  { return _pimpl->elements[idx_r]; }
90 
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 
107  { ::queue_pushunique( _pimpl.get(), val_r ); }
108 
110  { return ::queue_pop( _pimpl.get() ); }
111 
113  { ::queue_unshift( _pimpl.get(), val_r ); }
114 
116  { return ::queue_shift( _pimpl.get() ); }
117 
118  Queue::operator detail::CQueue *() // COW: nonconst version can't be inlined
119  { return _pimpl.get(); } // without exposing detail::CQueue
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 detail::CQueue * l = lhs;
139  const detail::CQueue * r = rhs;
140  return( l == r || ( l->count == r->count && ::memcmp( l->elements, r->elements, l->count ) == 0 ) );
141  }
142 
143  } // namespace sat
145 } // namespace zypp
bool empty() const
Definition: Queue.cc:46
void remove(value_type val_r)
Remove all occurances of val_r from the queue.
Definition: Queue.cc:97
A Solvable object within the sat Pool.
Definition: Solvable.h:53
detail::IdType value_type
Definition: Queue.h:38
bool operator==(const Map &lhs, const Map &rhs)
Definition: Map.cc:123
const_iterator find(value_type val_r) const
Return iterator to the 1st occurance of val_r or end.
Definition: Queue.cc:58
std::ostream & operator<<(std::ostream &str, const FileConflicts &obj)
String related utilities and Regular expression matching.
#define for_(IT, BEG, END)
Convenient for-loops using iterator.
Definition: Easy.h:27
value_type last() const
Return the last Id in the queue or 0 if empty.
Definition: Queue.cc:73
const_iterator begin() const
Definition: Queue.cc:52
void push(value_type val_r)
Push a value to the end off the Queue.
Definition: Queue.cc:103
void pushUnique(value_type val_r)
Push a value if it&#39;s not yet in the Queue.
Definition: Queue.cc:106
value_type pop_front()
Pop and return the 1st Id from the queue or 0 if empty.
Definition: Queue.cc:115
unsigned size_type
Definition: Queue.h:37
void push_front(value_type val_r)
Push a value to the beginning off the Queue.
Definition: Queue.cc:112
const value_type * const_iterator
Definition: Queue.h:39
const value_type & operator[](size_type idx_r) const
Return the Id at idx_r in the queue (no range check)
Definition: Queue.cc:88
RWCOW_pointer< detail::CQueue > _pimpl
Pointer to implementation.
Definition: Queue.h:114
std::ostream & dumpOn(std::ostream &str, const LocaleSupport &obj)
size_type size() const
Definition: Queue.cc:49
Libsolv Id queue wrapper.
Definition: Queue.h:34
const value_type & at(size_type idx_r) const
Return the Id at idx_r in the queue.
Definition: Queue.cc:82
void clear()
Clear the queue.
Definition: Queue.cc:94
value_type first() const
Return the 1st Id in the queue or 0 if empty.
Definition: Queue.cc:66
std::ostream & dumpRangeLine(std::ostream &str, TIterator begin, TIterator end)
Print range defined by iterators (single line style).
Definition: LogTools.h:114
const D * get() const
Definition: PtrTypes.h:503
#define M_RANGE_CKECK(IDX, LOC)
Definition: Queue.cc:80
Queue()
Default ctor: empty Queue.
Definition: Queue.cc:39
::_Queue CQueue
Wrapped libsolv C data type exposed as backdoor.
Definition: PoolMember.h:62
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:1
~Queue()
Dtor.
Definition: Queue.cc:43
const_iterator end() const
Definition: Queue.cc:55
value_type pop()
Pop and return the last Id from the queue or 0 if empty.
Definition: Queue.cc:109