Node_AllIncCells.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__geom_mesh_simplicial_Node_AllIncCells_h__)
#define __geom_mesh_simplicial_Node_AllIncCells_h__

#if defined(DEBUG_geom) && !defined(DEBUG_Node_AllIncCells)
#define DEBUG_Node_AllIncCells
#endif

#ifdef DEBUG_Node_AllIncCells
#ifndef DEBUG_Node_VertSelfId
// Debug the base class.
#define DEBUG_Node_VertSelfId
#endif
#endif

#include "Node_VertSelfId.h"

#include "../../../ads/iterator/IndirectIterator.h"

#include <vector>

BEGIN_NAMESPACE_GEOM


template <class Mesh>
class Node_AllIncCells :
  public Node_VertSelfId<Mesh>
{
  //
  // Private types.
  //

private:

  typedef Node_VertSelfId<Mesh> base_type;

  //
  // Enumerations.
  //

public:

  enum { N = base_type::N };

  //
  // Public types.
  //

public:

  typedef Mesh mesh_type;

  typedef typename mesh_type::cell_iterator cell_iterator;
  typedef typename mesh_type::cell_const_iterator cell_const_iterator;

  typedef typename base_type::node_iterator node_iterator;
  typedef typename base_type::node_const_iterator node_const_iterator;

  typedef typename base_type::number_type number_type;
  typedef typename base_type::vertex_type vertex_type;

  //
  // Private types.
  //

private:

  typedef std::vector<cell_iterator> cell_iterator_container;

  //
  // More public types.
  //

public:

  typedef typename cell_iterator_container::iterator cell_iter_iterator;
  typedef typename cell_iterator_container::const_iterator 
  cell_iter_const_iterator;

  typedef ads::IndirectIterator<typename cell_iterator_container::iterator> 
  cell_inc_to_node_iterator;
  typedef ads::IndirectIterator<typename 
  cell_iterator_container::const_iterator> 
  cell_inc_to_node_const_iterator;

  //
  // Data
  //
      
private:
      
  cell_iterator_container _cells;

public:

  //--------------------------------------------------------------------------

  Node_AllIncCells() :
    base_type(),
    _cells()
  {}

  Node_AllIncCells( const vertex_type& vertex, const int identifier = -1 ) :
    base_type( vertex, identifier ),
    _cells()
  {}

  void
  build( const vertex_type& vertex, const int identifier = -1,
         const node_iterator self = 0 )
  {
    base_type::build( vertex, identifier, self );
    _cells.clear();
  }

#if 0
  Node_AllIncCells( const vertex_type& vertex, const int identifier = -1, 
                    const cell_iterator cell = 0 ) :
    base_type( point, identifier ),
    _cells()
  {
    if ( cell != 0 ) {
      add_cell( cell );
    }
  }

  void
  build( const vertex_type& point, const int identifier = -1, 
         const cell_iterator cell = 0 )
  {
    base_type::build( point, identifier );
    _cells.clear();
    if ( cell != 0 ) {
      add_cell( cell );
    }
  }
#endif

  Node_AllIncCells( const Node_AllIncCells& x ) :
    base_type( x ),
    _cells( x._cells )
  {}

  ~Node_AllIncCells()
  {}

  //--------------------------------------------------------------------------
      
  Node_AllIncCells& 
  operator=( const Node_AllIncCells& x )
  {
    if ( &x != this ) {
      base_type::operator=( x );
      _cells = x._cells;
    }
    return *this;
  }

  //--------------------------------------------------------------------------

  const vertex_type&
  vertex() const
  { 
    return base_type::vertex();
  }


  int
  identifier() const
  {
    return base_type::identifier();
  }

  node_const_iterator
  self() const
  { 
    return base_type::self();
  }

  cell_const_iterator
  cell() const
  {
    // If there are no incident cells.
    if ( _cells.empty() ) {
      // Return a null iterator.
      return cell_const_iterator( 0 );
    }
    // Return the first adjacent cell in the container.
    return _cells.front();
  }

  int
  cells_size() const
  {
    return int(_cells.size());
  }

  cell_inc_to_node_const_iterator
  cells_begin() const
  {
    return cell_inc_to_node_const_iterator( _cells.begin() );
  }

  cell_inc_to_node_const_iterator
  cells_end() const
  {
    return cell_inc_to_node_const_iterator( _cells.end() );
  }

  cell_iter_const_iterator
  cell_iters_begin() const
  {
    return _cells.begin();
  }

  cell_iter_const_iterator
  cell_iters_end() const
  {
    return _cells.end();
  }


  bool
  is_on_boundary() const
  {
    // For each simplex incident to this vertex.
    for ( typename cell_iterator_container::const_iterator cii = 
            _cells.begin();
          cii != _cells.end(); ++cii ) {
      // If this cell has a face incident to this vertex and on the boundary.
      if ( (*cii)->has_incident_boundary_face( self() ) ) {
        // This vertex is on the boundary.
        return true;
      }
    }
    // We did not encounter any incident boundary faces.
    return false;
  }


  //--------------------------------------------------------------------------

  void
  set_vertex( const vertex_type& vertex )
  { 
    base_type::set_vertex( vertex );
  }


  void
  set_identifier( const int identifier ) const
  { 
    base_type::set_identifier( identifier );
  }

  node_iterator
  self()
  { 
    return base_type::self();
  }

  void
  set_self( const node_iterator self )
  { 
    base_type::set_self( self );
  }

  cell_iterator
  cell()
  { 
    // If there are no incident cells.
    if ( _cells.empty() ) {
      // Return a null iterator.
      return cell_iterator( 0 );
    }
    // Return the first adjacent cell in the container.
    return _cells.front();
  }


  void
  add_cell( const cell_iterator c )
  {
    // The cell iterator should not be null.
#ifdef DEBUG_Node_AllIncCells
    assert( c != 0 );
#endif    
    _cells.push_back( c );
  }

  template <typename CellIterInIter>
  void
  add_cells( CellIterInIter begin, CellIterInIter end )
  {
    for ( ; begin != end; ++begin ) {
      add_cell( *begin );
    }
  }

  void
  remove_cell( const cell_iterator c )
  {
    // Find the cell.
    typename cell_iterator_container::iterator i;
    i = std::find( _cells.begin(), _cells.end(), c );
    // The specified cell must be incident to this vertex.
    assert( i != _cells.end() );
    // Remove the incident cell.
    _cells.erase( i );
  }

  cell_inc_to_node_iterator
  cells_begin()
  {
    return cell_inc_to_node_iterator( _cells.begin() );
  }

  cell_inc_to_node_iterator
  cells_end()
  {
    return cell_inc_to_node_iterator( _cells.end() );
  }

  cell_iter_iterator
  cell_iters_begin()
  {
    return _cells.begin();
  }

  cell_iter_iterator
  cell_iters_end()
  {
    return _cells.end();
  }


  void
  replace( node_iterator x )
  {
    // Vertex Index.
    int vi;
    // Loop over the incident cells.
    cell_inc_to_node_iterator i = cells_begin();
    cell_inc_to_node_iterator i_end = cells_end();
    for ( ; i != i_end; ++i ) {
      // The index of this node.
      vi = i->index( self() );
      // Replace this node with the specified one.
      i->set_node( vi, x );
    }
  }

  //--------------------------------------------------------------------------
  
  bool
  operator==( const Node_AllIncCells& x ) const
  {
    return base_type::operator==( x ) && _cells == x._cells;
  }

  bool
  operator!=( const Node_AllIncCells& x ) const
  {
    return ! operator==( x );
  }

  //--------------------------------------------------------------------------

  void
  put( std::ostream& out ) const
  {
    // Write the point and the vertex identifier.
    base_type::put( out );
    // Write the incident cell identifiers.
    const int i_end = int(_cells.size());
    // CONTINUE REMOVE
    out << " cells = ";
    for ( int i = 0; i != i_end; ++i ) {
      out << " " << _cells[i]->identifier();
    }
    out << "\n";
  }

};

END_NAMESPACE_GEOM

#endif

---