wibble  1.1
operators.h
Go to the documentation of this file.
1 // -*- C++ -*-
2 
3 #include <set>
4 #include <wibble/empty.h>
5 #include <wibble/singleton.h>
6 #include <algorithm>
7 
8 #ifndef WIBBLE_OPERATORS_H
9 #define WIBBLE_OPERATORS_H
10 
11 namespace wibble {
12 namespace operators {
13 
14 /*
15 template< typename S, typename VT > struct IsContainer {
16  typedef S T;
17 };
18 
19 template< typename S >
20 typename IsContainer< S, typename S::value_type >::T operator &&( const S &a, const S &b ) {
21  S ret;
22  std::set_intersection( a.begin(), a.end(), b.begin(), b.end(),
23  std::inserter( ret, ret.begin() ) );
24  return ret;
25 }
26 */
27 
28 template< typename T >
29 T operator+( const T &i, typename T::difference_type o ) {
30  T r = i;
31  std::advance( r, o );
32  return r;
33 }
34 
35 template< typename T >
36 std::set< T > operator &( const std::set< T > &a, const std::set< T > &b ) {
37  std::set< T > ret;
38  std::set_intersection( a.begin(), a.end(), b.begin(), b.end(),
39  std::inserter( ret, ret.begin() ) );
40  return ret;
41 }
42 
43 template< typename T >
44 std::set< T > operator &( const std::set< T > &a, const T &b ) {
45  std::set< T > ret;
46  if ( a.find( b ) != a.end() ) {
47  std::set< T > r;
48  r.insert( b );
49  return r;
50  }
51  return std::set< T >();
52 }
53 
54 template< typename T >
55 std::set< T > operator |( const std::set< T > &a, const T& item ) {
56  std::set< T > ret = a;
57  ret.insert(item);
58  return ret;
59 }
60 
61 template< typename T >
62 std::set< T > operator |( const std::set< T > &a, const wibble::Empty<T>& ) {
63  return a;
64 }
65 
66 template< typename T >
67 std::set< T > operator |( const std::set< T > &a, const wibble::Singleton<T>& item ) {
68  std::set< T > ret = a;
69  ret.insert(*item.begin());
70  return ret;
71 }
72 
73 template< typename T >
74 std::set< T > operator |( const std::set< T > &a, const std::set< T > &b ) {
75  std::set< T > ret;
76  std::set_union( a.begin(), a.end(), b.begin(), b.end(),
77  std::inserter( ret, ret.begin() ) );
78  return ret;
79 }
80 
81 template< typename T >
82 std::set< T > operator -( const std::set< T > &a, const std::set< T > &b ) {
83  std::set< T > ret;
84  std::set_difference( a.begin(), a.end(), b.begin(), b.end(),
85  std::inserter(ret, ret.begin() ) );
86  return ret;
87 }
88 
89 template< typename T >
90 std::set< T > operator -( const std::set< T > &a, const T& item ) {
91  std::set< T > ret = a;
92  ret.erase(item);
93  return ret;
94 }
95 
96 template< typename T >
97 std::set< T > operator -( const std::set< T > &a, const wibble::Singleton<T>& item ) {
98  std::set< T > ret = a;
99  ret.erase(*item.begin());
100  return ret;
101 }
102 
103 template< typename T >
104 std::set< T > operator -( const std::set< T > &a, const wibble::Empty<T>& ) {
105  return a;
106 }
107 
108 template< typename T >
109 std::set< T > &operator|=( std::set< T > &a, const wibble::Empty<T>& )
110 {
111  return a;
112 }
113 
114 template< typename T >
115 std::set< T > &operator|=( std::set< T > &a, const T& item )
116 {
117  a.insert(item);
118  return a;
119 }
120 
121 // General case
122 template< typename T, typename SEQ >
123 std::set< T > &operator|=( std::set< T > &a, const SEQ& items )
124 {
125  for (typename SEQ::const_iterator i = items.begin();
126  i != items.end(); ++i)
127  a.insert(*i);
128  return a;
129 }
130 
131 // Little optimization in case a is empty
132 template< typename T >
133 std::set< T > &operator |=( std::set< T > &a, const std::set< T > &b ) {
134  if (a.empty())
135  return a = b;
136 
137  for (typename std::set<T>::const_iterator i = b.begin();
138  i != b.end(); ++i)
139  a.insert(*i);
140  return a;
141 }
142 
143 // General case, but assumes that b is sorted
144 template< typename T, typename SEQ >
145 std::set< T > &operator &=( std::set< T > &a, const SEQ& b ) {
146  // Little optimization: if b is empty, we avoid a run through a
147  if (b.empty())
148  {
149  a.clear();
150  return a;
151  }
152 
153  typename std::set<T>::iterator ia = a.begin();
154  typename SEQ::const_iterator ib = b.begin();
155  while (ia != a.end())
156  {
157  if (ib != b.end() && *ib < *ia)
158  {
159  ++ib;
160  }
161  else if (ib == b.end() || *ia != *ib)
162  {
163  typename std::set<T>::iterator tmp = ia;
164  ++ia;
165  a.erase(tmp);
166  }
167  else
168  {
169  ++ia;
170  ++ib;
171  }
172  }
173  return a;
174 }
175 
176 template< typename T >
177 std::set< T > &operator-=( std::set< T > &a, const wibble::Empty<T>& )
178 {
179  return a;
180 }
181 
182 template< typename T >
183 std::set< T > &operator-=( std::set< T > &a, const T& item )
184 {
185  a.erase(item);
186  return a;
187 }
188 
189 template< typename T >
190 std::set< T > &operator-=( std::set< T > &a, const wibble::Singleton<T>& item )
191 {
192  a.erase(*item.begin());
193  return a;
194 }
195 
196 // General case, but works only if b is sorted
197 template< typename T, typename SEQ >
198 std::set< T > &operator -=( std::set< T > &a, const SEQ& b )
199 {
200  typename std::set<T>::iterator ia = a.begin();
201  typename SEQ::const_iterator ib = b.begin();
202  while (ia != a.end() && ib != b.end())
203  {
204  if (*ia == *ib)
205  {
206  typename std::set<T>::iterator tmp = ia;
207  ++ia;
208  ++ib;
209  a.erase(tmp);
210  }
211  else if (*ia < *ib)
212  ++ia;
213  else
214  ++ib;
215  }
216  return a;
217 }
218 
219 template< typename T >
220 bool operator<=( const T &a, const std::set< T > &b ) {
221  return b.find( a ) != b.end();
222 }
223 
224 template< typename T >
225 bool operator<=( const std::set< T > &a, const std::set< T > &b ) {
226  typename std::set<T>::const_iterator x = a.begin();
227 
228  for ( typename std::set<T>::const_iterator y = b.begin(); y != b.end(); ++y )
229  if ( x == a.end() )
230  return true;
231  else if (*x == *y)
232  ++x;
233  else if (*x < *y)
234  return false;
235 
236  return x == a.end();
237 }
238 
239 }
240 }
241 
242 #endif
Definition: empty.h:32
Definition: singleton.h:33
iterator begin()
Definition: singleton.h:84
T operator+(const T &i, typename T::difference_type o)
Definition: operators.h:29
std::set< T > & operator|=(std::set< T > &a, const wibble::Empty< T > &)
Definition: operators.h:109
std::set< T > operator&(const std::set< T > &a, const std::set< T > &b)
Definition: operators.h:36
std::set< T > & operator-=(std::set< T > &a, const wibble::Empty< T > &)
Definition: operators.h:177
std::set< T > & operator&=(std::set< T > &a, const SEQ &b)
Definition: operators.h:145
std::set< T > operator|(const std::set< T > &a, const T &item)
Definition: operators.h:55
std::set< T > operator-(const std::set< T > &a, const std::set< T > &b)
Definition: operators.h:82
bool operator<=(const T &a, const std::set< T > &b)
Definition: operators.h:220
Definition: amorph.h:17
Iterator< typename I::value_type > iterator(I i)
Definition: iterator.h:123