globalintersectioniterator.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright © DUNE-FUFEM Project contributors, see file AUTHORS.md
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception OR LGPL-3.0-or-later
 
#ifndef GLOBAL_INTERSECTION_ITERATOR_HH
#define GLOBAL_INTERSECTION_ITERATOR_HH
 
#warning This header is deprecated and will be removed after 2.11. Use domains/intersectionsetiterator.hh instead.
 
#include <dune/common/iteratorfacades.hh>
#include <dune/common/version.hh>
 
#include <dune/geometry/referenceelements.hh>
 
template <class IntersectionIterator, bool returnsReference>
struct
[[deprecated("This class is deprecated and will be removed after 2.11.")]]
ReturnReferenceHelper {
 
    typedef typename IntersectionIterator::Intersection Intersection;
 
    static const Intersection& returnReference(IntersectionIterator* nIt,
                                        const Intersection& intersection)
    {
        return intersection;
    }
};
 
template <class IntersectionIterator>
struct ReturnReferenceHelper<IntersectionIterator,true> {
 
    typedef typename IntersectionIterator::Intersection Intersection;
 
    static const Intersection& returnReference(IntersectionIterator* nIt,
                                        const Intersection& intersection)
    {
        return **nIt;
    }
};
 
template <class IntersectionIterator, bool returnsReference>
static const typename IntersectionIterator::Intersection&
[[deprecated("This function is deprecated and will be removed after 2.11.")]]
returnReference(IntersectionIterator* nIt,
                            const typename IntersectionIterator::Intersection& intersection)
{
    return ReturnReferenceHelper<IntersectionIterator,returnsReference>::returnReference(nIt,intersection);
}
 
 
template <class GridView, class Impl>
class
[[deprecated("This class is deprecated and will be removed after 2.11. Use Dune::Fufem::IntersectionSetIterator instead.")]]
GlobalIntersectionIterator
    : public Dune::ForwardIteratorFacade<GlobalIntersectionIterator<GridView, Impl>, const typename GridView::Intersection>
{
    enum {dim=GridView::dimension};
 
    typedef typename GridView::IntersectionIterator IntersectionIterator;
    typedef typename GridView::template Codim<0>::Iterator ElementIterator;
 
public:
    typedef typename IntersectionIterator::Intersection Intersection;
 
private:
    // If this value is true, then the implementation still returns the Intersection by const reference
    // thus in this case we don't need to store the intersections at all
    static const bool isReference = std::is_lvalue_reference<decltype(std::declval<IntersectionIterator>().operator*())>::value;
 
public:
 
    enum PositionFlag {begin, end};
 
 
    GlobalIntersectionIterator(const GridView& gridView, PositionFlag flag) :
        gridView_(gridView),
        eIt_(gridView.template end<0>()),
        endEIt_(gridView.template end<0>()),
        nIt_(0)
    {
        if (flag==begin)
        {
            eIt_ = gridView.template begin<0>();
            nIt_ = new IntersectionIterator(gridView.ibegin(*eIt_));
        }
    }
 
    GlobalIntersectionIterator(const GridView& gridView, const ElementIterator& eIt, const ElementIterator& endEIt) :
        gridView_(gridView),
        eIt_(eIt),
        endEIt_(endEIt),
        nIt_(0)
    {
        if (eIt_!=endEIt_)
            nIt_ = new IntersectionIterator(gridView.ibegin(*eIt_));
    }
 
    GlobalIntersectionIterator(const GlobalIntersectionIterator& other) :
        gridView_(other.gridView_),
        eIt_(other.eIt_),
        endEIt_(other.endEIt_),
        nIt_(0)
    {
        if (other.nIt_)
            nIt_ = new IntersectionIterator(*other.nIt_);
 
        updateIntersection(other.intersection_);
    }
 
    ~GlobalIntersectionIterator() {
        delete(nIt_);
    }
 
    void increment()
    {
        // Increment until a face in the patch is found
        do {
            ++(*nIt_);
 
            // if end intersection reached find next intersection
            if ((*nIt_) == gridView_.iend(*eIt_))
            {
                do {
                    ++eIt_;
                } while (eIt_ != endEIt_ and asImpl().skipElement(*eIt_));
                if (eIt_ != endEIt_)
                    (*nIt_) = gridView_.ibegin(*eIt_);
            }
 
            // if we reached the end then stop
            if (eIt_ == endEIt_)
                break;
 
            // check if we skip the intersection
            const Intersection& intersection = **nIt_;
            if (not asImpl().skipIntersection(intersection)) {
                updateIntersection(intersection);
                break;
            }
 
        } while (true);
    }
 
    bool equals(const GlobalIntersectionIterator& other) const
    {
        return (eIt_ == other.eIt_) and ((eIt_ == endEIt_) or ((*nIt_) == (*other.nIt_)));
    }
 
    const Intersection& dereference() const
    {
        return returnReference<IntersectionIterator,isReference>(nIt_,intersection_);
    }
 
    const GlobalIntersectionIterator& operator=(const GlobalIntersectionIterator& other)
    {
        eIt_ = other.eIt_;
        endEIt_ = other.endEIt_;
 
        if (nIt_)
            delete nIt_;
 
        if (other.nIt_)
            nIt_ = new IntersectionIterator(*other.nIt_);
        else
            nIt_ = 0;
 
        updateIntersection(other.intersection_);
 
        return *this;
    }
 
    bool containsInsideSubentity(int subEntity, int codim) const
    {
        auto re = Dune::referenceElement<double, dim>(eIt_->type());
        return re.subEntities((*nIt_)->indexInInside(), 1,codim).contains(subEntity);
    }
 
protected:
 
    void updateIntersection(const Intersection& intersection)
    {
        if (not isReference)
            intersection_ = std::move(intersection);
    }
 
    void initialIncrement()
    {
        if (eIt_ == endEIt_)
            return;
 
        const Intersection& intersection = **nIt_;
        if (asImpl().skipIntersection(intersection))
            increment();
        else
            updateIntersection(intersection);
    }
 
    const Impl& asImpl() const
    {
        return static_cast<const Impl&>(*this);
    }
 
    Impl& asImpl()
    {
        return static_cast<Impl&>(*this);
    }
 
    GridView gridView_;
 
    ElementIterator eIt_;
    ElementIterator endEIt_;
 
    IntersectionIterator* nIt_;
 
    Intersection intersection_;
};
 
 
 
#endif