dofiterator.hh

#ifndef DUNE_FEM_DOFITERATOR_HH
#define DUNE_FEM_DOFITERATOR_HH
 
#include <dune/fem/misc/bartonnackmaninterface.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    template< class DofImp, class DofIteratorImp >
    class DofIteratorInterface
    : public BartonNackmanInterface< DofIteratorInterface< DofImp, DofIteratorImp >,
                                     DofIteratorImp >
    {
    public:
      typedef DofImp DofType;
 
      typedef DofIteratorImp DofIteratorType;
 
    private:
      typedef DofIteratorInterface< DofType, DofIteratorType > ThisType;
      typedef BartonNackmanInterface< ThisType, DofIteratorType > BaseType;
 
    protected:
      using BaseType :: asImp;
 
    public:
      DofIteratorType &operator= ( const DofIteratorType &other )
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().operator=( other ) );
        return asImp();
      }
 
      DofType &operator* ()
      {
        CHECK_INTERFACE_IMPLEMENTATION( *asImp() );
        return *asImp();
      }
 
      const DofType &operator* () const
      {
        CHECK_INTERFACE_IMPLEMENTATION( *asImp() );
        return *asImp();
      }
 
      const DofImp &operator[] ( const int n ) const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp()[ n ] );
        return asImp()[ n ];
      }
 
      DofImp &operator[] ( const int n )
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp()[ n ] );
        return asImp()[ n ];
      }
 
      DofIteratorType &operator++ ()
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATON( asImp().operator++() );
        return asImp();
      }
 
      bool operator== ( const DofIteratorType &other ) const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().operator==( other ) );
        return asImp().operator==( other );
      }
 
      bool operator!= ( const DofIteratorType &other ) const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().operator!=( other ) );
        return asImp().operator!=( other );
      }
 
      int index () const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().index() );
        return asImp().index();
      }
 
      void reset ()
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().reset() );
      }
    }; // end DofIteratorInterface
 
 
 
    template< class DofImp, class DofIteratorImp >
    class DofIteratorDefault
    : public DofIteratorInterface< DofImp, DofIteratorImp >
    {
    public:
      typedef DofImp DofType;
 
      typedef DofIteratorImp DofIteratorType;
 
    private:
      typedef DofIteratorDefault< DofType, DofIteratorType > ThisType;
      typedef DofIteratorInterface< DofType, DofIteratorType > BaseType;
 
    protected:
      using BaseType :: asImp;
 
    public:
      const DofImp &operator[] ( const int n ) const
      {
        DofIteratorType &it = const_cast< DofIteratorType & >( asImp() );
        it.reset();
        for( int i = 0; i < n; ++i )
          ++it;
        return *asImp();
      }
 
      DofType &operator[] ( const int n )
      {
        asImp().reset();
        for( int i = 0; i < n; ++i )
          ++asImp();
        return *asImp();
      }
 
      /* \copydoc Dune::Fem::DofIteratorInterface::operator!=
       *
       *  \note The default implementation is just
       *  \code
       *  return !operator==( other );
       *  \endcode
       */
      bool operator!= ( const DofIteratorType &other ) const
      {
        return !asImp().operator==( other );
      }
 
      int index () const
      {
        DofIteratorType it( asImp() );
        it.reset();
 
        int idx = 0;
        for( ; it != *this; ++it )
          ++idx;
 
        return idx;
      }
    }; // end class DofIteratorDefault
 
 
 
    /* \class ConstDofIteratorDefault
     * \brief makes a const DoF iterator out of DoF iterator
     */
    template< class DofIteratorImp >
    class ConstDofIteratorDefault
    : public DofIteratorDefault< typename DofIteratorImp :: DofType,
                                 DofIteratorImp >
    {
    public:
      typedef DofIteratorImp WrappedDofIteratorType;
 
      typedef typename WrappedDofIteratorType :: DofType DofType;
 
      typedef ConstDofIteratorDefault< WrappedDofIteratorType > ThisType;
      typedef DofIteratorDefault< DofType, ThisType > BaseType;
 
    protected:
      WrappedDofIteratorType it_;
 
    public:
      ConstDofIteratorDefault( const WrappedDofIteratorType &it )
      : it_( it )
      {
      }
 
      ConstDofIteratorDefault( const ThisType &other )
      : it_( other.it_ )
      {
      }
 
      const ThisType &operator= ( const ThisType &other )
      {
        it_ = other.it_;
        return *this;
      }
 
      const DofType& operator* () const
      {
        return (*it_);
      }
 
      const DofType &operator[] ( const int n ) const
      {
        return it_[ n ];
      }
 
      int index () const
      {
        return it_.index();
      }
 
      ThisType &operator++ ()
      {
        ++it_;
        return (*this);
      }
 
      bool operator== ( const ThisType &other ) const
      {
        return (it_ == other.it_);
      }
 
      bool operator!= ( const ThisType &other ) const
      {
        return (it_ != other.it_);
      }
 
      void reset ()
      {
        it_.reset();
      }
 
      // note: this method is not in the interface!
      const DofType *vector () const
      {
        return it_.vector();
      }
    }; // end class DofIteratorDefault
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_DOFITERATOR_HH