variant_filter_iterator.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2018 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 <cstdlib>   // for std::abort()
#include <iterator>

#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 variant_filter_iterator :
#if defined(__GNUC__) && (__GNUC__ < 3)  && !defined(__INTEL_COMPILER)
  public std::forward_iterator<std::forward_iterator_tag, Type>
#else
  public std::iterator<std::forward_iterator_tag,  Type>
#endif
{
public:
  typedef variant_filter_iterator<Predicate, Type, ReferenceType, PointerType> Iterator;



public:
  struct IterBase
  {
    virtual ~IterBase() {}
    virtual  IterBase * clone() const = 0;

    virtual ReferenceType operator*() const = 0;

    virtual IterBase & operator++() = 0;

    virtual bool equal(const IterBase * other) const = 0;

    // typedef typename variant_filter_iterator<Predicate, Type, const Type &, const Type *>::IterBase const_IterBase;
    typedef typename variant_filter_iterator<Predicate, Type const, Type const & , Type const *>::IterBase const_IterBase;

    virtual const_IterBase * const_clone() const = 0;
  };







  struct PredBase
  {
    virtual ~PredBase() {}
    virtual PredBase * clone() const = 0;
    virtual bool operator()(const IterBase * in) const = 0;

    // typedef typename variant_filter_iterator<Predicate, Type, const Type &, const Type *>::PredBase const_PredBase;
    typedef typename variant_filter_iterator<Predicate, Type const, Type const &, Type const *>::PredBase const_PredBase;

    virtual const_PredBase * const_clone() const = 0;
  };







  template<typename IterType>
  struct Iter : IterBase
  {

    Iter (const IterType & v) :
      iter_data (v)
    {
      // libMesh::out << "In Iter<IterType>::Iter(const IterType & v)" << std::endl;
    }


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


    virtual ~Iter () {}

    virtual IterBase * clone() const override
    {
#ifdef __SUNPRO_CC
      variant_filter_iterator::Iter<IterType> * copy =
        new variant_filter_iterator::Iter<IterType>(iter_data);
#else
      Iter<IterType> * copy =
        new Iter<IterType>(iter_data);
#endif

      return copy;
    }

    virtual typename IterBase::const_IterBase * const_clone() const override
    {
      // typedef typename variant_filter_iterator<Predicate, Type, const Type &, const Type *>::template Iter<IterType> const_Iter;
      typedef typename variant_filter_iterator<Predicate, Type const, Type const &,  Type const *>::template Iter<IterType> const_Iter;

      typename IterBase::const_IterBase * copy =
        new const_Iter(iter_data);

      return copy;
    }

    virtual ReferenceType operator*() const override
    {
      return * iter_data;
    }

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

    virtual bool equal(const IterBase * other) const override
    {
#if defined(__SUNPRO_CC) || (defined(__GNUC__) && (__GNUC__ < 3)  && !defined(__INTEL_COMPILER))
      const variant_filter_iterator::Iter<IterType> * p =
        libMesh::cast_ptr<const variant_filter_iterator::Iter<IterType> *>(other);
#else
      const Iter<IterType> * p =
        libMesh::cast_ptr<const Iter<IterType> *>(other);
#endif

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

    IterType iter_data;
  };




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

    virtual ~Pred () {}

    virtual PredBase * clone() const override
    {
#ifdef __SUNPRO_CC
      variant_filter_iterator::Pred<IterType,PredType> * copy =
        new variant_filter_iterator::Pred<IterType,PredType>(pred_data);
#else
      Pred<IterType,PredType> * copy =
        new Pred<IterType,PredType>(pred_data);
#endif

      return copy;
    }


    virtual typename PredBase::const_PredBase * const_clone() const override
    {
      //      typedef typename variant_filter_iterator<Predicate, Type, const Type &, const Type *>::template Pred<IterType, PredType> const_Pred;
      typedef typename variant_filter_iterator<Predicate, Type const, Type const &,  Type const *>::template Pred<IterType, PredType> const_Pred;


      typename PredBase::const_PredBase * copy =
        new const_Pred(pred_data);

      return copy;
    }




    virtual bool operator() (const IterBase * in) const override
    {
      libmesh_assert(in);

      // Attempt downcast
#if defined(__SUNPRO_CC) || (defined(__GNUC__) && (__GNUC__ < 3)  && !defined(__INTEL_COMPILER))
      const variant_filter_iterator::Iter<IterType> * p =
        libMesh::cast_ptr<const variant_filter_iterator::Iter<IterType> * >(in);
#else
      const Iter<IterType> * p =
        libMesh::cast_ptr<const Iter<IterType> *>(in);
#endif

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

    PredType pred_data;
  };



public:
  IterBase * data;

  IterBase * end;

  PredBase * pred;



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

  variant_filter_iterator () :
    data(nullptr),
    end(nullptr),
    pred(nullptr) {}

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



  template <class OtherType, class OtherReferenceType, class OtherPointerType>
  variant_filter_iterator (const variant_filter_iterator<Predicate, OtherType, OtherReferenceType, OtherPointerType> & rhs)
    : data (rhs.data != nullptr ? rhs.data->const_clone() : nullptr),
      end  (rhs.end  != nullptr ? rhs.end->const_clone()  : nullptr),
      pred (rhs.pred != nullptr ? rhs.pred->const_clone() : nullptr)
  {
    // libMesh::out << "Called templated copy constructor for variant_filter_iterator" << std::endl;
  }






  virtual ~variant_filter_iterator()
  {
    delete data; data = nullptr;
    delete end;  end  = nullptr;
    delete pred; pred = nullptr;
  }

  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>
inline
bool operator==(const variant_filter_iterator<Predicate, Type, ReferenceType, PointerType> & x,
                const variant_filter_iterator<Predicate, Type, ReferenceType, PointerType> & y)
{
  return x.equal(y);
}



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



#endif // LIBMESH_VARIANT_FILTER_ITERATOR_H