00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00015
00016
00017 #ifndef __defined_libdai_smallset_h
00018 #define __defined_libdai_smallset_h
00019
00020
00021 #include <vector>
00022 #include <algorithm>
00023 #include <iostream>
00024
00025
00026 namespace dai {
00027
00028
00030
00034 template <typename T>
00035 class SmallSet {
00036 private:
00038 std::vector<T> _elements;
00039
00040 public:
00042
00043
00044 SmallSet() : _elements() {}
00045
00047 SmallSet( const T &t ) : _elements() {
00048 _elements.push_back( t );
00049 }
00050
00052 SmallSet( const T &t1, const T &t2 ) {
00053 if( t1 < t2 ) {
00054 _elements.push_back( t1 );
00055 _elements.push_back( t2 );
00056 } else if( t2 < t1 ) {
00057 _elements.push_back( t2 );
00058 _elements.push_back( t1 );
00059 } else
00060 _elements.push_back( t1 );
00061 }
00062
00064
00070 template <typename TIterator>
00071 SmallSet( TIterator begin, TIterator end, size_t sizeHint ) {
00072 _elements.reserve( sizeHint );
00073 _elements.insert( _elements.begin(), begin, end );
00074 std::sort( _elements.begin(), _elements.end() );
00075 typename std::vector<T>::iterator new_end = std::unique( _elements.begin(), _elements.end() );
00076 _elements.erase( new_end, _elements.end() );
00077 }
00079
00081
00082
00083 SmallSet& insert( const T& t ) {
00084 typename SmallSet<T>::iterator it = std::lower_bound( _elements.begin(), _elements.end(), t );
00085 if( (it == _elements.end()) || (*it != t) )
00086 _elements.insert( it, t );
00087 return *this;
00088 }
00089
00091 SmallSet& erase( const T& t ) {
00092 return (*this /= t);
00093 }
00094
00096 SmallSet operator/ ( const SmallSet& x ) const {
00097 SmallSet res;
00098 std::set_difference( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end(), inserter( res._elements, res._elements.begin() ) );
00099 return res;
00100 }
00101
00103 SmallSet operator| ( const SmallSet& x ) const {
00104 SmallSet res;
00105 std::set_union( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end(), inserter( res._elements, res._elements.begin() ) );
00106 return res;
00107 }
00108
00110 SmallSet operator& ( const SmallSet& x ) const {
00111 SmallSet res;
00112 std::set_intersection( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end(), inserter( res._elements, res._elements.begin() ) );
00113 return res;
00114 }
00115
00117 SmallSet& operator/= ( const SmallSet& x ) {
00118 return (*this = (*this / x));
00119 }
00120
00122 SmallSet& operator/= ( const T &t ) {
00123 typename std::vector<T>::iterator pos = lower_bound( _elements.begin(), _elements.end(), t );
00124 if( pos != _elements.end() )
00125 if( *pos == t )
00126 _elements.erase( pos );
00127 return *this;
00128 }
00129
00131 SmallSet& operator|= ( const SmallSet& x ) {
00132 return( *this = (*this | x) );
00133 }
00134
00136 SmallSet& operator|= ( const T& t ) {
00137 typename std::vector<T>::iterator pos = lower_bound( _elements.begin(), _elements.end(), t );
00138 if( pos == _elements.end() || *pos != t )
00139 _elements.insert( pos, t );
00140 return *this;
00141 }
00142
00144 SmallSet& operator&= ( const SmallSet& x ) {
00145 return (*this = (*this & x));
00146 }
00147
00149 bool operator<< ( const SmallSet& x ) const {
00150 return std::includes( x._elements.begin(), x._elements.end(), _elements.begin(), _elements.end() );
00151 }
00152
00154 bool operator>> ( const SmallSet& x ) const {
00155 return std::includes( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end() );
00156 }
00158
00160
00161
00162 bool intersects( const SmallSet& x ) const {
00163 return( (*this & x).size() > 0 );
00164 }
00165
00167 bool contains( const T &t ) const {
00168 return std::binary_search( _elements.begin(), _elements.end(), t );
00169 }
00170
00172 typename std::vector<T>::size_type size() const { return _elements.size(); }
00173
00175 bool empty() const { return _elements.size() == 0; }
00176
00178 std::vector<T>& elements() { return _elements; }
00179
00181 const std::vector<T>& elements() const { return _elements; }
00183
00185 typedef typename std::vector<T>::const_iterator const_iterator;
00187 typedef typename std::vector<T>::iterator iterator;
00189 typedef typename std::vector<T>::const_reverse_iterator const_reverse_iterator;
00191 typedef typename std::vector<T>::reverse_iterator reverse_iterator;
00192
00194
00195
00196 iterator begin() { return _elements.begin(); }
00198 const_iterator begin() const { return _elements.begin(); }
00199
00201 iterator end() { return _elements.end(); }
00203 const_iterator end() const { return _elements.end(); }
00204
00206 reverse_iterator rbegin() { return _elements.rbegin(); }
00208 const_reverse_iterator rbegin() const { return _elements.rbegin(); }
00209
00211 reverse_iterator rend() { return _elements.rend(); }
00213 const_reverse_iterator rend() const { return _elements.rend(); }
00214
00216 T& front() { return _elements.front(); }
00218 const T& front() const { return _elements.front(); }
00219
00221 T& back() { return _elements.back(); }
00223 const T& back() const { return _elements.back(); }
00225
00227
00228
00229 friend bool operator==( const SmallSet &a, const SmallSet &b ) {
00230 return (a._elements == b._elements);
00231 }
00232
00234 friend bool operator!=( const SmallSet &a, const SmallSet &b ) {
00235 return !(a._elements == b._elements);
00236 }
00237
00239 friend bool operator<( const SmallSet &a, const SmallSet &b ) {
00240 return a._elements < b._elements;
00241 }
00243
00245
00246
00247 friend std::ostream& operator << ( std::ostream& os, const SmallSet& x ) {
00248 os << "{";
00249 for( typename std::vector<T>::const_iterator it = x.begin(); it != x.end(); it++ )
00250 os << (it != x.begin() ? ", " : "") << *it;
00251 os << "}";
00252 return os;
00253 }
00255 };
00256
00257
00258 }
00259
00260
00261 #endif