variant_filter_iterator.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2014 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;    // <-- CUSTOM INTERFACE METHOD
    virtual IterBase& operator++() = 0;          // <-- CUSTOM INTERFACE METHOD
    virtual bool equal(const IterBase *other) const = 0;

    // Similar to clone function above, but returns a pointer to a copy of a different type.
    // 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;

    // Similar to clone function above, but returns a pointer to a copy of a different type.
    // 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
    {
#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
    {
      // 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   // <-- CUSTOM INTERFACE METHOD
    {
      return *iter_data;
    }

    virtual Iter& operator++()         // <-- CUSTOM INTERFACE METHOD
    {
      ++iter_data;
      return *this;
    }

    virtual bool equal(const IterBase *other) const
    {
#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
    {
#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
    {
      //      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
    {
      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) ), // note: uses default IterBase copy constructor
    end  ( new Iter<IterType>(e) ),
    pred ( new Pred<IterType,PredType>(p) )
  {
    this->satisfy_predicate();
  }

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

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



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






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

  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