Subversion Repositories gelsvn

/* ----------------------------------------------------------------------- *
 * This file is part of GEL, www.imm.dtu.dk/GEL
 * Copyright (C) the authors (see AUTHORS.txt) and DTU Informatics
 *
 * Principal authors:
 *  Christian Thode Larsen (thode2d@gmail.com)
 *  J. Andreas Baerentzen (jab@imm.dtu.dk)
 *
 * See LICENSE.txt for licensing information
 * ----------------------------------------------------------------------- */

#ifndef __HMESH_ITERATORS_H__
#define __HMESH_ITERATORS_H__

#include "ConnectivityKernel.h"

namespace HMesh
{
    class VertexIDIterator
    {
    public:
        /// constructor (default: skipping enabled)
        VertexIDIterator(const ConnectivityKernel& _ck, VertexID _id, bool _skip = true);

        /// prefix increment 
        VertexIDIterator& operator ++();                
        /// postfix increment
        VertexIDIterator& operator ++(int);
        /// prefix decrement
        VertexIDIterator& operator --();
        /// postfix decrement
        VertexIDIterator& operator --(int);

        /// equal to
        bool operator ==(const VertexIDIterator& other) const;
        /// not equal to
        bool operator !=(const VertexIDIterator& other) const;

        /// indirection
        VertexID operator *();
        /// member by pointer
        VertexID* operator ->();
        /// cast
        //operator VertexID() const;

    private:
        const ConnectivityKernel* ck;
        VertexID id;
        bool skip;
    };

    class FaceIDIterator
    {
    public:
        /// constructor (default: skipping enabled)
        FaceIDIterator(const ConnectivityKernel& _ck, FaceID _id, bool _skip = true);

        /// prefix increment
        FaceIDIterator& operator ++();
        /// postfix increment
        FaceIDIterator& operator ++(int);
        /// prefix decrement
        FaceIDIterator& operator --();
        /// postfix decrement
        FaceIDIterator& operator --(int);

        /// equal to
        bool operator ==(const FaceIDIterator& other) const;
        /// not equal to
        bool operator !=(const FaceIDIterator& other) const;


        /// indirection
        FaceID operator *();
        /// member by pointer
        FaceID* operator ->();
        /// cast
        //operator FaceID() const;


    private:
        const ConnectivityKernel* ck;
        FaceID id;
        bool skip;
    };

    class HalfEdgeIDIterator
    {
    public:
        /// constructor (default: skipping enabled)
        HalfEdgeIDIterator(const ConnectivityKernel& _ck, HalfEdgeID _id, bool _skip = true);

        /// prefix increment
        HalfEdgeIDIterator& operator ++();
        /// postfix increment
        HalfEdgeIDIterator& operator ++(int);
        /// prefix decrement
        HalfEdgeIDIterator& operator --();
        /// postfix decrement
        HalfEdgeIDIterator& operator --(int);

        /// equal to
        bool operator ==(const HalfEdgeIDIterator& other) const;
        /// not equal to
        bool operator !=(const HalfEdgeIDIterator& other) const;

        /// indirection
        HalfEdgeID operator *();
        /// member by pointer
        HalfEdgeID* operator ->();
        /// cast
        //operator HalfEdgeID() const;

    private:
        const ConnectivityKernel* ck;
        HalfEdgeID id;
        bool skip;
    };

    inline VertexIDIterator::VertexIDIterator(const ConnectivityKernel& _ck, VertexID _id, bool _skip) : ck(&_ck), id(_id), skip(_skip){}


    inline VertexIDIterator& VertexIDIterator::operator ++()
    {
        id = ck->vertices_next(id, skip);
        return *this;
    }

    inline VertexIDIterator& VertexIDIterator::operator ++(int)
    { return ++(*this); }


    inline VertexIDIterator& VertexIDIterator::operator --()
    {
        id = ck->vertices_prev(id, skip);
        return *this;
    }

    inline VertexIDIterator& VertexIDIterator::operator --(int)
    { return --(*this); }


    inline bool VertexIDIterator::operator ==(const VertexIDIterator& other) const
    { return ck == other.ck && id == other.id; }

    inline bool VertexIDIterator::operator !=(const VertexIDIterator& other) const
    { return ck == other.ck && id == other.id; }


    inline VertexID VertexIDIterator::operator *()
    { return id; }

    inline VertexID* VertexIDIterator::operator ->()
    { return &id; }

    //inline VertexIDIterator::operator VertexID() const
    //{ return id; }



    inline FaceIDIterator::FaceIDIterator(const ConnectivityKernel& _ck, FaceID _id, bool _skip) : ck(&_ck), id(_id), skip(_skip){}


    inline FaceIDIterator& FaceIDIterator::operator ++()
    {
        id = ck->faces_next(id, skip);
        return *this;
    }

    inline FaceIDIterator& FaceIDIterator::operator ++(int)
    { return ++(*this); }

    inline FaceIDIterator& FaceIDIterator::operator --()
    {
        id = ck->faces_prev(id, skip);
        return *this;
    }

    inline FaceIDIterator& FaceIDIterator::operator --(int)
    { return --(*this); }


    inline bool FaceIDIterator::operator ==(const FaceIDIterator& other) const
    { return ck == other.ck && id == other.id; }

    inline bool FaceIDIterator::operator !=(const FaceIDIterator& other) const
    { return ck == other.ck && id == other.id; }


    inline FaceID FaceIDIterator::operator *()
    { return id; }

    inline FaceID* FaceIDIterator::operator ->()
    {return &id; }

    //inline FaceIDIterator::operator FaceID() const
    //{ return id; }


    inline HalfEdgeIDIterator::HalfEdgeIDIterator(const ConnectivityKernel& _ck, HalfEdgeID _id, bool _skip) : ck(&_ck), id(_id), skip(_skip){}


    inline HalfEdgeIDIterator& HalfEdgeIDIterator::operator ++()
    {
        id = ck->halfedges_next(id, skip);
        return *this;
    }

    inline HalfEdgeIDIterator& HalfEdgeIDIterator::operator ++(int)
    { return ++(*this); }

    inline HalfEdgeIDIterator& HalfEdgeIDIterator::operator --()
    {
        id = ck->halfedges_prev(id, skip);
        return *this;
    }

    inline HalfEdgeIDIterator& HalfEdgeIDIterator::operator --(int)
    { return --(*this); }


    inline bool HalfEdgeIDIterator::operator ==(const HalfEdgeIDIterator& other) const
    { return ck == other.ck && id == other.id; }

    inline bool HalfEdgeIDIterator::operator !=(const HalfEdgeIDIterator& other) const
    { return ck == other.ck && id == other.id; }


    inline HalfEdgeID HalfEdgeIDIterator::operator *()
    { return id; }

    inline HalfEdgeID* HalfEdgeIDIterator::operator ->()
    { return &id; }

    //inline HalfEdgeIDIterator::operator HalfEdgeID() const
    //{ return id; }


}

#endif