localdofstorage.hh

#ifndef DUNE_FEM_HPDG_SPACE_DISCONTINUOUSGALERKIN_LOCALDOFSTORAGE_HH
#define DUNE_FEM_HPDG_SPACE_DISCONTINUOUSGALERKIN_LOCALDOFSTORAGE_HH
 
#include <cassert>
#include <cstddef>
 
#include <algorithm>
#include <ostream>
#include <vector>
 
namespace Dune
{
 
  namespace Fem
  {
 
    namespace hpDG
    {
 
      // LocalDofStorage
      // ---------------
 
      template< class GlobalKey >
      class LocalDofStorage
      {
        using ThisType = LocalDofStorage< GlobalKey >;
 
        using container = std::vector< GlobalKey >;
 
      public:
        using value_type = GlobalKey;
 
        using iterator = typename container::iterator;
        using const_iterator = typename container::const_iterator;
 
        LocalDofStorage () : size_( 0 ), new_size_( 0 ) {}
 
        LocalDofStorage ( const ThisType & ) = default;
 
        LocalDofStorage ( ThisType && ) = default;
 
        ThisType &operator= ( const ThisType & ) = default;
 
        ThisType &operator= ( ThisType && ) = default;
 
        iterator begin () { return dofs_.begin(); }
 
        const_iterator begin () const { return dofs_.cbegin(); }
 
        iterator end () { return begin() + size(); }
 
        const_iterator end () const { return begin() + size(); }
 
        std::size_t size () const { return size_; }
 
        template< class Function >
        Function reserve ( std::size_t new_size, Function function )
        {
          // remember new size
          new_size_ = new_size;
 
          // enlarge dof vector if needed
          const std::size_t old_size = dofs_.size();
          if( old_size < new_size_ )
          {
            dofs_.resize( new_size );
            for( std::size_t i = old_size; i < new_size; ++i )
              dofs_[ i ] = function();
          }
 
          return std::move( function );
        }
 
        template< class Function >
        Function resize ( Function function )
        {
          assert( new_size_ <= dofs_.size() );
          size_ = new_size_;
 
          const std::size_t holes = dofs_.size() - size_;
          std::for_each( dofs_.rbegin(), dofs_.rbegin() + holes, function );
 
          dofs_.resize( size_ );
          // dofs_.shrink_to_fit();
 
          return std::move( function );
        }
 
        GlobalKey &operator[] ( std::size_t n ) { return dofs_[ n ]; }
 
        const GlobalKey &operator[] ( std::size_t n ) const { return dofs_[ n ]; }
 
#ifndef DOXYGEN
 
        friend std::ostream &operator<< ( std::ostream &ostream, const LocalDofStorage &storage )
        {
          const auto &dofs = storage.dofs_;
          const std::size_t size = dofs.size();
          for( std::size_t i = 0; i < size; ++i )
            ostream << dofs[ i ] << " ";
          ostream << "[" << storage.size_  << "; " << storage.new_size_ << "]";
          return ostream;
        }
 
#endif // #ifndef DOXYGEN
 
      private:
        std::size_t size_, new_size_;
        std::vector< GlobalKey > dofs_;
      };
 
    } // namespace hpDG
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_HPDG_SPACE_DISCONTINUOUSGALERKIN_LOCALDOFSTORAGE_HH