Node_OneIncCell.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__geom_mesh_simplicial_Node_OneIncCell_h__)
#define __geom_mesh_simplicial_Node_OneIncCell_h__

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

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

#include "Node_VertSelfId.h"

BEGIN_NAMESPACE_GEOM


template <class Mesh>
class Node_OneIncCell :
  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;

  //
  // Data
  //
      
private:
      
  cell_iterator _cell;

public:

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

  Node_OneIncCell() :
    base_type(),
    _cell( 0 )
  {}

  Node_OneIncCell( const vertex_type& point, const int identifier = -1,
                   const cell_iterator cell = 0 ) :
    base_type( point, identifier ),
    _cell( cell )
  {}

  void
  build( const vertex_type& point, const int identifier = -1, 
         const cell_iterator cell = 0 )
  {
    base_type::build( point, identifier );
    _cell = cell;
  }

  Node_OneIncCell( const Node_OneIncCell& x ) :
    base_type( x ),
    _cell( x._cell )
  {}

  ~Node_OneIncCell()
  {}

  //--------------------------------------------------------------------------
      
  Node_OneIncCell& 
  operator=( const Node_OneIncCell& x )
  {
    if ( &x != this ) {
      base_type::operator=( x );
      _cell = x._cell;
    }
    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
  { 
    return _cell;
  }

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

  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 v )
  { 
    base_type::set_self( v );
  }

  cell_iterator
  cell()
  { 
    return _cell;
  }

  void
  add_cell( const cell_iterator c )
  { 
    _cell = c;
  }

  void
  remove_cell( const cell_iterator c )
  { 
    // Look for another adjacent cell.
    // CONTINUE;
    assert( false );
  }

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

  bool
  operator!=( const Node_OneIncCell& 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 identifier.
    out << " " << _cell->identifier();
  }

};

END_NAMESPACE_GEOM

#endif

---