FaceSet.h

Go to the documentation of this file.

/*
 * $Revision: 2027 $
 * 
 * last checkin:
 *   $Author: gutwenger $ 
 *   $Date: 2010-09-01 11:55:17 +0200 (Wed, 01 Sep 2010) $ 
 ***************************************************************/
 
#ifdef _MSC_VER
#pragma once
#endif

#ifndef OGDF_FACE_SET_H
#define OGDF_FACE_SET_H


#include <ogdf/basic/FaceArray.h>
#include <ogdf/basic/List.h>



namespace ogdf {



class OGDF_EXPORT FaceSetSimple {
public:
    FaceSetSimple(const CombinatorialEmbedding &E) : m_isContained(E,false) { }

    ~FaceSetSimple() { }


    void insert(face f) {
        OGDF_ASSERT(f->embeddingOf() == m_isContained.embeddingOf());
        bool &isContained = m_isContained[f];
        if (isContained == false) {
            isContained = true;
            m_faces.pushFront(f);
        }
    }



    void clear() {
        SListIterator<face> it;
        for(it = m_faces.begin(); it.valid(); ++it) {
            m_isContained[*it] = false;
        }
        m_faces.clear();
    }



    bool isMember(face f) const {
        OGDF_ASSERT(f->embeddingOf() == m_isContained.embeddingOf());
        return m_isContained[f];
    }

    const SListPure<face> &faces() const {
        return m_faces;
    }

private:
    FaceArray<bool> m_isContained;
    SListPure<face> m_faces;
};




class OGDF_EXPORT FaceSetPure {
public:
    FaceSetPure(const CombinatorialEmbedding &E) : m_it(E,ListIterator<face>()) { }

    ~FaceSetPure() { }


    void insert(face f) {
        OGDF_ASSERT(f->embeddingOf() == m_it.embeddingOf());
        ListIterator<face> &itF = m_it[f];
        if (!itF.valid())
            itF = m_faces.pushBack(f);
    }


    void remove(face f) {
        OGDF_ASSERT(f->embeddingOf() == m_it.embeddingOf());
        ListIterator<face> &itF = m_it[f];
        if (itF.valid()) {
            m_faces.del(itF);
            itF = ListIterator<face>();
        }
    }



    void clear() {
        ListIterator<face> it;
        for(it = m_faces.begin(); it.valid(); ++it) {
            m_it[*it] = ListIterator<face>();
        }
        m_faces.clear();
    }



    bool isMember(face f) const {
        OGDF_ASSERT(f->embeddingOf() == m_it.embeddingOf());
        return m_it[f].valid();
    }

    const ListPure<face> &faces() const {
        return m_faces;
    }

private:
    FaceArray<ListIterator<face> > m_it;
    ListPure<face> m_faces;
};



class OGDF_EXPORT FaceSet {
public:
    FaceSet(const CombinatorialEmbedding &E) : m_it(E,ListIterator<face>()) { }

    ~FaceSet() { }


    void insert(face f) {
        OGDF_ASSERT(f->embeddingOf() == m_it.embeddingOf());
        ListIterator<face> &itF = m_it[f];
        if (!itF.valid())
            itF = m_faces.pushBack(f);
    }

    /* running time: O(1)
     * Precond.: f is a face in the asociated embedding
     */
    void remove(face f) {
        OGDF_ASSERT(f->embeddingOf() == m_it.embeddingOf());
        ListIterator<face> &itF = m_it[f];
        if (itF.valid()) {
            m_faces.del(itF);
            itF = ListIterator<face>();
        }
    }



    void clear() {
        ListIterator<face> it;
        for(it = m_faces.begin(); it.valid(); ++it) {
            m_it[*it] = ListIterator<face>();
        }
        m_faces.clear();
    }



    bool isMember(face f) const {
        OGDF_ASSERT(f->embeddingOf() == m_it.embeddingOf());
        return m_it[f].valid();
    }


    int size() const {
        return m_faces.size();
    }

    const List<face> &faces() const {
        return m_faces;
    }

private:
    FaceArray<ListIterator<face> > m_it;
    List<face> m_faces;
};


} // end namespace ogdf


#endif