pointiterator.hh

// SPDX-FileCopyrightText: Copyright (C) DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
 
#ifndef DUNE_GRID_IO_FILE_VTK_POINTITERATOR_HH
#define DUNE_GRID_IO_FILE_VTK_POINTITERATOR_HH
 
#include <iterator>
#include <vector>
 
#include <dune/common/iteratorfacades.hh>
#include <dune/common/typetraits.hh>
 
#include <dune/grid/io/file/vtk/corner.hh>
#include <dune/grid/io/file/vtk/corneriterator.hh>
 
namespace Dune
{
 
  namespace VTK {
 
 
    template<typename CellIterator, typename IS>
    class PointIterator
      : public ForwardIteratorFacade
        < PointIterator<CellIterator, IS>,
            const Corner<typename std::remove_const<typename std::iterator_traits<
                        CellIterator>::value_type>::type>,
            const Corner<typename std::remove_const<typename std::iterator_traits<
                        CellIterator>::value_type>::type>&,
            typename std::iterator_traits<CellIterator>::difference_type>
    {
    public:
      typedef VTK::Corner<typename std::remove_const<typename std::iterator_traits<
                  CellIterator>::value_type>::type> Corner;
 
      // reiterate the facades typedefs here
      typedef PointIterator<CellIterator, IS> DerivedType;
      typedef const Corner Value;
      typedef Value& Reference;
      typedef typename std::iterator_traits<CellIterator>::difference_type
      DifferenceType;
 
      static const unsigned mydim = std::iterator_traits<CellIterator>::
                                    value_type::mydimension;
 
    private:
      typedef ForwardIteratorFacade<DerivedType, Value, Reference,
          DifferenceType> Facade;
 
      CornerIterator<CellIterator> cornerit;
      const IS* is;
      std::vector<bool> seen;
 
    public:
      Reference dereference() const {
        return *cornerit;
      }
 
      bool isDereferencable() const {
        return cornerit.isDereferencable();
      }
 
      bool equals(const DerivedType& other) const {
        return cornerit == other.cornerit;
      }
 
      void increment() {
        for(++cornerit; isDereferencable(); ++cornerit) {
          typename IS::IndexType index =
            is->subIndex(cornerit->cell(), cornerit->duneIndex(), mydim);
 
          if(!seen[index]) {
            seen[index] = true;
            break;
          }
        }
      }
 
 
      PointIterator(const CellIterator& cellit, const CellIterator& cellend,
                    const IS& is_)
        : cornerit(cellit, cellend), is(&is_), seen(is->size(mydim), false)
      { }
 
      PointIterator(const CellIterator& cellend_)
        : cornerit(cellend_), is(0)
      { }
    };
 
  } // namespace VTK
 
 
} // namespace Dune
 
#endif // DUNE_GRID_IO_FILE_VTK_POINTITERATOR_HH