DigitalSetBySTLSet.ih

#include <cstdlib>

// IMPLEMENTATION of inline methods.

// ----------------------- Standard services ------------------------------

template <typename Domain>
inline
DGtal::DigitalSetBySTLSet<Domain>::~DigitalSetBySTLSet()
{
}

template <typename Domain>
inline
DGtal::DigitalSetBySTLSet<Domain>::DigitalSetBySTLSet( const Domain & d )
  : myDomain( d ), mySet()
{
}

template <typename Domain>
inline
DGtal::DigitalSetBySTLSet<Domain>::DigitalSetBySTLSet( const DigitalSetBySTLSet<Domain> & other )
  : myDomain( other.myDomain ), mySet( other.mySet )
{
}

template <typename Domain>
inline
DGtal::DigitalSetBySTLSet<Domain> &
DGtal::DigitalSetBySTLSet<Domain>::operator= ( const DigitalSetBySTLSet<Domain> & other )
{
  ASSERT( ( myDomain.lowerBound() <= other.myDomain.lowerBound() )
    && ( myDomain.upperBound() >= other.myDomain.upperBound() )
    && "This domain should include the domain of the other set in case of assignment." );
  mySet = other.mySet;
  return *this;
}


template <typename Domain>
inline
const Domain & 
DGtal::DigitalSetBySTLSet<Domain>::domain() const
{
  return myDomain;
}



// Interface - public :


template <typename Domain>
inline
typename DGtal::DigitalSetBySTLSet<Domain>::Size
DGtal::DigitalSetBySTLSet<Domain>::size() const
{
  return (unsigned int)mySet.size();
}

template <typename Domain>
inline
bool
DGtal::DigitalSetBySTLSet<Domain>::empty() const
{
  return mySet.empty();
}


template <typename Domain>
inline
void
DGtal::DigitalSetBySTLSet<Domain>::insert( const Point & p )
{
  // ASSERT( myDomain.isInside( p ) );
  mySet.insert( p );
}


template <typename Domain>
template <typename PointInputIterator>
void
DGtal::DigitalSetBySTLSet<Domain>::insert( PointInputIterator first, PointInputIterator last )
{
  mySet.insert( first, last );
}


template <typename Domain>
inline
void
DGtal::DigitalSetBySTLSet<Domain>::insertNew( const Point & p )
{
  // ASSERT( myDomain.isInside( p ) );
  mySet.insert( p );
}

template <typename Domain>
template <typename PointInputIterator>
inline
void
DGtal::DigitalSetBySTLSet<Domain>::insertNew
( PointInputIterator first, PointInputIterator last )
{
  mySet.insert( first, last );
}

template <typename Domain>
typename DGtal::DigitalSetBySTLSet<Domain>::Size
DGtal::DigitalSetBySTLSet<Domain>::erase( const Point & p )
{
  return (unsigned int)mySet.erase( p );
}

template <typename Domain>
inline
void
DGtal::DigitalSetBySTLSet<Domain>::erase( Iterator it )
{
  mySet.erase( it );
}

template <typename Domain>
inline
void
DGtal::DigitalSetBySTLSet<Domain>::clear()
{
  mySet.clear();
}

template <typename Domain>
inline
typename DGtal::DigitalSetBySTLSet<Domain>::ConstIterator
DGtal::DigitalSetBySTLSet<Domain>::find( const Point & p ) const
{
  return mySet.find( p );
}

template <typename Domain>
inline
typename DGtal::DigitalSetBySTLSet<Domain>::Iterator
DGtal::DigitalSetBySTLSet<Domain>::find( const Point & p )
{
  return mySet.find( p );
}

template <typename Domain>
inline
typename DGtal::DigitalSetBySTLSet<Domain>::ConstIterator
DGtal::DigitalSetBySTLSet<Domain>::begin() const
{
  return mySet.begin();
}

template <typename Domain>
inline
typename DGtal::DigitalSetBySTLSet<Domain>::ConstIterator
DGtal::DigitalSetBySTLSet<Domain>::end() const
{
  return mySet.end();
}

template <typename Domain>
inline
typename DGtal::DigitalSetBySTLSet<Domain>::Iterator
DGtal::DigitalSetBySTLSet<Domain>::begin()
{
  return mySet.begin();
}

template <typename Domain>
inline
typename DGtal::DigitalSetBySTLSet<Domain>::Iterator
DGtal::DigitalSetBySTLSet<Domain>::end()
{
  return mySet.end();
}

template <typename Domain>
inline
DGtal::DigitalSetBySTLSet<Domain> & 
DGtal::DigitalSetBySTLSet<Domain>
::operator+=( const DigitalSetBySTLSet<Domain> & aSet )
{
  if ( this != &aSet )
    {
      Iterator it_dst = end();
      for ( ConstIterator it_src = aSet.begin();
      it_src != aSet.end();
      ++it_src )
  {
    // Use hint it_dst to go faster.
    it_dst = mySet.insert( it_dst, *it_src );
  }
    }
  return *this;
}


// ----------------------- Other Set services -----------------------------
    

template <typename Domain>
template <typename TOutputIterator>
inline
void
DGtal::DigitalSetBySTLSet<Domain>::computeComplement(TOutputIterator& ito) const
{
  typename Domain::ConstIterator itPoint = myDomain.begin();
  typename Domain::ConstIterator itEnd = myDomain.end();
  while ( itPoint != itEnd ) {
    if ( find( *itPoint ) == end() ) {
      *ito++ = *itPoint;
    }
    ++itPoint;
  }
}

template <typename Domain>
inline
void
DGtal::DigitalSetBySTLSet<Domain>::assignFromComplement
( const DigitalSetBySTLSet<Domain> & other_set )
{
  clear();
  typename Domain::ConstIterator itPoint = myDomain.begin();
  typename Domain::ConstIterator itEnd = myDomain.end();
  while ( itPoint != itEnd ) {
    if ( other_set.find( *itPoint ) == other_set.end() ) {
      insert( *itPoint );
    }
    ++itPoint;
  }
}

template <typename Domain>
inline
void
DGtal::DigitalSetBySTLSet<Domain>::computeBoundingBox
( Point & lower, Point & upper ) const
{
  lower = myDomain.upperBound();
  upper = myDomain.lowerBound();
  ConstIterator it = begin();
  ConstIterator itEnd = end();
  while ( it != itEnd ) {
    lower = lower.inf( *it );
    upper = upper.sup( *it );
    ++it;
  }
}

// Interface - public :

template <typename Domain>
inline
void
DGtal::DigitalSetBySTLSet<Domain>::selfDisplay ( std::ostream & out ) const
{
  out << "[DigitalSetBySTLSet]" << " size=" << size();
}

template <typename Domain>
inline
bool
DGtal::DigitalSetBySTLSet<Domain>::isValid() const
{
  return true;
}


// --------------- CDrawableWithBoard2D realization -------------------------

template<typename Domain>
inline
std::string
DGtal::DigitalSetBySTLSet<Domain>::className() const
{
  return "DigitalSetBySTLSet";
}

// Implementation of inline function                                         //

template <typename Domain>
inline
std::ostream &
DGtal::operator<< ( std::ostream & out, const DGtal::DigitalSetBySTLSet<Domain> & object )
{
  object.selfDisplay( out );
  return out;
}

//                                                                           //