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
00024
00025 namespace dai {
00026
00027
00029
00033 template <typename T>
00034 class SmallSet {
00035 private:
00037 std::vector<T> _elements;
00038
00039 public:
00041
00042
00043 SmallSet() : _elements() {}
00044
00046 SmallSet( const T &t ) : _elements() {
00047 _elements.push_back( t );
00048 }
00049
00051 SmallSet( const T &t1, const T &t2 ) {
00052 if( t1 < t2 ) {
00053 _elements.push_back( t1 );
00054 _elements.push_back( t2 );
00055 } else if( t2 < t1 ) {
00056 _elements.push_back( t2 );
00057 _elements.push_back( t1 );
00058 } else
00059 _elements.push_back( t1 );
00060 }
00061
00063
00068 template <typename TIterator>
00069 SmallSet( TIterator begin, TIterator end, size_t sizeHint=0 ) {
00070 _elements.reserve( sizeHint );
00071 _elements.insert( _elements.begin(), begin, end );
00072 std::sort( _elements.begin(), _elements.end() );
00073 typename std::vector<T>::iterator new_end = std::unique( _elements.begin(), _elements.end() );
00074 _elements.erase( new_end, _elements.end() );
00075 }
00077
00079
00080
00081 SmallSet operator/ ( const SmallSet& x ) const {
00082 SmallSet res;
00083 std::set_difference( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end(), inserter( res._elements, res._elements.begin() ) );
00084 return res;
00085 }
00086
00088 SmallSet operator| ( const SmallSet& x ) const {
00089 SmallSet res;
00090 std::set_union( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end(), inserter( res._elements, res._elements.begin() ) );
00091 return res;
00092 }
00093
00095 SmallSet operator& ( const SmallSet& x ) const {
00096 SmallSet res;
00097 std::set_intersection( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end(), inserter( res._elements, res._elements.begin() ) );
00098 return res;
00099 }
00100
00102 SmallSet& operator/= ( const SmallSet& x ) {
00103 return (*this = (*this / x));
00104 }
00105
00107 SmallSet& operator/= ( const T &t ) {
00108 typename std::vector<T>::iterator pos = lower_bound( _elements.begin(), _elements.end(), t );
00109 if( pos != _elements.end() )
00110 if( *pos == t )
00111 _elements.erase( pos );
00112 return *this;
00113 }
00114
00116 SmallSet& operator|= ( const SmallSet& x ) {
00117 return( *this = (*this | x) );
00118 }
00119
00121 SmallSet& operator|= ( const T& t ) {
00122 typename std::vector<T>::iterator pos = lower_bound( _elements.begin(), _elements.end(), t );
00123 if( pos == _elements.end() || *pos != t )
00124 _elements.insert( pos, t );
00125 return *this;
00126 }
00127
00129 SmallSet& operator&= ( const SmallSet& x ) {
00130 return (*this = (*this & x));
00131 }
00132
00134 bool operator<< ( const SmallSet& x ) const {
00135 return std::includes( x._elements.begin(), x._elements.end(), _elements.begin(), _elements.end() );
00136 }
00137
00139 bool operator>> ( const SmallSet& x ) const {
00140 return std::includes( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end() );
00141 }
00143
00145
00146
00147 bool intersects( const SmallSet& x ) const {
00148 return( (*this & x).size() > 0 );
00149 }
00150
00152 bool contains( const T &t ) const {
00153 return std::binary_search( _elements.begin(), _elements.end(), t );
00154 }
00155
00157 typename std::vector<T>::size_type size() const { return _elements.size(); }
00158
00160 bool empty() const { return _elements.size() == 0; }
00161
00163 std::vector<T>& elements() { return _elements; }
00164
00166 const std::vector<T>& elements() const { return _elements; }
00168
00170 typedef typename std::vector<T>::const_iterator const_iterator;
00172 typedef typename std::vector<T>::iterator iterator;
00174 typedef typename std::vector<T>::const_reverse_iterator const_reverse_iterator;
00176 typedef typename std::vector<T>::reverse_iterator reverse_iterator;
00177
00179
00180
00181 iterator begin() { return _elements.begin(); }
00183 const_iterator begin() const { return _elements.begin(); }
00184
00186 iterator end() { return _elements.end(); }
00188 const_iterator end() const { return _elements.end(); }
00189
00191 reverse_iterator rbegin() { return _elements.rbegin(); }
00193 const_reverse_iterator rbegin() const { return _elements.rbegin(); }
00194
00196 reverse_iterator rend() { return _elements.rend(); }
00198 const_reverse_iterator rend() const { return _elements.rend(); }
00199
00201 T& front() { return _elements.at(0); }
00203 const T& front() const { return _elements.at(0); }
00205
00207
00208
00209 friend bool operator==( const SmallSet &a, const SmallSet &b ) {
00210 return (a._elements == b._elements);
00211 }
00212
00214 friend bool operator!=( const SmallSet &a, const SmallSet &b ) {
00215 return !(a._elements == b._elements);
00216 }
00217
00219 friend bool operator<( const SmallSet &a, const SmallSet &b ) {
00220 return a._elements < b._elements;
00221 }
00223 };
00224
00225
00226 }
00227
00228
00229 #endif