cellcomplex.h

Go to the documentation of this file.

#ifndef CELLCOMPLEX_H
#define CELLCOMPLEX_H


#include <iostream>
#include <cstddef>
#include <vector>
#include <queue>
#include <deque>

#include "globals.h"
#include "hash_set.h"
#include "hash_map.h"
#include "hash_classes.h"
#include "util.h"
#include "celltuple.h"
#include "persistance.h"


template <class Vertex,class Edge,class Face,class Tuple>
class CellComplex{
    public:
        CellComplex(PersistantStore&);
        virtual ~CellComplex();

        PersistantStore& get_store() const;

    private:
        /* copy and assignment constructors declared private to prevent use */
        CellComplex( const CellComplex<Vertex, Edge, Face, Tuple> &other);

        CellComplex<Vertex, Edge, Face, Tuple>&
        operator=(const CellComplex<Vertex, Edge, Face, Tuple> &other);


    protected:
        virtual void add_vertex(Vertex*);
        virtual void add_edge(Edge *e);
        virtual void add_face(Face*,Edge**,int,bool inverse_handed=false);

        virtual void delete_vertex(Vertex*);
        virtual void delete_edge(Edge*);
        virtual void delete_face(Face*);
        void trash_cell(Cell*);
        void keep_trash();
        void empty_trash();
    public:
        typedef PersistantHashSet<Vertex*> Vertex_Hash_T;
        typedef PersistantHashSet<Edge*> Edge_Hash_T;
        typedef PersistantHashSet<Face*> Face_Hash_T;
        typedef PersistantHashMap<std::pair<Vertex*,Edge*>,Vertex*,PairHasher<Vertex*,Edge*> > Switch0_Hash_T;
        typedef PersistantHashMap<Tuple,Edge*,TupleHasher<Tuple> > Switch1_Hash_T;
        typedef PersistantHashMap<std::pair<Edge*,Face*>,Face*,PairHasher<Edge*,Face*> > Switch2_Hash_T;
        typedef PersistantHashSet<Face*> Inverted_Hash_T;
        bool is_member(Vertex*) const;
        bool is_member(Edge*) const;
        bool is_member(Face*) const;
    bool is_inverse_handed(Face*) const;
        int lower(Edge *e, std::vector<Vertex*> &vs);
        int lower(Edge *e, std::list<Vertex*> &vs);
        int lower(Face *f, std::vector<Edge*> &es);
        int lower(Face *f, std::list<Edge*> &es);

        int upper(Edge *e, std::vector<Face*> &fs);
        int upper(Edge *e, std::list<Face*> &fs);
        int upper(Vertex *v, std::vector<Edge*> &es);
        int upper(Vertex *v, std::list<Edge*> &es);

        Vertex* get_opposite_vertex(Edge *e, Vertex *v);
        Face*   get_opposite_face(Edge *e, Face *f);

        void enqueue_faces(Vertex *vert, std::deque<Face*> &faces);
        void enqueue_edges(Vertex *vert, std::deque<Edge*> &edges);

        Edge* find_common_edge(Vertex *v0, Vertex *v1);
        Edge* find_common_edge(Face *f0, Face *f1);

        void find_adjacent_faces(Face *f, std::list<Face*> &faces);
        void find_adjacent_edges(Edge *e, std::list<Edge*> &edges);

        void find_adjacent_faces(Face *f, std::deque<Face*> &faces);
        void find_adjacent_edges(Edge *e, std::deque<Edge*> &edges);
        Tuple Switch(int,const Tuple&) const;

        Tuple get_tuple() const;
        Tuple get_tuple(Face*) const;
        Tuple get_tuple(Vertex*, Face*) const;
        Tuple get_tuple(Edge*, Face*) const;
        Tuple get_tuple(Vertex*) const;
        Tuple get_tuple(Edge*) const;
    Tuple get_tuple(Vertex *v, Edge *e) const;


        int switch_size(int) const;
        void print(std::ostream& os = std::cout) const;
        void print_statistics(std::ostream& os = std::cout) const;

        template<class V,class E,class F,class T>
        friend std::ostream& operator<<( std::ostream &stream, const CellComplex<V, E, F, T> &bm);
        int get_num_vertices() const { return vertexs.size(); }
        typename Vertex_Hash_T::iterator get_vertexs_begin() const;
        typename Vertex_Hash_T::iterator get_vertexs_end() const;
        typename Vertex_Hash_T::iterator get_vertices_begin() const {
            return get_vertexs_begin();
        }
        typename Vertex_Hash_T::iterator get_vertices_end() const {
            return get_vertexs_end();
        }

        int get_num_edges() const { return edges.size(); }
        typename Edge_Hash_T::iterator get_edges_begin() const;
        typename Edge_Hash_T::iterator get_edges_end() const;

        int get_num_faces() const { return faces.size(); }
        typename Face_Hash_T::iterator get_faces_begin() const;
        typename Face_Hash_T::iterator get_faces_end() const;
        Vertex *get_next_vertex(typename Vertex_Hash_T::iterator&) const;
        Edge *get_next_edge(typename Edge_Hash_T::iterator&) const;
        Face *get_next_face(typename Face_Hash_T::iterator&) const;
    private:
        Vertex_Hash_T vertexs; 
        Edge_Hash_T edges; 
        Face_Hash_T faces; 
        typedef PersistantHashSet<Cell*> Trash_T;
        Trash_T trash_;
        int keep_trash_;
        /* Independent of the trash mechanism: this handles deleting things
           allocated and undone, or not actually deleting things until a
           commit. */
        PersistantMemoryPool<Cell> pool_;

        Switch0_Hash_T switch0; 
        Switch1_Hash_T switch1; 
        Switch2_Hash_T switch2; 
        Inverted_Hash_T inverted_faces; 
};

template<class Vertex,class Edge,class Face,class Tuple>
inline std::ostream& operator << (std::ostream &stream,
                           const CellComplex<Vertex, Edge, Face, Tuple> &cc)
{
    cc.print_statistics(stream);
    return stream;
}

#endif

---