MeshIterator.h

Go to the documentation of this file.

#ifndef included_AMP_MeshIterators
#define included_AMP_MeshIterators
 
#include "AMP/mesh/MeshElement.h"
 
#include <iterator>
#include <memory>
 
 
namespace AMP::IO {
class RestartManager;
}
 
 
namespace AMP::Mesh {
 
 
class MeshIterator;
 
 
class MeshIteratorEnd
{
};
 
 
class MeshIteratorBase
{
public: // iterator_traits
    using iterator_category = std::random_access_iterator_tag;
    using value_type        = AMP::Mesh::MeshElement;
    using difference_type   = ptrdiff_t;
    using pointer           = const AMP::Mesh::MeshElement *;
    using reference         = const AMP::Mesh::MeshElement &;
 
 
public:
    enum class Type : uint8_t { Forward = 1, Bidirectional = 2, RandomAccess = 3 };
 
 
public:
    inline Type type() const { return d_iteratorType; }
 
    inline uint64_t getID() const { return d_typeHash; }
 
    inline size_t empty() const { return d_size == 0; }
 
    inline size_t size() const { return d_size; }
 
    inline size_t pos() const { return d_pos; }
 
    inline const MeshElement *operator->() const { return d_element; }
 
    inline const MeshElement &operator*() const { return *d_element; }
 
    inline MeshIteratorEnd end() const { return MeshIteratorEnd(); }
 
    inline bool operator==( MeshIteratorEnd ) const { return d_pos == d_size; }
 
    inline bool operator!=( MeshIteratorEnd ) const { return d_pos != d_size; }
 
public:
    virtual ~MeshIteratorBase() = default;
 
    virtual std::string className() const = 0;
 
    virtual void setPos( size_t ) = 0;
 
    // Increment
    virtual MeshIteratorBase &operator++() = 0;
 
    // Decrement
    virtual MeshIteratorBase &operator--() = 0;
 
    // Arithmetic operator+=
    virtual MeshIteratorBase &operator+=( int N ) = 0;
 
    virtual bool operator==( const MeshIteratorBase &rhs ) const = 0;
 
    virtual bool operator!=( const MeshIteratorBase &rhs ) const = 0;
 
    virtual MeshIterator begin() const = 0;
 
    virtual std::unique_ptr<MeshIteratorBase> clone() const = 0;
 
 
public: // Write/read restart data
    virtual void registerChildObjects( AMP::IO::RestartManager * ) const = 0;
    virtual void writeRestart( int64_t ) const                           = 0;
    MeshIteratorBase( int64_t, AMP::IO::RestartManager * );
 
 
protected:
    MeshIteratorBase()                           = default;
    MeshIteratorBase( const MeshIteratorBase & ) = delete;
    MeshIteratorBase &operator=( const MeshIteratorBase & ) = delete;
    MeshIteratorBase( MeshIteratorBase && )                 = delete;
    MeshIteratorBase &operator=( MeshIteratorBase && ) = delete;
 
 
protected:
    Type d_iteratorType          = Type::RandomAccess; 
    uint32_t d_typeHash          = 0;                  
    size_t d_size                = 0;                  
    size_t d_pos                 = 0;                  
    const MeshElement *d_element = nullptr;            
};
 
 
class MeshIterator final
{
public: // iterator_traits
    using iterator_category = std::random_access_iterator_tag;
    using value_type        = AMP::Mesh::MeshElement;
    using difference_type   = ptrdiff_t;
    using pointer           = const AMP::Mesh::MeshElement *;
    using reference         = const AMP::Mesh::MeshElement &;
    using Type              = MeshIteratorBase::Type;
 
 
public:
    template<class T, typename... Args>
    static MeshIterator create( Args... args )
    {
        return MeshIterator( new T( std::forward<Args>( args )... ) );
    }
 
    MeshIterator();
 
    MeshIterator( std::unique_ptr<MeshIteratorBase> &&p ) : it( p.release() ) {}
 
    MeshIterator( MeshIterator && );
 
    MeshIterator( const MeshIterator & );
 
    MeshIterator &operator=( MeshIterator && );
 
    MeshIterator &operator=( const MeshIterator & );
 
    MeshIterator &operator=( std::unique_ptr<MeshIteratorBase> && );
 
    ~MeshIterator() { delete it; }
 
    inline std::string className() const { return it->className(); }
 
    inline MeshIterator begin() const { return it->begin(); }
 
    inline MeshIteratorEnd end() const { return MeshIteratorEnd(); }
 
    inline MeshIterator &operator++()
    {
        it->operator++();
        return *this;
    }
 
    inline MeshIterator &operator--()
    {
        it->operator--();
        return *this;
    }
 
    inline MeshIterator &operator+=( int N )
    {
        it->operator+=( N );
        return *this;
    }
 
    MeshIterator &operator+=( const MeshIterator &it );
 
    inline bool operator==( const MeshIterator &rhs ) const { return *it == *rhs.it; }
 
    inline bool operator==( MeshIteratorEnd rhs ) const { return *it == rhs; }
 
    inline bool operator==( const MeshIteratorBase &rhs ) const { return *it == rhs; }
 
    inline bool operator!=( const MeshIterator &rhs ) const { return *it != *rhs.it; }
 
    inline bool operator!=( MeshIteratorEnd rhs ) const { return *it != rhs; }
 
    inline bool operator!=( const MeshIteratorBase &rhs ) const { return *it != rhs; }
 
    inline Type type() const { return it->type(); }
 
    inline uint64_t getID() const { return it->getID(); }
 
    inline MeshIteratorBase *rawIterator() { return it; }
 
    inline const MeshIteratorBase *rawIterator() const { return it; }
 
    inline bool empty() const { return it->empty(); }
 
    inline size_t size() const { return it->size(); }
 
    inline size_t pos() const { return it->pos(); }
 
    inline void setPos( size_t i ) { it->setPos( i ); }
 
    inline bool operator<( const MeshIterator &rhs ) const { return pos() < rhs.pos(); }
 
    inline bool operator<=( const MeshIterator &rhs ) const { return pos() <= rhs.pos(); }
 
    inline bool operator>( const MeshIterator &rhs ) const { return pos() > rhs.pos(); }
 
    inline bool operator>=( const MeshIterator &rhs ) const { return pos() >= rhs.pos(); }
 
    inline const MeshElement &operator*() const { return it->operator*(); }
 
    inline const MeshElement *operator->() const { return it->operator->(); }
 
    inline const MeshElement *get() const { return it->operator->(); }
 
    MeshIterator operator++( int );
 
    MeshIterator operator--( int );
 
    MeshIterator operator+( int N ) const;
 
    MeshIterator operator+( const MeshIterator &it ) const;
 
    MeshIterator operator-( int N ) const;
 
    MeshIterator operator-( const MeshIterator &it ) const;
 
    MeshIterator &operator-=( int N );
 
    MeshIterator &operator-=( const MeshIterator &it );
 
 
public: // Advanced functions (use with caution)
    MeshIterator( MeshIteratorBase *p ) : it( p ) {}
 
    MeshIteratorBase *release();
 
 
public: // Write/read restart data
    void registerChildObjects( AMP::IO::RestartManager *manager ) const;
    void writeRestart( int64_t fid ) const;
    MeshIterator( int64_t fid );
 
 
protected:
    MeshIteratorBase *it = nullptr; // A pointer to the derived class
};
 
 
} // namespace AMP::Mesh
 
 
#endif