SetFunctions.h

 
#pragma once
 
#if defined(SetFunctions_RECURSES)
#error Recursive header files inclusion detected in SetFunctions.h
#else // defined(SetFunctions_RECURSES)
#define SetFunctions_RECURSES
 
#if !defined SetFunctions_h
#define SetFunctions_h
 
// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/base/ContainerTraits.h"
 
namespace DGtal
{
 
  namespace detail {
    template <typename LessThan, typename T> 
    struct EqualPredicateFromLessThanComparator {
      LessThan compare;
      EqualPredicateFromLessThanComparator( LessThan aCompare )
        : compare( aCompare ) {}
      bool operator()( const T& t1, const T& t2 ) const
      {
        return ( ! compare( t1, t2 ) ) && ( ! compare( t2, t1 ) );
      }
    };
    template <typename KeyComparator, typename PairKeyData> 
    struct KeyComparatorForPairKeyData {
      KeyComparator compare;
      KeyComparatorForPairKeyData( KeyComparator aCompare )
        : compare( aCompare ) {}
      bool operator()( const PairKeyData& t1, const PairKeyData& t2 ) const
      {
        return compare( t1.first, t2.first );
      }
    };
 
    template <typename Container, bool associative, bool ordered, bool pair>
    struct ComparatorAdapter
    {
      typedef typename Container::value_type value_type;
      typedef std::less< value_type >           LessThanPredicate;
      typedef std::equal_to< value_type >       EqualPredicate;
      static LessThanPredicate less( const Container& /* C */ )
      {
        return LessThanPredicate();
      }
      static EqualPredicate equal_to( const Container& /* C */ )
      {
        return EqualPredicate();
      }
      static inline const value_type& key( const value_type& value )
      {
        return value;
      }
      
    };
 
    template <typename Container>
    struct ComparatorAdapter< Container, true, true, false > 
    {
      typedef typename Container::value_type  value_type;
      typedef typename Container::key_type    key_type;
      typedef typename Container::key_compare key_compare;
      typedef key_compare                     LessThanPredicate;
      typedef EqualPredicateFromLessThanComparator< LessThanPredicate, value_type >
                                              EqualPredicate;
      static LessThanPredicate less( const Container& C )
      {
        return C.key_comp();
      }
      static EqualPredicate equal_to( const Container& C )
      {
        return EqualPredicate( C.key_comp() );
      }
      static inline const key_type& key( const value_type& value )
      {
        return value;
      }
    };
 
    template <typename Container>
    struct ComparatorAdapter< Container, true, true, true > 
    {
      typedef typename Container::value_type  value_type;
      typedef typename Container::key_type    key_type;
      typedef typename Container::key_compare key_compare;
      typedef KeyComparatorForPairKeyData< key_compare, value_type >
                                              LessThanPredicate;
      typedef EqualPredicateFromLessThanComparator< LessThanPredicate, value_type >
                                              EqualPredicate;
      static LessThanPredicate less( const Container& C )
      {
        return LessThanPredicate( C.key_comp() );
      }
      static EqualPredicate equal_to( const Container& C )
      {
        return EqualPredicate( less( C ) );
      }
      static inline const key_type& key( const value_type& value )
      {
        return value.first;
      }
    };
 
    template <typename Container>
    struct ComparatorAdapter< Container, true, false, false > 
    {
      typedef typename Container::value_type  value_type;
      typedef typename Container::key_type    key_type;
      typedef std::less< key_type >           LessThanPredicate;
      typedef std::equal_to< key_type >       EqualPredicate;
      static LessThanPredicate less( const Container& /* C */ )
      {
        return LessThanPredicate();
      }
      static EqualPredicate equal_to( const Container& /* C */ )
      {
        return EqualPredicate();
      }
      static inline const key_type& key( const value_type& value )
      {
        return value;
      }
    };
 
    template <typename Container>
    struct ComparatorAdapter< Container, true, false, true > 
    {
      typedef typename Container::value_type      value_type;
      typedef typename Container::key_type        key_type;
      typedef KeyComparatorForPairKeyData
        < std::less< key_type >, value_type >     LessThanPredicate;
      typedef KeyComparatorForPairKeyData
        < std::equal_to< key_type >, value_type > EqualPredicate;
 
      static LessThanPredicate less( const Container& /* C */ )
      {
        return LessThanPredicate( std::less< key_type >() );
      }
      static EqualPredicate equal_to( const Container& /* C */ )
      {
        return EqualPredicate( std::equal_to< key_type >() );
      }
      static inline const key_type& key( const value_type& value )
      {
        return value.first;
      }
 
    };
 
 
 
    template <typename Container, bool associative, bool ordered>
    struct SetFunctionsImpl
    {
      static bool isEqual( const Container& S1, const Container& S2 )
      {
        // Checks size first.
        if ( S1.size() != S2.size() ) return false;
        typedef typename Container::value_type value_type;
        typedef std::vector<value_type> Vector;
        typedef ComparatorAdapter< Container, associative, ordered,
                                   IsPairAssociativeContainer< Container >::value >
          CompAdapter;
 
        Vector V1( S1.begin(), S1.end() );
        Vector V2( S2.begin(), S2.end() );
        std::sort( V1.begin(), V1.end(), CompAdapter::less( S1 ) );
        std::sort( V2.begin(), V2.end(), CompAdapter::less( S1 ) );
        return std::equal( V1.begin(), V1.end(), V2.begin(),
                           CompAdapter::equal_to( S1 ) );
      }
 
      static bool isSubset( const Container& S1, const Container& S2 )
      {
        // Checks size first.
        if ( S1.size() > S2.size() ) return false;
        typedef typename Container::value_type value_type;
        typedef std::vector<value_type> Vector;
        typedef ComparatorAdapter< Container, associative, ordered,
                                   IsPairAssociativeContainer< Container >::value >
          CompAdapter;
 
        Vector V1( S1.begin(), S1.end() );
        Vector V2( S2.begin(), S2.end() );
        std::sort( V1.begin(), V1.end(), CompAdapter::less( S1 ) );
        std::sort( V2.begin(), V2.end(), CompAdapter::less( S1 ) );
        return std::includes( V2.begin(), V2.end(), V1.begin(), V1.end(),
                              CompAdapter::less( S1 ) );
      }
 
      static Container& assignDifference( Container& S1, const Container& S2 )
      {
        typedef typename Container::value_type value_type;
        typedef std::vector<value_type> Vector;
        typedef ComparatorAdapter< Container, associative, ordered,
                                   IsPairAssociativeContainer< Container >::value >
          CompAdapter;
 
        Vector V1( S1.begin(), S1.end() );
        Vector V2( S2.begin(), S2.end() );
        std::sort( V1.begin(), V1.end(), CompAdapter::less( S1 ) );
        std::sort( V2.begin(), V2.end(), CompAdapter::less( S1 ) );
        S1.clear();
        std::set_difference( V1.begin(), V1.end(), V2.begin(), V2.end(),
                             std::inserter( S1, S1.end() ), CompAdapter::less( S1 ) );
        return S1;
      }
 
      static Container& assignUnion( Container& S1, const Container& S2 )
      {
        typedef typename Container::value_type value_type;
        typedef std::vector<value_type> Vector;
        typedef ComparatorAdapter< Container, associative, ordered,
                                   IsPairAssociativeContainer< Container >::value >
          CompAdapter;
 
        Vector V1( S1.begin(), S1.end() );
        Vector V2( S2.begin(), S2.end() );
        std::sort( V1.begin(), V1.end(), CompAdapter::less( S1 ) );
        std::sort( V2.begin(), V2.end(), CompAdapter::less( S1 ) );
        S1.clear();
        std::set_union( V1.begin(), V1.end(), V2.begin(), V2.end(),
                        std::inserter( S1, S1.end() ), CompAdapter::less( S1 ) );
        return S1;
      }
 
      static Container& assignIntersection( Container& S1, const Container& S2 )
      {
        typedef typename Container::value_type value_type;
        typedef std::vector<value_type> Vector;
        typedef ComparatorAdapter< Container, associative, ordered,
                                   IsPairAssociativeContainer< Container >::value >
          CompAdapter;
 
        Vector V1( S1.begin(), S1.end() );
        Vector V2( S2.begin(), S2.end() );
        std::sort( V1.begin(), V1.end(), CompAdapter::less( S1 )  );
        std::sort( V2.begin(), V2.end(), CompAdapter::less( S1 )  );
        S1.clear();
        std::set_intersection( V1.begin(), V1.end(), V2.begin(), V2.end(),
                               std::inserter( S1, S1.end() ), 
                               CompAdapter::less( S1 )  );
        return S1;
      }
 
      static Container& assignSymmetricDifference( Container& S1, const Container& S2 )
      {
        typedef typename Container::value_type value_type;
        typedef std::vector<value_type> Vector;
        typedef ComparatorAdapter< Container, associative, ordered,
                                   IsPairAssociativeContainer< Container >::value >
          CompAdapter;
 
        Vector V1( S1.begin(), S1.end() );
        Vector V2( S2.begin(), S2.end() );
        std::sort( V1.begin(), V1.end(), CompAdapter::less( S1 )  );
        std::sort( V2.begin(), V2.end(), CompAdapter::less( S1 )  );
        S1.clear();
        std::set_symmetric_difference( V1.begin(), V1.end(), V2.begin(), V2.end(),
                                       std::inserter( S1, S1.end() ), 
                                       CompAdapter::less( S1 )  );
        return S1;
      }
 
 
    };
    
    template <typename Container>
    struct SetFunctionsImpl<Container, true, false>
    {
 
      static bool isEqual( const Container& S1, const Container& S2 )
      {
        typedef ComparatorAdapter< Container, true, false,
                                   IsPairAssociativeContainer< Container >::value >
          CompAdapter;
 
        // Checks size first.
        if ( S1.size() != S2.size() ) return false;
        // Note that it is critical here that all elements are distinct.
        for ( typename Container::const_iterator it = S1.begin(), 
                itE = S1.end(); it != itE; ++it )
          if ( S2.find( CompAdapter::key( *it ) ) == S2.end() ) return false;
        return true;
      }
 
      static bool isSubset( const Container& S1, const Container& S2 )
      {
        typedef ComparatorAdapter< Container, true, false,
                                   IsPairAssociativeContainer< Container >::value >
          CompAdapter;
 
        // Checks size first.
        if ( S1.size() > S2.size() ) return false;
        for ( typename Container::const_iterator it = S1.begin(), 
                itE = S1.end(); it != itE; ++it )
          if ( S2.find( CompAdapter::key( *it ) ) == S2.end() ) return false;
        return true;
      }
 
      static Container& assignDifference( Container& S1, const Container& S2 )
      {
        typedef ComparatorAdapter< Container, true, false,
                                   IsPairAssociativeContainer< Container >::value >
          CompAdapter;
 
        for ( typename Container::const_iterator it = S2.begin(), 
                itE = S2.end(); it != itE; ++it )
          S1.erase( CompAdapter::key( *it ) );
        return S1;
      }
 
      static Container& assignUnion( Container& S1, const Container& S2 )
      {
        typename Container::iterator itS1 = S1.end();
        for ( typename Container::const_iterator it = S2.begin(), 
                itE = S2.end(); it != itE; ++it )
          itS1 = S1.insert( itS1, *it );
        return S1;
      }
 
      static Container& assignIntersection( Container& S1, const Container& S2 )
      {
        typedef ComparatorAdapter< Container, true, false,
                                   IsPairAssociativeContainer< Container >::value >
          CompAdapter;
 
        for ( typename Container::iterator it = S1.begin(), 
                itE = S1.end(); it != itE; )
          {
            typename Container::iterator itNext = it; ++itNext;
            if ( S2.find( CompAdapter::key( *it ) ) == S2.end() )
              S1.erase( CompAdapter::key( *it ) );
            it = itNext;
          }
        return S1;
      }
 
      static Container& assignSymmetricDifference( Container& S1, const Container& S2 )
      {
        Container S12( S1 );
        assignIntersection( S12, S2 );
        assignUnion( S1, S2 );
        return assignDifference( S1, S12 );
      }
 
    };
 
    template <typename Container>
    struct SetFunctionsImpl<Container, true, true >
    {
 
      static bool isEqual( const Container& S1, const Container& S2 )
      {
        // Checks size first.
        if ( S1.size() != S2.size() ) return false;
        // One has to be careful for comparing keys in set-like
        // structure, we only have an operator<. Hence a == b is defined as 
        // ( ! a<b ) && ( ! b<a ).
        typedef ComparatorAdapter< Container, true, true,
                                   IsPairAssociativeContainer< Container >::value >
          CompAdapter;
 
        return std::equal( S1.begin(), S1.end(), S2.begin(), 
                           CompAdapter::equal_to( S1 ) );
      }
 
      static bool isSubset( const Container& S1, const Container& S2 )
      {
        // Checks size first.
        if ( S1.size() > S2.size() ) return false;
        typedef ComparatorAdapter< Container, true, true,
                                   IsPairAssociativeContainer< Container >::value >
          CompAdapter;
 
        return std::includes( S2.begin(), S2.end(), 
                              S1.begin(), S1.end(), CompAdapter::less( S1 ) );
      }
 
 
      static Container& assignDifference( Container& S1, const Container& S2 )
      {
        typedef ComparatorAdapter< Container, true, true,
                                   IsPairAssociativeContainer< Container >::value >
          CompAdapter;
 
        Container S;
        std::swap( S, S1 );
        std::set_difference( S.begin(), S.end(), S2.begin(), S2.end(), 
                             std::inserter( S1, S1.end() ),
                             CompAdapter::less( S1 ) );
        return S1;
      }
 
      static Container& assignUnion( Container& S1, const Container& S2 )
      {
        typedef ComparatorAdapter< Container, true, true,
                                   IsPairAssociativeContainer< Container >::value >
          CompAdapter;
 
        Container S;
        std::swap( S, S1 );
        std::set_union( S.begin(), S.end(), S2.begin(), S2.end(), 
                        std::inserter( S1, S1.end() ),
                        CompAdapter::less( S1 ) );
        return S1;
      }
 
      static Container& assignIntersection( Container& S1, const Container& S2 )
      {
        typedef ComparatorAdapter< Container, true, true,
                                   IsPairAssociativeContainer< Container >::value >
          CompAdapter;
 
        Container S;
        std::swap( S, S1 );
        std::set_intersection( S.begin(), S.end(), S2.begin(), S2.end(), 
                               std::inserter( S1, S1.end() ), 
                               CompAdapter::less( S1 ) );
        return S1;
      }
 
      static Container& assignSymmetricDifference( Container& S1, const Container& S2 )
      {
        typedef ComparatorAdapter< Container, true, true,
                                   IsPairAssociativeContainer< Container >::value >
          CompAdapter;
 
        Container S;
        std::swap( S, S1 );
        std::set_symmetric_difference( S.begin(), S.end(), S2.begin(), S2.end(), 
                                       std::inserter( S1, S1.end() ),
                                       CompAdapter::less( S1 ) );
        return S1;
      }
    };
 
    template <typename Container >
    struct SetFunctionsImpl< Container, false, true >
    {
      static bool isEqual( const Container& S1, const Container& S2 )
      {
        typedef ComparatorAdapter< Container, false, true, false >
          CompAdapter;
 
        // Checks size first.
        if ( S1.size() != S2.size() ) return false;
        return std::equal( S1.begin(), S1.end(), S2.begin(), 
                           CompAdapter::equal_to( S1 ) ); 
      }
 
      static bool isSubset( const Container& S1, const Container& S2 )
      {
        typedef ComparatorAdapter< Container, false, true, false >
          CompAdapter;
 
        // Checks size first.
        if ( S1.size() > S2.size() ) return false;
        return std::includes( S2.begin(), S2.end(), S1.begin(), S1.end(), 
                              CompAdapter::less( S1 ) ); 
      }
 
      static Container& assignDifference( Container& S1, const Container& S2 )
      {
        typedef ComparatorAdapter< Container, false, true, false >
          CompAdapter;
 
        Container S;
        std::swap( S, S1 );
        std::set_difference( S.begin(), S.end(), S2.begin(), S2.end(), 
                             std::inserter( S1, S1.end() ), 
                             CompAdapter::less( S1 ) );
        return S1;
      }
 
      static Container& assignUnion( Container& S1, const Container& S2 )
      {
        typedef ComparatorAdapter< Container, false, true, false >
          CompAdapter;
 
        Container S;
        std::swap( S, S1 );
        std::set_union( S.begin(), S.end(), S2.begin(), S2.end(), 
                        std::inserter( S1, S1.end() ), 
                        CompAdapter::less( S1 ) );
        return S1;
      }
 
      static Container& assignIntersection( Container& S1, const Container& S2 )
      {
        typedef ComparatorAdapter< Container, false, true, false >
          CompAdapter;
 
        Container S;
        std::swap( S, S1 );
        std::set_intersection( S.begin(), S.end(), S2.begin(), S2.end(), 
                               std::inserter( S1, S1.end() ), 
                               CompAdapter::less( S1 ) );
        return S1;
      }
 
      static Container& assignSymmetricDifference( Container& S1, const Container& S2 )
      {
        typedef ComparatorAdapter< Container, false, true, false >
          CompAdapter;
 
        Container S;
        std::swap( S, S1 );
        std::set_symmetric_difference( S.begin(), S.end(), S2.begin(), S2.end(), 
                                       std::inserter( S1, S1.end() ), 
                                       CompAdapter::less( S1 ) );
        return S1;
      }
 
    };
    
  } // detail
  
  // template class SetFunctions
 
  namespace functions {
 
 
    template <typename Container, bool ordered>
    bool isEqual( const Container& S1, const Container& S2 )
      {
        BOOST_STATIC_ASSERT( IsContainer< Container >::value );
        BOOST_STATIC_CONSTANT
          ( bool, isAssociative = IsAssociativeContainer< Container >::value );
        BOOST_STATIC_CONSTANT
          ( bool, isOrdered = ordered 
            || ( isAssociative && IsOrderedAssociativeContainer< Container >::value ) );
        
        return DGtal::detail::SetFunctionsImpl< Container, isAssociative, isOrdered >
          ::isEqual( S1, S2 );
      }
 
    template <typename Container>
    bool isEqual( const Container& S1, const Container& S2 )
      {
        BOOST_STATIC_ASSERT( IsContainer< Container >::value );
        BOOST_STATIC_CONSTANT
          ( bool, isAssociative = IsAssociativeContainer< Container >::value );
        BOOST_STATIC_CONSTANT
          ( bool, isOrdered = isAssociative && IsOrderedAssociativeContainer< Container >::value );
        
        return DGtal::detail::SetFunctionsImpl< Container, isAssociative, isOrdered >
          ::isEqual( S1, S2 );
      }
 
 
 
    template <typename Container, bool ordered>
    bool isSubset( const Container& S1, const Container& S2 )
      {
        BOOST_STATIC_ASSERT( IsContainer< Container >::value );
        BOOST_STATIC_CONSTANT
          ( bool, isAssociative = IsAssociativeContainer< Container >::value );
        BOOST_STATIC_CONSTANT
          ( bool, isOrdered = ordered 
            || ( isAssociative && IsOrderedAssociativeContainer< Container >::value ) );
        
        return DGtal::detail::SetFunctionsImpl< Container, isAssociative, isOrdered >
          ::isSubset( S1, S2 );
      }
 
    template <typename Container>
    bool isSubset( const Container& S1, const Container& S2 )
      {
        BOOST_STATIC_ASSERT( IsContainer< Container >::value );
        BOOST_STATIC_CONSTANT
          ( bool, isAssociative = IsAssociativeContainer< Container >::value );
        BOOST_STATIC_CONSTANT
          ( bool, isOrdered = isAssociative && IsOrderedAssociativeContainer< Container >::value );
        
        return DGtal::detail::SetFunctionsImpl< Container, isAssociative, isOrdered >
          ::isSubset( S1, S2 );
      }
 
 
    template <typename Container, bool ordered>
    Container& assignDifference( Container& S1, const Container& S2 )
    {
      BOOST_STATIC_ASSERT( IsContainer< Container >::value );
      BOOST_STATIC_CONSTANT
        ( bool, isAssociative = IsAssociativeContainer< Container >::value );
      BOOST_STATIC_CONSTANT
        ( bool, isOrdered = ordered 
          || ( isAssociative && IsOrderedAssociativeContainer< Container >::value ) );
 
      return DGtal::detail::SetFunctionsImpl< Container, isAssociative, isOrdered >
        ::assignDifference( S1, S2 );
    }
 
    template <typename Container>
    Container& assignDifference( Container& S1, const Container& S2 )
    {
      BOOST_STATIC_ASSERT( IsContainer< Container >::value );
      BOOST_STATIC_CONSTANT
        ( bool, isAssociative = IsAssociativeContainer< Container >::value );
      BOOST_STATIC_CONSTANT
        ( bool, isOrdered = isAssociative && IsOrderedAssociativeContainer< Container >::value );
 
      return DGtal::detail::SetFunctionsImpl< Container, isAssociative, isOrdered >
        ::assignDifference( S1, S2 );
    }
 
    template <typename Container, bool ordered>
    Container makeDifference( const Container& S1, const Container& S2 )
    {
      BOOST_STATIC_ASSERT( IsContainer< Container >::value );
      Container S( S1 );
      assignDifference<Container, ordered>( S, S2 );
      return S;
    }
 
    template <typename Container>
    Container makeDifference( const Container& S1, const Container& S2 )
    {
      BOOST_STATIC_ASSERT( IsContainer< Container >::value );
      Container S( S1 );
      assignDifference( S, S2 );
      return S;
    }
 
 
 
    template <typename Container, bool ordered>
    Container& assignUnion( Container& S1, const Container& S2 )
    {
      BOOST_STATIC_ASSERT( IsContainer< Container >::value );
      BOOST_STATIC_CONSTANT
        ( bool, isAssociative = IsAssociativeContainer< Container >::value );
      BOOST_STATIC_CONSTANT
        ( bool, isOrdered = ordered 
          || ( isAssociative && IsOrderedAssociativeContainer< Container >::value ) );
 
      return DGtal::detail::SetFunctionsImpl< Container, isAssociative, isOrdered >
        ::assignUnion( S1, S2 );
    }
 
    template <typename Container>
    Container& assignUnion( Container& S1, const Container& S2 )
    {
      BOOST_STATIC_ASSERT( IsContainer< Container >::value );
      BOOST_STATIC_CONSTANT
        ( bool, isAssociative = IsAssociativeContainer< Container >::value );
      BOOST_STATIC_CONSTANT
        ( bool, isOrdered = isAssociative && IsOrderedAssociativeContainer< Container >::value );
 
      return DGtal::detail::SetFunctionsImpl< Container, isAssociative, isOrdered >
        ::assignUnion( S1, S2 );
    }
 
    template <typename Container, bool ordered>
    Container makeUnion( const Container& S1, const Container& S2 )
    {
      BOOST_STATIC_ASSERT( IsContainer< Container >::value );
      Container S( S1 );
      assignUnion<Container, ordered>( S, S2 );
      return S;
    }
 
    template <typename Container>
    Container makeUnion( const Container& S1, const Container& S2 )
    {
      BOOST_STATIC_ASSERT( IsContainer< Container >::value );
      Container S( S1 );
      assignUnion( S, S2 );
      return S;
    }
 
 
 
    template <typename Container, bool ordered>
    Container& assignIntersection( Container& S1, const Container& S2 )
    {
      BOOST_STATIC_ASSERT( IsContainer< Container >::value );
      BOOST_STATIC_CONSTANT
        ( bool, isAssociative = IsAssociativeContainer< Container >::value );
      BOOST_STATIC_CONSTANT
        ( bool, isOrdered = ordered 
          || ( isAssociative && IsOrderedAssociativeContainer< Container >::value ) );
 
      return DGtal::detail::SetFunctionsImpl< Container, isAssociative, isOrdered >
        ::assignIntersection( S1, S2 );
    }
 
    template <typename Container>
    Container& assignIntersection( Container& S1, const Container& S2 )
    {
      BOOST_STATIC_ASSERT( IsContainer< Container >::value );
      BOOST_STATIC_CONSTANT
        ( bool, isAssociative = IsAssociativeContainer< Container >::value );
      BOOST_STATIC_CONSTANT
        ( bool, isOrdered = isAssociative && IsOrderedAssociativeContainer< Container >::value );
 
      return DGtal::detail::SetFunctionsImpl< Container, isAssociative, isOrdered >
        ::assignIntersection( S1, S2 );
    }
 
    template <typename Container, bool ordered>
    Container makeIntersection( const Container& S1, const Container& S2 )
    {
      BOOST_STATIC_ASSERT( IsContainer< Container >::value );
      Container S( S1 );
      assignIntersection<Container, ordered>( S, S2 );
      return S;
    }
 
    template <typename Container>
    Container makeIntersection( const Container& S1, const Container& S2 )
    {
      BOOST_STATIC_ASSERT( IsContainer< Container >::value );
      Container S( S1 );
      assignIntersection( S, S2 );
      return S;
    }
 
 
 
    template <typename Container, bool ordered>
    Container& assignSymmetricDifference( Container& S1, const Container& S2 )
    {
      BOOST_STATIC_ASSERT( IsContainer< Container >::value );
      BOOST_STATIC_CONSTANT
        ( bool, isAssociative = IsAssociativeContainer< Container >::value );
      BOOST_STATIC_CONSTANT
        ( bool, isOrdered = ordered 
          || ( isAssociative && IsOrderedAssociativeContainer< Container >::value ) );
 
      return DGtal::detail::SetFunctionsImpl< Container, isAssociative, isOrdered >
        ::assignSymmetricDifference( S1, S2 );
    }
 
    template <typename Container>
    Container& assignSymmetricDifference( Container& S1, const Container& S2 )
    {
      BOOST_STATIC_ASSERT( IsContainer< Container >::value );
      BOOST_STATIC_CONSTANT
        ( bool, isAssociative = IsAssociativeContainer< Container >::value );
      BOOST_STATIC_CONSTANT
        ( bool, isOrdered = isAssociative && IsOrderedAssociativeContainer< Container >::value );
 
      return DGtal::detail::SetFunctionsImpl< Container, isAssociative, isOrdered >
        ::assignSymmetricDifference( S1, S2 );
    }
 
    template <typename Container, bool ordered>
    Container makeSymmetricDifference( const Container& S1, const Container& S2 )
    {
      BOOST_STATIC_ASSERT( IsContainer< Container >::value );
      Container S( S1 );
      assignSymmetricDifference<Container, ordered>( S, S2 );
      return S;
    }
 
    template <typename Container>
    Container makeSymmetricDifference( const Container& S1, const Container& S2 )
    {
      BOOST_STATIC_ASSERT( IsContainer< Container >::value );
      Container S( S1 );
      assignSymmetricDifference( S, S2 );
      return S;
    }
 
 
 
    // OVERLOADING SET OPERATIONS
 
    namespace setops {
      
      template <typename Container>
      inline Container& operator-=( Container& S1, const Container& S2 )
      {
        return assignDifference( S1, S2 );
      }
      
      template <typename Container>
      inline Container operator-( const Container& S1, const Container& S2 )
      {
        return makeDifference( S1, S2 );
      }
 
      template <typename Container>
      inline Container operator|( const Container& S1, const Container& S2 )
      {
        return makeUnion( S1, S2 );
      }
 
      template <typename Container>
      inline Container& operator|=( Container& S1, const Container& S2 )
      {
        return assignUnion( S1, S2 );
      }
 
      template <typename Container>
      inline Container operator&( const Container& S1, const Container& S2 )
      {
        return makeIntersection( S1, S2 );
      }
 
      template <typename Container>
      inline Container& operator&=( Container& S1, const Container& S2 )
      {
        return assignIntersection( S1, S2 );
      }
 
      template <typename Container>
      inline Container operator^( const Container& S1, const Container& S2 )
      {
        return makeSymmetricDifference( S1, S2 );
      }
 
      template <typename Container>
      inline Container& operator^=( Container& S1, const Container& S2 )
      {
        return assignSymmetricDifference( S1, S2 );
      }
 
    }
  }
 
 
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/base/SetFunctions.ih"
 
//                                                                           //
 
#endif // !defined SetFunctions_h
 
#undef SetFunctions_RECURSES
#endif // else defined(SetFunctions_RECURSES)