cellcomplex_C.h

Go to the documentation of this file.

#include "cellcomplex.h"
#include "cell.h"

//using std::make_pair;
using namespace std;


template<class Vertex,class Edge,class Face,class Tuple>
CellComplex<Vertex,Edge,Face,Tuple>::CellComplex(PersistantStore& store) 
: vertexs(store), edges(store), faces(store)
, trash_(store), keep_trash_(false), pool_(store)
, switch0(store), switch1(store), switch2(store), inverted_faces(store)
{
}

template<class Vertex,class Edge,class Face,class Tuple>
CellComplex<Vertex,Edge,Face,Tuple>::~CellComplex()
{
  /* All the Persistant* data structures deallocate their interiors on their
   * own; the pool also deallocates all the cells. */
}

template<class Vertex,class Edge,class Face,class Tuple>
PersistantStore& 
CellComplex<Vertex,Edge,Face,Tuple>::get_store() const
{
  return vertexs.get_store();
}


template<class Vertex,class Edge,class Face,class Tuple>
Tuple CellComplex<Vertex,Edge,Face,Tuple>::Switch(int snum,const Tuple& ct)
    const
{
    Tuple new_ct(ct);
    switch(snum){
        case 0:
          {
            typename Switch0_Hash_T::const_iterator it =
              switch0.find(make_pair(ct.v,ct.e));
        if (it == switch0.end())
          {
        cout << "[cellcomplex.C] Fell off the end of switch 0 hash"<<endl;
        cout << "Looking for ctv = "<<*ct.v<<endl;
        cout << "Looking for cte = "<<*ct.e<<endl;
        assert(it != switch0.end());
          }
            new_ct.v = (*it).second;
            break;
          }
        case 1:
          {
            typename Switch1_Hash_T::const_iterator it = switch1.find(ct);
            assert(it != switch1.end());
            new_ct.e = (*it).second;
            break;
          }
        case 2:
          {
            typename Switch2_Hash_T::const_iterator it =
              switch2.find(make_pair(ct.e,ct.f));
            assert(it != switch2.end());
            new_ct.f = (*it).second;
            break;
          }
        default:
            assert(0);
            break;
    }
    return new_ct;
}

template<class Vertex,class Edge,class Face,class Tuple>
void CellComplex<Vertex,Edge,Face,Tuple>::add_vertex(Vertex *v)
{
#ifdef DEBUG
    if( !v ) FATAL_ERROR("CellComplex::add_vertex -- vertex is NULL");
    if( is_member(v) ) FATAL_ERROR("CellComplex::add_vertex --- vertex is already in Complex");
#endif

    pool_.mark_allocated(v);
    vertexs.insert(v);
}

template<class Vertex,class Edge,class Face,class Tuple>
void CellComplex<Vertex,Edge,Face,Tuple>::add_edge(Edge *e)
{
  Vertex *v1 = e->get_vertex(0);
  Vertex *v2 = e->get_vertex(1);

  /* Run standard checks */
  assert(e);
  assert(is_member(v1));
  assert(is_member(v2));
  assert(!is_member(e));

  // update vertex's edge list
  v1->add_edge(e);
  if (v1 != v2) {
    v2->add_edge(e);
  }

    //update switch0's
    switch0[make_pair(v1,e)]=v2;
    switch0[make_pair(v2,e)]=v1;

    pool_.mark_allocated(e);
    edges.insert(e);
}

template<class Vertex,class Edge,class Face,class Tuple>
void CellComplex<Vertex,Edge,Face,Tuple>::add_face(Face *f,Edge **es,int num_es,bool inverse_handed)
{
    int i,j;
#ifdef DEBUG
    /* Run standard error checks */
    if(!f) FATAL_ERROR("CellComplex::add_face --- face is NULL");
    if(is_member(f)) FATAL_ERROR("CellComplex::add_face --- face is already in Complex");
    for(i=0; i < num_es; i++){
        if( !es[i]) FATAL_ERROR("CellComplex::add_face --- given edge is NULL");
        if( !is_member(es[i]) ) FATAL_ERROR("CellComplex::add_face --- given edge is not in Complex");
    }
#endif

    //update face's edge list, and edge's face list
    for(i=0;i<num_es;i++){
        f->add_edge(es[i]);
        es[i]->add_face(f);
    }

    // update switch 2's
    for(int i = 0; i < num_es; i++) {
      Edge *e = es[i];
      if (e->num_faces() == 1) {
        Face *ef = e->get_any_face();
        switch2[make_pair(e,ef)] = ef;
      } else {
        assert(e->num_faces() == 2);
    typename Edge::face_iterator it = e->begin_faces();
    Face *f1 = *it;
    Face *f2 = *(++it);
        switch2[make_pair(es[i],f1)] = f2;
        switch2[make_pair(es[i],f2)] = f1;
      }
    }

    //update switch 1's
    //invariant that only two of the es[i] share each vertex
    //through each iteration es[i] will share v0 with v0_edge and v1 with v1_edge
    Tuple tup(NULL,NULL,f);
    Vertex *v0,*v1;
    Edge *v0_edge, *v1_edge;

    //check for self loop
    if(num_es==1){
        tup.e = es[0];
        tup.v = es[0]->get_vertex(0);
        switch1[tup] = es[0];
        tup.v = es[0]->get_vertex(1);
        switch1[tup] = es[0];
    }
    // otherwise we have more than one edge
    else{
        /* foreach edge e,
         *  foreach vertex v of the edge,
         *  find the other edge e' that shares v
         *  set up the switch from (v,e) to e'
         * since we do this for every edge, the reverse switch will be
         * set up eventually.
         */
        for(i=0;i<num_es;i++){
            tup.e = es[i];
            v0 = es[i]->get_vertex(0);
            v1 = es[i]->get_vertex(1);
            v0_edge = NULL;
            v1_edge = NULL;
            for(j=0; j < num_es; j++){
                if(i != j){
                    if(es[j]->get_vertex(0)==v0 || es[j]->get_vertex(1)==v0) v0_edge=es[j];
                    if(es[j]->get_vertex(0)==v1 || es[j]->get_vertex(1)==v1) v1_edge=es[j];
                }
            }
            if(v0_edge==NULL || v1_edge==NULL) FATAL_ERROR("CellComplex::add_face --- edge set for face is not closed");
            tup.v=v0;
            switch1[tup]=v0_edge;
            tup.v=v1;
            switch1[tup]=v1_edge;
        }
    }

    if( inverse_handed ) inverted_faces.insert(f);

    pool_.mark_allocated(f);
    faces.insert(f);
}

template<class Vertex,class Edge,class Face,class Tuple>
void CellComplex<Vertex,Edge,Face,Tuple>::delete_vertex(Vertex *v)
{
    if( !v ) return;
    if( !is_member(v) ) FATAL_ERROR("CellComplex::delete_vertex --- vertex is not a member of Complex");

    // delete edges with v as a vertex (they will themselves delete the faces)
    while(v->num_edges() > 0) {
      Edge *e = v->get_any_edge();
      delete_edge(e); // this will remove e from v also, hence the strange loop
    }
    vertexs.erase(v);

    trash_cell(v);
}

template<class Vertex,class Edge,class Face,class Tuple>
void CellComplex<Vertex,Edge,Face,Tuple>::delete_edge(Edge *e)
{
    if(!e) return;
    if( !is_member(e) ) FATAL_ERROR("CellComplex::delete_edge --- edge is not a member of Complex");

    Vertex *v0,*v1;
    v0 = e->get_vertex(0);
    v1 = e->get_vertex(1);

    // delete faces that have e as an edge; this changes faces_, hence the
    // strange loop
    while(e->num_faces() > 0) {
      delete_face(e->get_any_face());
    }

    //remove e from the list of uppers of its vertexes
    v0->delete_edge(e);
    v1->delete_edge(e);

    // remove switch 0's; higher switches were owned by the faces, which have
    // already been deleted
    switch0.erase(make_pair(v0,e));
    switch0.erase(make_pair(v1,e));

    //remove edge from complex
    edges.erase(e);

    trash_cell(e);
}

template<class Vertex,class Edge,class Face,class Tuple>
void CellComplex<Vertex,Edge,Face,Tuple>::delete_face(Face *f)
{
    if(!f) return;
    if( !is_member(f) ) FATAL_ERROR("CellComplex::delete_face --- face is not a member of Complex");

    Vertex *v0,*v1;
    Tuple tup(0,0,f);

    for(typename Face::edge_iterator it = f->begin_edges();
        it != f->end_edges(); ++it) {
        Edge *e = *it;

        //remove f from its edge's face list
        e->delete_face(f);

        // remove switch2 out of this face;
        // make switch2 into this face be a self-loop (if there are any
        // edges left around the edge)
        switch2.erase(make_pair(e,f));
        switch(e->num_faces()) {
          case 0:
            break;
          case 1:
            switch2[make_pair(e,e->get_any_face())] = e->get_any_face();
            break;
          default:
            assert(e->num_faces() == 0 || e->num_faces() == 1);
            break;
        }

        // remove switch1 out of this edge (the reverse direction will be
        // removed by the corresponding edge in another iteration of this loop)
        v0 = e->get_vertex(0);
        v1 = e->get_vertex(1);
        tup.e = e;
        tup.v = v0;
        switch1.erase(tup);
        tup.v = v1;
        switch1.erase(tup);

        // switch0 doesn't deal with faces
    }

    //remove f from inverted_faces
    inverted_faces.erase(f);

    //remove f from complex
    faces.erase(f);

    trash_cell(f);
}

template<class Vertex,class Edge,class Face,class Tuple>
void CellComplex<Vertex,Edge,Face,Tuple>::trash_cell(Cell *c)
{
  if (keep_trash_ > 0) {
    bool found;
    found = trash_.insert(c).second;
    assert(found);
  } else {
    pool_.mark_deleted(c);
  }
}

template<class Vertex,class Edge,class Face,class Tuple>
void CellComplex<Vertex,Edge,Face,Tuple>::keep_trash()
{
  keep_trash_++;
}

template<class Vertex,class Edge,class Face,class Tuple>
void CellComplex<Vertex,Edge,Face,Tuple>::empty_trash()
{
  assert(keep_trash_ > 0);
  keep_trash_--;
  if (keep_trash_ == 0) {
    for(typename Trash_T::iterator it = trash_.begin();
        it != trash_.end(); ++it) {
      pool_.mark_deleted(*it);
    }
    trash_.clear();
  }
}

template<class Vertex,class Edge,class Face,class Tuple>
bool CellComplex<Vertex,Edge,Face,Tuple>::is_member(Vertex *v) const
{
    //return ids.find(v->id) != ids.end();
    return vertexs.find(v) != vertexs.end();
}

template<class Vertex,class Edge,class Face,class Tuple>
bool CellComplex<Vertex,Edge,Face,Tuple>::is_member(Edge *e) const
{
    //return ids.find(e->id) != ids.end();
    return edges.find(e) != edges.end();
}

template<class Vertex,class Edge,class Face,class Tuple>
bool CellComplex<Vertex,Edge,Face,Tuple>::is_member(Face *f) const
{
    //return ids.find(f->id) != ids.end();
    return faces.find(f) != faces.end();
}

template<class Vertex,class Edge,class Face,class Tuple>
bool CellComplex<Vertex,Edge,Face,Tuple>::is_inverse_handed(Face *f) const
{
    return ( inverted_faces.count(f) != 0 );
}




/***************************************************************************
  Size of switch hashes, for debugging.
 ***************************************************************************/
template<class Vertex,class Edge,class Face,class Tuple>
int CellComplex<Vertex,Edge,Face,Tuple>::switch_size(int d) const
{
  switch(d) {
    case 0: return switch0.size();
    case 1: return switch1.size();
    case 2: return switch2.size();
    default: assert(0); return 0;
  }
}

template<class Vertex,class Edge,class Face,class Tuple>
int CellComplex<Vertex,Edge,Face,Tuple>::lower(Edge *e, std::vector<Vertex*> &vs)
{
    vs.push_back(e->get_vertex(0));
    vs.push_back(e->get_vertex(1));
    return 2;
}

template<class Vertex,class Edge,class Face,class Tuple>
int CellComplex<Vertex,Edge,Face,Tuple>::lower(Edge *e, std::list<Vertex*> &vs)
{
    vs.push_back(e->get_vertex(0));
    vs.push_back(e->get_vertex(1));
    return 2;
}

template<class Vertex,class Edge,class Face,class Tuple>
int CellComplex<Vertex,Edge,Face,Tuple>::lower(Face *f, std::vector<Edge*> &es)
{
    if(!f) return -1;
    for(typename Face::edge_iterator it = f->begin_edges();
        it != f->end_edges(); ++it) {
      es.push_back(*it);
    }
    return f->num_edges();
}

template<class Vertex,class Edge,class Face,class Tuple>
int CellComplex<Vertex,Edge,Face,Tuple>::lower(Face *f, std::list<Edge*> &es)
{
    if(!f) return -1;
    for(typename Face::edge_iterator it = f->begin_edges();
        it != f->end_edges(); ++it) {
      es.push_back(*it);
    }
    return f->num_edges();
}

template<class Vertex,class Edge,class Face,class Tuple>
int CellComplex<Vertex,Edge,Face,Tuple>::upper(Vertex *v, std::vector<Edge*> &es)
{
  if(!v) return -1;
  copy(v->begin_edges(), v->end_edges(), std::back_inserter(es));
  return v->num_edges();
}

template<class Vertex,class Edge,class Face,class Tuple>
int CellComplex<Vertex,Edge,Face,Tuple>::upper(Vertex *v, std::list<Edge*> &es)
{
  if(!v) return -1;
  copy(v->begin_edges(), v->end_edges(), std::back_inserter(es));
  return v->num_edges();
}

template<class Vertex,class Edge,class Face,class Tuple>
int CellComplex<Vertex,Edge,Face,Tuple>::upper(Edge *e, std::vector<Face*> &fs)
{
    int n=0;
    assert(e);
    for(typename Edge::face_iterator it = e->begin_faces();
        it != e->end_faces(); ++it) {
        Face *f= *it;
        if(f){
            fs.push_back(f);
            n++;
        }
    }
    return n;
}

template<class Vertex,class Edge,class Face,class Tuple>
int CellComplex<Vertex,Edge,Face,Tuple>::upper(Edge *e, std::list<Face*> &fs)
{
    int n=0;
    assert(e);
    for(typename Edge::face_iterator it = e->begin_faces();
        it != e->end_faces(); ++it) {
        Face *f= *it;
        if(f){
            fs.push_back(f);
            n++;
        }
    }
    return n;
}

template<class Vertex,class Edge,class Face,class Tuple>
Vertex* CellComplex<Vertex,Edge,Face,Tuple>::get_opposite_vertex(Edge *e, Vertex *v)
{
    Vertex *v0 = e->get_vertex(0);
    if( v == v0) v0 = e->get_vertex(1);
    return v0;
}

template<class Vertex,class Edge,class Face,class Tuple>
Face* CellComplex<Vertex,Edge,Face,Tuple>::get_opposite_face(Edge *e, Face *f)
{
#ifdef DEBUG
    if( !f->has_edge(e) ) FATAL_ERROR( "CellComplex::get_opposite_face --- e is not an edge of f" );
#endif
    typename Edge::face_iterator it = find_if(e->begin_faces(), e->end_faces(),
        std::bind2nd(std::not_equal_to<Face*>(),f));
    if (it == e->end_faces()) {
      return NULL;
    } else {
      return *it;
    }
}

template<class Vertex,class Edge,class Face,class Tuple>
void CellComplex<Vertex,Edge,Face,Tuple>::enqueue_edges(Vertex *v, std::deque<Edge*> &edges)
{
  copy(v->begin_edges(), v->end_edges(), std::back_inserter(edges));
}

template<class Vertex,class Edge,class Face,class Tuple>
void CellComplex<Vertex,Edge,Face,Tuple>::enqueue_faces(Vertex *v, std::deque<Face*> &faces)
{
    assert(v);
    std::list<Face*> temp;
    for(typename Vertex::edge_iterator it = v->begin_edges();
        it != v->end_edges(); ++it) {
        Edge *e = *it;
        for(typename Edge::face_iterator it = e->begin_faces();
            it != e->end_faces(); ++it) {
            Face *f = *it;
            if(f) temp.push_back(f);
        }
    }
    temp.unique();
    copy(temp.begin(), temp.end(), back_inserter(faces));
}


template<class Vertex,class Edge,class Face,class Tuple>
Edge* CellComplex<Vertex,Edge,Face,Tuple>::find_common_edge(Vertex *v0, Vertex *v1)
{
    for(typename Vertex::edge_iterator it = v0->begin_edges();
        it != v0->end_edges(); ++it) {
        Edge *e = *it;
        if((e->get_vertex(0) == v1) || (e->get_vertex(1) == v1)) return e;
    }
    return NULL;
}

template<class Vertex,class Edge,class Face,class Tuple>
Edge* CellComplex<Vertex,Edge,Face,Tuple>::find_common_edge(Face *f0, Face *f1)
{
    for(typename Face::edge_iterator it = f0->begin_edges();
        it != f0->end_edges(); ++it) {
        Edge *e = *it;
        if(e->has_face(f1)) return e;
    }
    return NULL;
}

template<class Vertex,class Edge,class Face,class Tuple>
void CellComplex<Vertex,Edge,Face,Tuple>::find_adjacent_faces(Face *f, std::list<Face*> &faces)
{
    for(typename Face::edge_iterator it = f->begin_edges();
        it != f->end_edges(); ++it) {
        Edge *e = *it;
        Face *temp = get_opposite_face(e, f);
        if (temp) faces.push_back(temp);
    }
}


template<class Vertex,class Edge,class Face,class Tuple>
void CellComplex<Vertex,Edge,Face,Tuple>::find_adjacent_faces(Face *f, std::deque<Face*> &faces)
{
    for(typename Face::edge_iterator it = f->begin_edges();
        it != f->end_edges(); ++it) {
        Edge *e = *it;
        Face *temp = get_opposite_face(e, f);
        if (temp) faces.push_back(temp);
    }
}

template<class Vertex,class Edge,class Face,class Tuple>
void CellComplex<Vertex,Edge,Face,Tuple>::find_adjacent_edges(Edge *e, std::list<Edge*> &edges)
{
  assert(e);
  for(typename Edge::face_iterator it = e->begin_faces();
      it != e->end_faces(); ++it) {
    Face *f = *it;
    for(typename Face::edge_iterator it = f->begin_edges();
        it != f->end_edges(); ++it) {
      Edge *temp = *it;
      if(temp != e) edges.push_back(temp);
    }
  }
}

template<class Vertex,class Edge,class Face,class Tuple>
void CellComplex<Vertex,Edge,Face,Tuple>::find_adjacent_edges(Edge *e, std::deque<Edge*> &edges)
{
  assert(e);
  for(typename Edge::face_iterator it = e->begin_faces();
      it != e->end_faces(); ++it) {
    Face *f = *it;
    for(typename Face::edge_iterator it = f->begin_edges();
        it != f->end_edges(); ++it) {
      Edge *temp = *it;
      if(temp != e) edges.push_back(temp);
    }
  }
}

template<class Vertex,class Edge,class Face,class Tuple>
Tuple CellComplex<Vertex,Edge,Face,Tuple>::get_tuple() const
{
    return get_tuple( *faces.begin() );
}

template<class Vertex,class Edge,class Face,class Tuple>
Tuple CellComplex<Vertex,Edge,Face,Tuple>::get_tuple(Face *f) const
{
#ifdef DEBUG
    if( !f ) FATAL_ERROR("CellComplex::get_tuple(f) --- face is NULL!");
#endif

    Edge *e = f->get_canon_edge();
    Vertex *v = e->get_canon_vertex();

    Tuple ct(v,e,f);
    if (!is_inverse_handed(f)) return ct;
    else return Switch(0,ct);
}

template<class Vertex,class Edge,class Face,class Tuple>
Tuple CellComplex<Vertex,Edge,Face,Tuple>::get_tuple(Edge *e, Face *f)
    const
{
#ifdef DEBUG
    if( !f ) FATAL_ERROR("CellComplex::get_tuple(e,f) --- face is NULL!");
    if( !e ) FATAL_ERROR("CellComplex::get_tuple(e,f) --- edge is NULL!");
    if( !f->has_edge(e) ) FATAL_ERROR("CellComplex::get_tuple(e,f) --- edge is not an edge of face");
#endif

    Tuple tup;
    tup = get_tuple(f);
    while(e != tup.e) tup = Switch(1, Switch(0, tup) );
    return tup;
}

template<class Vertex,class Edge,class Face,class Tuple>
Tuple CellComplex<Vertex,Edge,Face,Tuple>::get_tuple(Vertex *v, Face *f)
    const
{
#ifdef DEBUG
    if( !v ) FATAL_ERROR("CellComplex::get_tuple(v,f) --- vertex is NULL!");
    if( !f ) FATAL_ERROR("CellComplex::get_tuple(v,f) --- face is NULL!");
    if( !f->has_vertex(v) ) FATAL_ERROR("CellComplex::get_tuple(v,f) --- vertex is not a sub-simplex of face");
#endif

    Tuple tup;
    tup = get_tuple(f);
    while(v != tup.v) tup = Switch(1,Switch(0,tup));
    return tup;
}


template<class Vertex, class Edge, class Face, class Tuple>
Tuple CellComplex<Vertex,Edge,Face,Tuple>::get_tuple(Vertex *v, Edge *e)
     const
{
  Tuple tup;
  Face *f = e->get_any_face();
  tup = get_tuple(e,f); // this is oriented by might not contain v
  if (tup.v != v) tup = Switch(2, Switch(0, tup));
  //If this was one sided, then switch 2 is fixed, and there is no oriented tuple
  assert((tup.v == v) && "Edge Vertex pair is on the boundary: No oriented tuple exists");

  return tup;
}

template<class Vertex,class Edge,class Face,class Tuple>
Tuple CellComplex<Vertex,Edge,Face,Tuple>::get_tuple(Vertex *v)
    const
{
#ifdef DEBUG
    if( !v ) FATAL_ERROR("CellComplex::get_tuple(v) --- vertex is NULL!");
#endif

    Edge *e = v->get_any_edge();

#ifdef DEBUG
    if( !e ) FATAL_ERROR("CellComplex::get_tuple(v) --- vertex has no edges");
#endif

    Face *f = e->get_any_face();

#ifdef DEBUG
    if( !f ) FATAL_ERROR("CellComplex::get_tuple(v) --- edge 0 has no face");
#endif

    return get_tuple(v,f);
}

template<class Vertex,class Edge,class Face,class Tuple>
Tuple CellComplex<Vertex,Edge,Face,Tuple>::get_tuple(Edge* e)
    const
{
#ifdef DEBUG
  if( !e ) FATAL_ERROR("CellComplex::get_tuple(e) --- edge is NULL!");
#endif
  
  Face *f = e->get_any_face();
  
  return get_tuple(e,f);
}

template<class Vertex,class Edge,class Face,class Tuple>
void CellComplex<Vertex,Edge,Face,Tuple>::print(std::ostream& os) const
{
    //this will be improved later
    os  << "CellComplex:= { num_vertexs=" << get_num_vertices()
        << ", num_edges=" << get_num_edges()
        << ", num_faces=" << get_num_faces()
        << " }\n";
    typename Vertex_Hash_T::const_iterator i;
    typename Edge_Hash_T::const_iterator j;
    typename Face_Hash_T::const_iterator k;

    os << "---------------------Vertices------------------\n";
    for(i=vertexs.begin();i!=vertexs.end(); ++i) { os << (*i); }
    os << "----------------------Edges--------------------\n";
    for(j=edges.begin();j!=edges.end(); ++j) { os << (*j); }
    os << "----------------------Faces--------------------\n";
    for(k=faces.begin();k!=faces.end(); ++k) { os << (*k); }
}

template<class Vertex,class Edge,class Face,class Tuple>
void CellComplex<Vertex,Edge,Face,Tuple>::print_statistics(std::ostream& os)
    const
{
    os  <<"#######################CELL COMPLEX##############################\n"
        << "Vertices: " << get_num_vertices() << std::endl
        << "Edges:    " << get_num_edges()    << std::endl
        << "Faces:    " << get_num_faces()    << std::endl
        << "Inverted Faces: " << inverted_faces.size() << std::endl
        << "Switch0 size: " << switch0.size() << std::endl
        << "Switch1 size: " << switch1.size() << std::endl
        << "Switch2 size: " << switch2.size() << std::endl
        << "##############################################################\n\n";
}


/* From here down are wrappers for ruby */

template<class Vertex,class Edge,class Face,class Tuple>
typename CellComplex<Vertex,Edge,Face,Tuple>::Vertex_Hash_T::iterator
CellComplex<Vertex,Edge,Face,Tuple>::get_vertexs_begin() const
{
    return vertexs.begin();
}

template<class Vertex,class Edge,class Face,class Tuple>
typename CellComplex<Vertex,Edge,Face,Tuple>::Vertex_Hash_T::iterator
CellComplex<Vertex,Edge,Face,Tuple>::get_vertexs_end() const
{
    return vertexs.end();
}

template<class Vertex,class Edge,class Face,class Tuple>
typename CellComplex<Vertex,Edge,Face,Tuple>::Edge_Hash_T::iterator
CellComplex<Vertex,Edge,Face,Tuple>::get_edges_begin() const
{
    return edges.begin();
}

template<class Vertex,class Edge,class Face,class Tuple>
typename CellComplex<Vertex,Edge,Face,Tuple>::Edge_Hash_T::iterator
CellComplex<Vertex,Edge,Face,Tuple>::get_edges_end() const
{
    return edges.end();
}

template<class Vertex,class Edge,class Face,class Tuple>
typename CellComplex<Vertex,Edge,Face,Tuple>::Face_Hash_T::iterator
CellComplex<Vertex,Edge,Face,Tuple>::get_faces_begin() const
{
    return faces.begin();
}

template<class Vertex,class Edge,class Face,class Tuple>
typename CellComplex<Vertex,Edge,Face,Tuple>::Face_Hash_T::iterator
CellComplex<Vertex,Edge,Face,Tuple>::get_faces_end() const
{
    return faces.end();
}

template<class Vertex,class Edge,class Face,class Tuple>
Vertex *
CellComplex<Vertex,Edge,Face,Tuple>::get_next_vertex(typename CellComplex<Vertex,Edge,Face,Tuple>::Vertex_Hash_T::iterator &it) const
{
  if(it == get_vertices_end()) {
    return NULL;
  }
  Vertex *v = *it;
  ++it;
  return v;
}

template<class Vertex,class Edge,class Face,class Tuple>
Edge *
CellComplex<Vertex,Edge,Face,Tuple>::get_next_edge(typename CellComplex<Vertex,Edge,Face,Tuple>::Edge_Hash_T::iterator &it) const
{
  if(it == get_edges_end()) {
    return NULL;
  }
  Edge *e = *it;
  ++it;
  return e;
}

template<class Vertex,class Edge,class Face,class Tuple>
Face *
CellComplex<Vertex,Edge,Face,Tuple>::get_next_face(typename CellComplex<Vertex,Edge,Face,Tuple>::Face_Hash_T::iterator &it) const
{
  if(it == get_faces_end()) {
    return NULL;
  }
  Face *f = *it;
  ++it;
  return f;
}

---