Cleaned up error handling by introducing the DAI_THROWE macro.
[libdai.git] / include / dai / smallset.h
index b5e4121..b3f9daa 100644 (file)
@@ -24,7 +24,7 @@
 
 
 /// \file
-/// \brief Defines smallSet<T> class
+/// \brief Defines SmallSet<T> class
 
 
 #ifndef __defined_libdai_smallset_h
 namespace dai {
 
 
-/// Represents a set (optimized for a small number of elements).
-/** For sets consisting of a small number of elements, an implementation using
- *  an ordered std::vector<T> is faster than an implementation using std::set<T>.
- *  The elements should be less-than-comparable.
+/// Represents a set; the implementation is optimized for a small number of elements.
+/** SmallSet uses an ordered std::vector<T> to represent a set; this is faster than
+ *  using a std::set<T> if the number of elements is small.
+ *  \tparam T Should be less-than-comparable.
  */
 template <typename T>
-class smallSet {
+class SmallSet {
     private:
         /// The elements in this set
         std::vector<T> _elements;
 
     public:
-        /// Default constructor
-        smallSet() : _elements() {}
-
-        /// Construct a smallSet with one element
-        smallSet( const T &n ) : _elements() { 
-            _elements.push_back( n );
-        }
-
-        /// Construct a smallSet with two elements
-        smallSet( const T &n1, const T &n2 ) { 
-            if( n1 < n2 ) {
-                _elements.push_back( n1 );
-                _elements.push_back( n2 );
-            } else if( n2 < n1 ) {
-                _elements.push_back( n2 );
-                _elements.push_back( n1 );
+        /// Default constructor (construct an empty set)
+        SmallSet() : _elements() {}
+
+        /// Construct a set with one element
+        SmallSet( const T &t ) : _elements() { 
+            _elements.push_back( t );
+        }
+
+        /// Construct a set with two elements
+        SmallSet( const T &t1, const T &t2 ) { 
+            if( t1 < t2 ) {
+                _elements.push_back( t1 );
+                _elements.push_back( t2 );
+            } else if( t2 < t1 ) {
+                _elements.push_back( t2 );
+                _elements.push_back( t1 );
             } else
-                _elements.push_back( n1 );
+                _elements.push_back( t1 );
         }
 
-        /// Construct a smallSet from a range of iterators.
-        /** \tparam Iterator Iterator with value_type T.
+        /// Construct a SmallSet from a range of elements.
+        /** \tparam TIterator Iterates over instances of type T.
          *  \param begin Points to first element to be added.
          *  \param end Points just beyond last element to be added.
          *  \param sizeHint For efficiency, the number of elements can be speficied by sizeHint.
          */
-        template <typename Iterator>
-        smallSet( Iterator begin, Iterator end, size_t sizeHint=0 ) {
+        template <typename TIterator>
+        SmallSet( TIterator begin, TIterator end, size_t sizeHint=0 ) {
             _elements.reserve( sizeHint );
             _elements.insert( _elements.begin(), begin, end );
             std::sort( _elements.begin(), _elements.end() );
@@ -85,88 +85,77 @@ class smallSet {
             _elements.erase( new_end, _elements.end() );
         }
 
-        /// Copy constructor
-        smallSet( const smallSet &x ) : _elements( x._elements ) {}
-
-        /// Assignment operator
-        smallSet & operator=( const smallSet &x ) {
-            if( this != &x ) {
-                _elements = x._elements;
-            }
-            return *this;
-        }
-        
-        /// Setminus operator: returns all elements in *this, except those in ns
-        smallSet operator/ ( const smallSet& ns ) const {
-            smallSet res;
-            std::set_difference( _elements.begin(), _elements.end(), ns._elements.begin(), ns._elements.end(), inserter( res._elements, res._elements.begin() ) );
+        /// Set-minus operator: returns all elements in *this, except those in x
+        SmallSet operator/ ( const SmallSet& x ) const {
+            SmallSet res;
+            std::set_difference( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end(), inserter( res._elements, res._elements.begin() ) );
             return res;
         }
 
-        /// Set-union operator: returns all elements in *this, plus those in ns
-        smallSet operator| ( const smallSet& ns ) const {
-            smallSet res;
-            std::set_union( _elements.begin(), _elements.end(), ns._elements.begin(), ns._elements.end(), inserter( res._elements, res._elements.begin() ) );
+        /// Set-union operator: returns all elements in *this, plus those in x
+        SmallSet operator| ( const SmallSet& x ) const {
+            SmallSet res;
+            std::set_union( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end(), inserter( res._elements, res._elements.begin() ) );
             return res;
         }
 
-        /// Set-intersection operator: returns all elements in *this that are also contained in ns
-        smallSet operator& ( const smallSet& ns ) const {
-            smallSet res;
-            std::set_intersection( _elements.begin(), _elements.end(), ns._elements.begin(), ns._elements.end(), inserter( res._elements, res._elements.begin() ) );
+        /// Set-intersection operator: returns all elements in *this that are also contained in 
+        SmallSet operator& ( const SmallSet& x ) const {
+            SmallSet res;
+            std::set_intersection( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end(), inserter( res._elements, res._elements.begin() ) );
             return res;
         }
         
-        /// Erases from *this all elements in ns
-        smallSet& operator/= ( const smallSet& ns ) {
-            return (*this = (*this / ns));
+        /// Erases from *this all elements in x
+        SmallSet& operator/= ( const SmallSet& x ) {
+            return (*this = (*this / x));
         }
 
         /// Erases one element
-        smallSet& operator/= ( const T& n ) { 
-            typename std::vector<T>::iterator pos = lower_bound( _elements.begin(), _elements.end(), n );
+        SmallSet& operator/= ( const T &t ) { 
+            typename std::vector<T>::iterator pos = lower_bound( _elements.begin(), _elements.end(), t );
             if( pos != _elements.end() )
-                if( *pos == n ) // found element, delete it
+                if( *pos == t ) // found element, delete it
                     _elements.erase( pos ); 
             return *this; 
         }
 
-        /// Adds to *this all elements in ns
-        smallSet& operator|= ( const smallSet& ns ) {
-            return( *this = (*this | ns) );
+        /// Adds to *this all elements in x
+        SmallSet& operator|= ( const SmallSet& x ) {
+            return( *this = (*this | x) );
         }
 
         /// Adds one element
-        smallSet& operator|= ( const T& n ) {
-            typename std::vector<T>::iterator pos = lower_bound( _elements.begin(), _elements.end(), n );
-            if( pos == _elements.end() || *pos != n ) // insert it
-                _elements.insert( pos, n );
+        SmallSet& operator|= ( const T& t ) {
+            typename std::vector<T>::iterator pos = lower_bound( _elements.begin(), _elements.end(), t );
+            if( pos == _elements.end() || *pos != t ) // insert it
+                _elements.insert( pos, t );
             return *this;
         }
 
-        /// Erases from *this all elements not in ns
-        smallSet& operator&= ( const smallSet& ns ) { 
-            return (*this = (*this & ns));
+        /// Erases from *this all elements not in x
+        SmallSet& operator&= ( const SmallSet& x ) { 
+            return (*this = (*this & x));
         }
 
-        /// Returns true if *this is a subset of ns
-        bool operator<< ( const smallSet& ns ) const { 
-            return std::includes( ns._elements.begin(), ns._elements.end(), _elements.begin(), _elements.end() );
+        /// Returns true if *this is a subset of x
+        bool operator<< ( const SmallSet& x ) const { 
+            return std::includes( x._elements.begin(), x._elements.end(), _elements.begin(), _elements.end() );
         }
 
-        /// Returns true if ns is a subset of *this
-        bool operator>> ( const smallSet& ns ) const { 
-            return std::includes( _elements.begin(), _elements.end(), ns._elements.begin(), ns._elements.end() );
+        /// Returns true if x is a subset of *this
+        bool operator>> ( const SmallSet& x ) const { 
+            return std::includes( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end() );
         }
 
-        /// Returns true if *this and ns contain common elements
-        bool intersects( const smallSet& ns ) const { 
-            return( (*this & ns).size() > 0 ); 
+        /// Returns true if *this and x have elements in common
+        bool intersects( const SmallSet& x ) const { 
+            return( (*this & x).size() > 0 ); 
         }
 
-        /// Returns true if *this contains the element n
-        bool contains( const T& n ) const { 
-            return std::binary_search( _elements.begin(), _elements.end(), n );
+        /// Returns true if *this contains the element t
+        bool contains( const T &t ) const { 
+            return std::binary_search( _elements.begin(), _elements.end(), t );
         }
 
         /// Constant iterator over the elements
@@ -201,21 +190,21 @@ class smallSet {
         /// Returns number of elements
         typename std::vector<T>::size_type size() const { return _elements.size(); }
 
-        /// Returns whether the smallSet is empty
+        /// Returns whether the SmallSet is empty
         bool empty() const { return _elements.size() == 0; }
 
-        /// Returns true if the two sets are identical
-        friend bool operator==( const smallSet &a, const smallSet &b ) {
+        /// Returns true if a and b are identical
+        friend bool operator==( const SmallSet &a, const SmallSet &b ) {
             return (a._elements == b._elements);
         }
 
-        /// Returns true if the two sets are not identical
-        friend bool operator!=( const smallSet &a, const smallSet &b ) {
+        /// Returns true if a and b are not identical
+        friend bool operator!=( const SmallSet &a, const SmallSet &b ) {
             return !(a._elements == b._elements);
         }
 
         /// Lexicographical comparison of elements
-        friend bool operator<( const smallSet &a, const smallSet &b ) {
+        friend bool operator<( const SmallSet &a, const SmallSet &b ) {
             return a._elements < b._elements;
         }
 };