variant_filter_iterator.h

浏览该文件的文档.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2023 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner

// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

#ifndef LIBMESH_VARIANT_FILTER_ITERATOR_H
#define LIBMESH_VARIANT_FILTER_ITERATOR_H


// C++ includes
#include <algorithm> // for std::swap
#include <cstddef>
#include <iterator>
#include <memory>

#if defined(__GNUC__) && (__GNUC__ < 3)  && !defined(__INTEL_COMPILER)
#include <typeinfo>
#endif

// Local includes
#include "libmesh/libmesh_common.h" // for cast_ptr()

template<class Predicate, class Type, class ReferenceType = Type &, class PointerType = Type *,
                          class ConstType = const Type, class ConstReferenceType = const Type &,
                          class ConstPointerType = const Type *>
class variant_filter_iterator
{
public:
  using iterator_category = std::forward_iterator_tag;
  using value_type = Type;
  using difference_type = std::ptrdiff_t;
  using pointer = PointerType;
  using reference = ReferenceType;

  typedef variant_filter_iterator<Predicate, Type, ReferenceType, PointerType,
                                  ConstType, ConstReferenceType, ConstPointerType> Iterator;



public:
  struct IterBase
  {
    virtual ~IterBase() = default;
    virtual std::unique_ptr<IterBase> clone() const = 0;

    virtual ReferenceType operator*() const = 0;

    virtual IterBase & operator++() = 0;

    virtual bool equal(const std::unique_ptr<IterBase> & other) const = 0;

    typedef typename variant_filter_iterator<Predicate, ConstType, ConstReferenceType, ConstPointerType>::IterBase const_IterBase;

    virtual std::unique_ptr<const_IterBase> const_clone() const = 0;
  };







  struct PredBase
  {
    virtual ~PredBase() = default;
    virtual std::unique_ptr<PredBase> clone() const = 0;
    virtual bool operator()(const std::unique_ptr<IterBase> & in) const = 0;

    typedef typename variant_filter_iterator<Predicate, ConstType, ConstReferenceType, ConstPointerType>::PredBase const_PredBase;

    virtual std::unique_ptr<const_PredBase> const_clone() const = 0;
  };







  template<typename IterType>
  struct Iter : IterBase
  {
    Iter (const IterType & v) :
      iter_data (v)
    {}

    Iter (const Iter & other) :
      iter_data(other.iter_data)
    {}

    virtual ~Iter () = default;

    virtual std::unique_ptr<IterBase> clone() const override
    {
      return std::make_unique<Iter<IterType>>(iter_data);
    }

    virtual std::unique_ptr<typename IterBase::const_IterBase> const_clone() const override
    {
      typedef typename variant_filter_iterator<Predicate, ConstType, ConstReferenceType, ConstPointerType>::template Iter<IterType> const_Iter;
      return std::make_unique<const_Iter>(iter_data);
    }

    virtual ReferenceType operator*() const override
    {
      return * this->iter_ptr();
    }

    virtual Iter & operator++() override
    {
      ++iter_data;
      return *this;
    }

    virtual bool equal(const std::unique_ptr<IterBase> & other) const override
    {
      const Iter<IterType> * p =
        libMesh::cast_ptr<const Iter<IterType> *>(other.get());

      return (iter_data == p->iter_data);
    }

    IterType iter_data;

  private:

    PointerType iter_ptr () const
    {
      return &*iter_data;
    }
  };




  template <typename IterType, typename PredType>
  struct Pred : PredBase
  {
    Pred (const PredType & v) :
      pred_data (v) {}

    virtual ~Pred () = default;

    virtual std::unique_ptr<PredBase> clone() const override
    {
      return std::make_unique<Pred<IterType,PredType>>(pred_data);
    }

    virtual std::unique_ptr<typename PredBase::const_PredBase> const_clone() const override
    {
      typedef typename variant_filter_iterator<Predicate, ConstType, ConstReferenceType, ConstPointerType>::template Pred<IterType, PredType> const_Pred;
      return std::make_unique<const_Pred>(pred_data);
    }

    virtual bool operator() (const std::unique_ptr<IterBase> & in) const override
    {
      libmesh_assert(in);

      // Attempt downcast
      const Iter<IterType> * p =
        libMesh::cast_ptr<const Iter<IterType> *>(in.get());

      // Return result of op() for the user's predicate.
      return pred_data(p->iter_data);
    }

    PredType pred_data;
  };



public:
  std::unique_ptr<IterBase> data;

  std::unique_ptr<IterBase> end;

  std::unique_ptr<PredBase> pred;

  template<typename PredType, typename IterType>
  variant_filter_iterator (const IterType & d,
                           const IterType & e,
                           const PredType & p ):
    data ( std::make_unique<Iter<IterType>>(d) ),
    end  ( std::make_unique<Iter<IterType>>(e) ),
    pred ( std::make_unique<Pred<IterType,PredType>>(p) )
  {
    this->satisfy_predicate();
  }

  variant_filter_iterator () = default;

  variant_filter_iterator (const Iterator & rhs) :
    data (rhs.data ? rhs.data->clone() : nullptr),
    end  (rhs.end  ? rhs.end->clone()  : nullptr),
    pred (rhs.pred ? rhs.pred->clone() : nullptr) {}

  template <class OtherType, class OtherReferenceType, class OtherPointerType,
            class OtherConstType, class OtherConstReferenceType, class OtherConstPointerType>
  variant_filter_iterator (const variant_filter_iterator<Predicate, OtherType, OtherReferenceType, OtherPointerType,
                                                         OtherConstType, OtherConstReferenceType, OtherConstPointerType> & rhs)
    : data (rhs.data ? rhs.data->const_clone() : nullptr),
      end  (rhs.end  ? rhs.end->const_clone()  : nullptr),
      pred (rhs.pred ? rhs.pred->const_clone() : nullptr)
  {
  }

  virtual ~variant_filter_iterator() = default;

  ReferenceType operator*() const
  {
    return **data;
  }

  PointerType operator->() const
  {
    return &**this;
  }

  Iterator & operator++()
  {
    ++*data;
    this->satisfy_predicate();
    return *this;
  }

  const Iterator operator++(int) // const here to prevent iterator++++ type operations
  {
    Iterator oldValue(*this); // standard is to return old value
    ++*data;
    this->satisfy_predicate();
    return oldValue;
  }

  bool equal(const variant_filter_iterator & other) const
  {
    return data->equal(other.data);
  }

  void swap(Iterator & lhs, Iterator & rhs)
  {
    // Swap the data pointers
    std::swap (lhs.data, rhs.data);

    // Swap the end pointers
    std::swap (lhs.end, rhs.end);

    // Also swap the predicate objects.
    std::swap (lhs.pred, rhs.pred);
  }

  Iterator & operator=(const Iterator & rhs)
  {
    Iterator temp(rhs);
    swap(temp, *this);
    return *this;
  }



private:

  void satisfy_predicate()
  {
    while ( !data->equal(end) && !(*pred)(data) )
      ++(*data);
  }
};






// op==
template<class Predicate, class Type, class ReferenceType, class PointerType,
         class OtherConstType, class OtherConstReferenceType, class OtherConstPointerType>
inline
bool operator==(const variant_filter_iterator<Predicate, Type, ReferenceType, PointerType,
                                              OtherConstType, OtherConstReferenceType, OtherConstPointerType> & x,
                const variant_filter_iterator<Predicate, Type, ReferenceType, PointerType,
                                              OtherConstType, OtherConstReferenceType, OtherConstPointerType> & y)
{
  return x.equal(y);
}



// op!=
template<class Predicate, class Type, class ReferenceType, class PointerType,
         class OtherConstType, class OtherConstReferenceType, class OtherConstPointerType>
inline
bool operator!=(const variant_filter_iterator<Predicate, Type, ReferenceType, PointerType,
                                              OtherConstType, OtherConstReferenceType, OtherConstPointerType> & x,
                const variant_filter_iterator<Predicate, Type, ReferenceType, PointerType,
                                              OtherConstType, OtherConstReferenceType, OtherConstPointerType> & y)
{
  return !(x == y);
}



#endif // LIBMESH_VARIANT_FILTER_ITERATOR_H