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 operator/ ( const SmallSet& x ) const {
00092 SmallSet res;
00093 std::set_difference( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end(), inserter( res._elements, res._elements.begin() ) );
00094 return res;
00095 }
00096
00098 SmallSet operator| ( const SmallSet& x ) const {
00099 SmallSet res;
00100 std::set_union( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end(), inserter( res._elements, res._elements.begin() ) );
00101 return res;
00102 }
00103
00105 SmallSet operator& ( const SmallSet& x ) const {
00106 SmallSet res;
00107 std::set_intersection( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end(), inserter( res._elements, res._elements.begin() ) );
00108 return res;
00109 }
00110
00112 SmallSet& operator/= ( const SmallSet& x ) {
00113 return (*this = (*this / x));
00114 }
00115
00117 SmallSet& operator/= ( const T &t ) {
00118 typename std::vector<T>::iterator pos = lower_bound( _elements.begin(), _elements.end(), t );
00119 if( pos != _elements.end() )
00120 if( *pos == t )
00121 _elements.erase( pos );
00122 return *this;
00123 }
00124
00126 SmallSet& operator|= ( const SmallSet& x ) {
00127 return( *this = (*this | x) );
00128 }
00129
00131 SmallSet& operator|= ( const T& t ) {
00132 typename std::vector<T>::iterator pos = lower_bound( _elements.begin(), _elements.end(), t );
00133 if( pos == _elements.end() || *pos != t )
00134 _elements.insert( pos, t );
00135 return *this;
00136 }
00137
00139 SmallSet& operator&= ( const SmallSet& x ) {
00140 return (*this = (*this & x));
00141 }
00142
00144 bool operator<< ( const SmallSet& x ) const {
00145 return std::includes( x._elements.begin(), x._elements.end(), _elements.begin(), _elements.end() );
00146 }
00147
00149 bool operator>> ( const SmallSet& x ) const {
00150 return std::includes( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end() );
00151 }
00153
00155
00156
00157 bool intersects( const SmallSet& x ) const {
00158 return( (*this & x).size() > 0 );
00159 }
00160
00162 bool contains( const T &t ) const {
00163 return std::binary_search( _elements.begin(), _elements.end(), t );
00164 }
00165
00167 typename std::vector<T>::size_type size() const { return _elements.size(); }
00168
00170 bool empty() const { return _elements.size() == 0; }
00171
00173 std::vector<T>& elements() { return _elements; }
00174
00176 const std::vector<T>& elements() const { return _elements; }
00178
00180 typedef typename std::vector<T>::const_iterator const_iterator;
00182 typedef typename std::vector<T>::iterator iterator;
00184 typedef typename std::vector<T>::const_reverse_iterator const_reverse_iterator;
00186 typedef typename std::vector<T>::reverse_iterator reverse_iterator;
00187
00189
00190
00191 iterator begin() { return _elements.begin(); }
00193 const_iterator begin() const { return _elements.begin(); }
00194
00196 iterator end() { return _elements.end(); }
00198 const_iterator end() const { return _elements.end(); }
00199
00201 reverse_iterator rbegin() { return _elements.rbegin(); }
00203 const_reverse_iterator rbegin() const { return _elements.rbegin(); }
00204
00206 reverse_iterator rend() { return _elements.rend(); }
00208 const_reverse_iterator rend() const { return _elements.rend(); }
00209
00211 T& front() { return _elements.front(); }
00213 const T& front() const { return _elements.front(); }
00214
00216 T& back() { return _elements.back(); }
00218 const T& back() const { return _elements.back(); }
00220
00222
00223
00224 friend bool operator==( const SmallSet &a, const SmallSet &b ) {
00225 return (a._elements == b._elements);
00226 }
00227
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 }
00238
00240
00241
00242 friend std::ostream& operator << ( std::ostream& os, const SmallSet& x ) {
00243 os << "{";
00244 for( typename std::vector<T>::const_iterator it = x.begin(); it != x.end(); it++ )
00245 os << (it != x.begin() ? ", " : "") << *it;
00246 os << "}";
00247 return os;
00248 }
00250 };
00251
00252
00253 }
00254
00255
00256 #endif