SPAR/AIModule/BWTA/vendors/CGAL/CGAL/Arr_dcel_base.h

Go to the documentation of this file.

// Copyright (c) 2006  Tel-Aviv University (Israel).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org); you may redistribute it under
// the terms of the Q Public License version 1.0.
// See the file LICENSE.QPL distributed with CGAL.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// $URL: svn+ssh://scm.gforge.inria.fr/svn/cgal/branches/CGAL-3.5-branch/Arrangement_on_surface_2/include/CGAL/Arr_dcel_base.h $
// $Id: Arr_dcel_base.h 46826 2008-11-12 08:37:24Z lrineau $
// 
//
// Author(s)     : Ron Wein <wein@post.tau.ac.il>
//                 (based on old version by: Iddo Hanniel and Oren Nechushtan)

#ifndef CGAL_ARR_DCEL_BASE_H
#define CGAL_ARR_DCEL_BASE_H

#include <CGAL/basic.h>
#include <CGAL/Arr_enums.h>
#include <list>
#include <map>
#include <CGAL/N_step_adaptor_derived.h>
#include <CGAL/In_place_list.h>
#include <CGAL/function_objects.h>
#include <CGAL/Iterator_project.h>
#include <CGAL/Arrangement_2/Arrangement_2_iterators.h>

CGAL_BEGIN_NAMESPACE

inline void* _clean_pointer (const void* p)
{
  const size_t  mask = ~1;
  const size_t  val = (reinterpret_cast<size_t>(p) & mask);

  return (reinterpret_cast<void*> (val));
}

inline void* _set_lsb (const void* p)
{
  const size_t  mask = 1;
  const size_t  val = (reinterpret_cast<size_t>(p) | mask);

  return (reinterpret_cast<void*> (val));
}

inline bool _is_lsb_set (const void* p)
{
  const size_t  mask = 1;
  const size_t  val = reinterpret_cast<size_t>(p);

  return ((val & mask) != 0); 
}

template <class Point_> class Arr_vertex_base 
{
public:

  typedef Point_       Point;

  template<typename PNT>
  struct rebind
  {
    typedef Arr_vertex_base<PNT>             other;
  };

protected:

  void       *p_inc;  // An incident halfedge pointing at the vertex,
                      // or the isolated vertex information (in case it is
                      // isolated). The LSB of the pointer indicates whether
                      // the vertex is isolated.
  Point      *p_pt;   // The point associated with the vertex.
  char        pss[2]; // The x and y parameter spaces (condensed in two bytes).

public:

  Arr_vertex_base() :
    p_inc (NULL),
    p_pt (NULL)
  {
    pss[0] = pss[1] = static_cast<char> (CGAL::ARR_INTERIOR);
  }
  
  virtual ~Arr_vertex_base() {}

  bool has_null_point () const
  {
    return (p_pt == NULL);
  }

  const Point& point() const 
  {
    CGAL_assertion (p_pt != NULL);
    return (*p_pt);
  }

  Point& point() 
  { 
    CGAL_assertion (p_pt != NULL);
    return (*p_pt);
  }

  void set_point (Point *p) 
  {
    p_pt = p;
  }

  Arr_parameter_space parameter_space_in_x () const
  {
    return (Arr_parameter_space (pss[0]));
  }

  Arr_parameter_space parameter_space_in_y () const
  {
    return (Arr_parameter_space (pss[1]));
  }

  void set_boundary (Arr_parameter_space ps_x, Arr_parameter_space ps_y)
  {
    pss[0] = static_cast<char> (ps_x);
    pss[1] = static_cast<char> (ps_y);
    return;
  }

  virtual void assign (const Arr_vertex_base<Point>& v)
  {
    p_pt = v.p_pt;
    pss[0] = v.pss[0];
    pss[1] = v.pss[1];
  }
};

template <class X_monotone_curve_> class Arr_halfedge_base 
{
public:

  typedef X_monotone_curve_  X_monotone_curve;

  template<typename XCV>
  struct rebind
  {
    typedef Arr_halfedge_base<XCV>           other;
  };

protected:

  void       *p_opp;   // The opposite halfedge.
  void       *p_prev;  // The previous halfedge in the component boundary.
  void       *p_next;  // The next halfedge in the component boundary.

  void       *p_v;     // The incident vertex (the target of the halfedge).
                       // The LSB of this pointer is used to store the
                       // direction of the halfedge.
  void       *p_comp;  // The component this halfedge belongs to: the incident
                       // face for outer CCBs and the inner CCB information for
                       // inner CCBs. The LSB of the pointer indicates whether
                       // the halfedge lies on the boundary of an inner CCB.
  
  X_monotone_curve *p_cv; // The associated x-monotone curve.

public:

  Arr_halfedge_base() :
    p_opp (NULL),
    p_prev (NULL),
    p_next (NULL),
    p_v (NULL),
    p_comp (NULL),
    p_cv (NULL)
  {}

  virtual ~Arr_halfedge_base()
  {}

  bool has_null_curve () const
  {
    return (p_cv == NULL);
  }

  const X_monotone_curve& curve() const 
  {
    CGAL_precondition (p_cv != NULL);
    return (*p_cv);
  }

  X_monotone_curve& curve () 
  {
    CGAL_precondition (p_cv != NULL);
    return (*p_cv);
  }

  void set_curve (X_monotone_curve* c)
  { 
    p_cv = c;

    // Set the curve for the opposite halfedge as well.
    Arr_halfedge_base<X_monotone_curve>* opp =
      reinterpret_cast<Arr_halfedge_base<X_monotone_curve>* > (p_opp);

    opp->p_cv = c;
  }

  virtual void assign (const Arr_halfedge_base<X_monotone_curve>& he)
  {
    p_cv = he.p_cv;
  }
};

class Arr_face_base
{
public:

  typedef std::list<void*>                      Outer_ccbs_container;
  typedef Outer_ccbs_container::iterator        Outer_ccb_iterator;
  typedef Outer_ccbs_container::const_iterator  Outer_ccb_const_iterator;

  typedef std::list<void*>                      Inner_ccbs_container;
  typedef Inner_ccbs_container::iterator        Inner_ccb_iterator;
  typedef Inner_ccbs_container::const_iterator  Inner_ccb_const_iterator;

  typedef std::list<void*>                      Isolated_vertices_container;
  typedef Isolated_vertices_container::iterator Isolated_vertex_iterator;
  typedef Isolated_vertices_container::const_iterator
                                                Isolated_vertex_const_iterator;

protected:

  enum
  {
    IS_UNBOUNDED = 1,
    IS_FICTITIOUS = 2
  };

  int                          flags;      // Face flags.
  Outer_ccbs_container         outer_ccbs; // The outer CCBs of the faces.
  Inner_ccbs_container         inner_ccbs; // The holes inside the face.
  Isolated_vertices_container  iso_verts;  // The isolated vertices inside
                                           // the face.

public:

  Arr_face_base() :
    flags (0)
  {}

  virtual ~Arr_face_base()
  {}

  bool is_unbounded () const
  {
    return ((flags & IS_UNBOUNDED) != 0);
  }

  void set_unbounded (bool unbounded)
  {
    flags = (unbounded) ? (flags | IS_UNBOUNDED) : (flags & ~IS_UNBOUNDED);
  }

  bool is_fictitious () const
  {
    return ((flags & IS_FICTITIOUS) != 0);
  }

  void set_fictitious (bool fictitious)
  {
    flags = (fictitious) ? (flags | IS_FICTITIOUS) : (flags & ~IS_FICTITIOUS);
  }

  virtual void assign (const Arr_face_base& f)
  {
    flags = f.flags;
  }
};

// Forward declarations:
template <class V, class H, class F> class Arr_vertex;
template <class V, class H, class F> class Arr_halfedge;
template <class V, class H, class F> class Arr_face;
template <class V, class H, class F> class Arr_outer_ccb;
template <class V, class H, class F> class Arr_inner_ccb;
template <class V, class H, class F> class Arr_isolated_vertex;

template <class V, class H, class F>
class Arr_vertex : public V,
                   public In_place_list_base<Arr_vertex<V,H,F> >
{
public:

  typedef V                           Base;
  typedef Arr_vertex<V,H,F>           Vertex;
  typedef Arr_halfedge<V,H,F>         Halfedge;
  typedef Arr_isolated_vertex<V,H,F>  Isolated_vertex;

  Arr_vertex() 
  {}

  bool is_isolated () const
  {
    // Note that we use the LSB of the p_inc pointer as a Boolean flag.
    return (_is_lsb_set (this->p_inc));
  }

  const Halfedge* halfedge () const
  {
    CGAL_precondition (! is_isolated());
    return (reinterpret_cast<const Halfedge*>(this->p_inc));
  }

  Halfedge* halfedge ()
  {
    CGAL_precondition (! is_isolated());
    return (reinterpret_cast<Halfedge*>(this->p_inc));
  }

  void set_halfedge (Halfedge* he)
  { 
    // Set the halfedge pointer and reset the LSB.
    this->p_inc = he;
  }

  const Isolated_vertex* isolated_vertex () const
  {
    CGAL_precondition (is_isolated());
    return (reinterpret_cast<const Isolated_vertex*>(_clean_pointer 
                                                     (this->p_inc)));
  }

  Isolated_vertex* isolated_vertex ()
  {
    CGAL_precondition (is_isolated());
    return (reinterpret_cast<Isolated_vertex*>(_clean_pointer (this->p_inc)));
  }

  void set_isolated_vertex (Isolated_vertex* iv)
  {
    // Set the isolated vertex-information pointer and set its LSB.
    this->p_inc = _set_lsb (iv);
  }
};

template <class V, class H, class F>
class Arr_halfedge : public H,
                     public In_place_list_base<Arr_halfedge<V,H,F> >
{
public:

  typedef H                     Base;
  typedef Arr_vertex<V,H,F>     Vertex;
  typedef Arr_halfedge<V,H,F>   Halfedge;
  typedef Arr_face<V,H,F>       Face;
  typedef Arr_outer_ccb<V,H,F>  Outer_ccb;
  typedef Arr_inner_ccb<V,H,F>  Inner_ccb;

  Arr_halfedge()
  {}

  const Halfedge* opposite () const
  { 
    return (reinterpret_cast<const Halfedge*>(this->p_opp));
  }
  
  Halfedge* opposite ()
  { 
    return (reinterpret_cast<Halfedge*>(this->p_opp));
  }

  void set_opposite (Halfedge* he) 
  { 
    this->p_opp = he;
  }

  Arr_halfedge_direction direction () const
  {
    // Note that we use the LSB of the p_v pointer as a Boolean flag.
    if (_is_lsb_set (this->p_v))
      return (ARR_LEFT_TO_RIGHT);
    else
      return (ARR_RIGHT_TO_LEFT);
  }

  void set_direction (Arr_halfedge_direction dir)
  {
    Halfedge*   opp = reinterpret_cast<Halfedge*> (this->p_opp);

    if (dir == ARR_LEFT_TO_RIGHT)
    {
      this->p_v = _set_lsb (this->p_v);
      opp->p_v = _clean_pointer (opp->p_v);
    }
    else
    {
      this->p_v = _clean_pointer (this->p_v);
      opp->p_v = _set_lsb (opp->p_v);
    }
  }

  const Halfedge* prev () const
  {
    return (reinterpret_cast<const Halfedge*>(this->p_prev));
  }

  Halfedge* prev ()
  {
    return (reinterpret_cast<Halfedge*>(this->p_prev));
  }

  void set_prev (Halfedge* he)
  {
    this->p_prev = he;
    he->p_next = this;
  }

  const Halfedge* next () const
  {
    return (reinterpret_cast<const Halfedge*>(this->p_next));
  }

  Halfedge* next ()
  {
    return (reinterpret_cast<Halfedge*>(this->p_next));
  }

  void set_next (Halfedge* he)
  {
    this->p_next = he;
    he->p_prev = this;
  }

  const Vertex* vertex () const 
  { 
    return (reinterpret_cast<const Vertex*>(_clean_pointer (this->p_v)));
  }

  Vertex* vertex ()
  { 
    return (reinterpret_cast<Vertex*>(_clean_pointer (this->p_v)));
  }

  void set_vertex (Vertex* v)
  {
    // Set the vertex pointer, preserving the content of the LSB.
    if (_is_lsb_set (this->p_v))
      this->p_v = _set_lsb (v);
    else
      this->p_v = v;
  }

  bool is_on_inner_ccb () const
  {
    return (_is_lsb_set (this->p_comp));
  }

  const Outer_ccb* outer_ccb () const
  {
    CGAL_precondition (! is_on_inner_ccb());
    return (reinterpret_cast<const Outer_ccb*>(this->p_comp));
  }

  Outer_ccb* outer_ccb ()
  {
    CGAL_precondition (! is_on_inner_ccb());
    return (reinterpret_cast<Outer_ccb*>(this->p_comp));
  }

  void set_outer_ccb (Outer_ccb *oc)
  { 
    // Set the component pointer and reset its LSB.
    this->p_comp = oc;
  }

  const Inner_ccb* inner_ccb () const 
  {     
    CGAL_precondition (is_on_inner_ccb());
    return (reinterpret_cast<const Inner_ccb*>(_clean_pointer (this->p_comp)));
  }

  Inner_ccb* inner_ccb () 
  {
    CGAL_precondition (is_on_inner_ccb());
    return (reinterpret_cast<Inner_ccb*> (_clean_pointer (this->p_comp)));
  }

  void set_inner_ccb (Inner_ccb *ic)
  { 
    // Set the component pointer and set its LSB.
    this->p_comp = _set_lsb (ic);
  }
};

template <class V, class H, class F>
class Arr_face : public F,
                 public In_place_list_base<Arr_face<V,H,F> >
{
public:

  typedef F                            Base;
  typedef Arr_vertex<V,H,F>            Vertex;
  typedef Arr_halfedge<V,H,F>          Halfedge;
  typedef Arr_face<V,H,F>              Face;
  typedef Arr_outer_ccb<V,H,F>         Outer_ccb;
  typedef Arr_inner_ccb<V,H,F>         Inner_ccb;
  typedef Arr_isolated_vertex<V,H,F>   Isolated_vertex;

private:

  typedef Cast_function_object<void*,
                               Halfedge*>        _Ccb_to_halfedge_cast;
  typedef Cast_function_object<const void*,
                               const Halfedge*>  _Const_ccb_to_halfedge_cast;


public:

  Arr_face()
  {}

  // Definition of the outer CCB iterators:
  typedef Iterator_project<typename F::Outer_ccb_iterator, 
                           _Ccb_to_halfedge_cast>   Outer_ccb_iterator;

  typedef Iterator_project<typename F::Outer_ccb_const_iterator,
                           _Const_ccb_to_halfedge_cast> 
                                                    Outer_ccb_const_iterator;

  size_t number_of_outer_ccbs () const
  {
    return (this->outer_ccbs.size());
  }

  Outer_ccb_iterator outer_ccbs_begin()
  {
    return (this->outer_ccbs.begin());
  }

  Outer_ccb_iterator outer_ccbs_end()
  {
    return (this->outer_ccbs.end());
  }

  Outer_ccb_const_iterator outer_ccbs_begin() const
  {
    return (this->outer_ccbs.begin());
  }

  Outer_ccb_const_iterator outer_ccbs_end() const
  {
    return (this->outer_ccbs.end());
  }

  void add_outer_ccb (Outer_ccb *oc, Halfedge *h)
  {
    oc->set_iterator (this->outer_ccbs.insert (this->outer_ccbs.end(), h));
    return;
  }

  void erase_outer_ccb (Outer_ccb *oc)
  {
    this->outer_ccbs.erase (oc->iterator().current_iterator());
  }

  // Definition of the inner CCB iterators:
  typedef Iterator_project<typename F::Inner_ccb_iterator, 
                           _Ccb_to_halfedge_cast>   Inner_ccb_iterator;

  typedef Iterator_project<typename F::Inner_ccb_const_iterator,
                           _Const_ccb_to_halfedge_cast> 
                                                    Inner_ccb_const_iterator;

  size_t number_of_inner_ccbs () const
  {
    return (this->inner_ccbs.size());
  }

  Inner_ccb_iterator inner_ccbs_begin()
  {
    return (this->inner_ccbs.begin());
  }

  Inner_ccb_iterator inner_ccbs_end()
  {
    return (this->inner_ccbs.end());
  }

  Inner_ccb_const_iterator inner_ccbs_begin() const
  {
    return (this->inner_ccbs.begin());
  }

  Inner_ccb_const_iterator inner_ccbs_end() const
  {
    return (this->inner_ccbs.end());
  }

  void add_inner_ccb (Inner_ccb *ic, Halfedge *h)
  {
    ic->set_iterator (this->inner_ccbs.insert (this->inner_ccbs.end(), h));
    return;
  }

  void erase_inner_ccb (Inner_ccb *ic)
  {
    this->inner_ccbs.erase (ic->iterator().current_iterator());
  }

  // Definition of the isloated vertices iterators:
  typedef I_Dereference_iterator<
    typename F::Isolated_vertex_iterator,
    Vertex,
    typename F::Isolated_vertex_iterator::difference_type,
    typename F::Isolated_vertex_iterator::iterator_category>
                                              Isolated_vertex_iterator;
  
  typedef I_Dereference_const_iterator<
    typename F::Isolated_vertex_const_iterator,
    typename F::Isolated_vertex_iterator,
    Vertex,
    typename F::Isolated_vertex_iterator::difference_type,
    typename F::Isolated_vertex_iterator::iterator_category>
                                              Isolated_vertex_const_iterator;

  size_t number_of_isolated_vertices() const
  {
    return (this->iso_verts.size());
  }

  Isolated_vertex_iterator isolated_vertices_begin()
  {
    return (this->iso_verts.begin());
  }

  Isolated_vertex_iterator isolated_vertices_end()
  {
    return (this->iso_verts.end());
  }

  Isolated_vertex_const_iterator isolated_vertices_begin() const
  {
    return (this->iso_verts.begin());
  }

  Isolated_vertex_const_iterator isolated_vertices_end() const
  {
    return (this->iso_verts.end());
  }

  void add_isolated_vertex (Isolated_vertex *iv, Vertex* v)
  {
    iv->set_iterator (this->iso_verts.insert (this->iso_verts.end(), v));
    return;
  }

  void erase_isolated_vertex (Isolated_vertex *iv)
  {
    this->iso_verts.erase (iv->iterator().current_iterator());
    return;
  }

};

template <class V, class H, class F>
class Arr_outer_ccb : public In_place_list_base<Arr_outer_ccb<V,H,F> >
{
public:

  typedef Arr_outer_ccb<V,H,F>               Self;
  typedef Arr_halfedge<V,H,F>                Halfedge;
  typedef Arr_face<V,H,F>                    Face;
  typedef typename Face::Outer_ccb_iterator  Outer_ccb_iterator;

private:

  Face               *p_f;    // The face the contains the CCB in its interior.
  Outer_ccb_iterator  iter;   // The outer CCB identifier.
  bool iter_is_not_singular;

public:

  Arr_outer_ccb () :
    p_f (NULL), iter_is_not_singular(false)
  {}

  Arr_outer_ccb (const Arr_outer_ccb& other )
    : p_f (other.p_f), iter_is_not_singular(other.iter_is_not_singular)
  {
    if(other.iter_is_not_singular) {
      iter = other.iter;
    }
  }

  const Halfedge* halfedge () const
  {
    return (*iter);
  }

  Halfedge* halfedge ()
  {
    return (*iter);
  }

  void set_halfedge (Halfedge *he)
  {
    *iter = he;
    return;
  }

  const Face* face () const
  {
    return (p_f);
  }

  Face* face ()
  {
    return (p_f);
  }

  void set_face (Face* f)
  {
    p_f = f;
    return;
  }

  Outer_ccb_iterator iterator () const
  {
    CGAL_assertion(iter_is_not_singular);
    return (iter);
  }

  Outer_ccb_iterator iterator ()
  {
    CGAL_assertion(iter_is_not_singular);
    return (iter);
  }

  void set_iterator (Outer_ccb_iterator it)
  {
    iter = it;
    iter_is_not_singular = true;
    return;
  }
};

template <class V, class H, class F>
class Arr_inner_ccb : public In_place_list_base<Arr_inner_ccb<V,H,F> >
{
public:

  typedef Arr_inner_ccb<V,H,F>               Self;
  typedef Arr_halfedge<V,H,F>                Halfedge;
  typedef Arr_face<V,H,F>                    Face;
  typedef typename Face::Inner_ccb_iterator  Inner_ccb_iterator;

private:

  Face               *p_f;    // The face the contains the CCB in its interior.
  Inner_ccb_iterator  iter;   // The inner CCB identifier.
  bool iter_is_not_singular;

public:

  Arr_inner_ccb () :
    p_f (NULL), iter_is_not_singular(false)
  {}

  Arr_inner_ccb (const Arr_inner_ccb& other )
    : p_f (other.p_f), iter_is_not_singular(other.iter_is_not_singular)
  {
    if(other.iter_is_not_singular) {
      iter = other.iter;
    }
  }

  const Halfedge* halfedge () const
  {
    return (*iter);
  }

  Halfedge* halfedge ()
  {
    return (*iter);
  }

  void set_halfedge (Halfedge *he)
  {
    *iter = he;
    return;
  }

  const Face* face () const
  {
    return (p_f);
  }

  Face* face ()
  {
    return (p_f);
  }

  void set_face (Face* f)
  {
    p_f = f;
    return;
  }

  Inner_ccb_iterator iterator () const
  {
    CGAL_assertion(iter_is_not_singular);
    return (iter);
  }

  Inner_ccb_iterator iterator ()
  {
    CGAL_assertion(iter_is_not_singular);
    return (iter);
  }

  void set_iterator (Inner_ccb_iterator it)
  {
    iter = it;
    iter_is_not_singular = true;
    return;
  }
};

template <class V, class H, class F>
class Arr_isolated_vertex : 
public In_place_list_base<Arr_isolated_vertex<V,H,F> >
{
public:

  typedef Arr_isolated_vertex<V,H,F>                Self;
  typedef Arr_face<V,H,F>                           Face;
  typedef typename Face::Isolated_vertex_iterator   Isolated_vertex_iterator;

private:

  Face                        *p_f;   // The face containing the hole.
  Isolated_vertex_iterator   iv_it; // The isolated vertex identifier.
  bool iter_is_not_singular;

public:

  Arr_isolated_vertex ():
    p_f (NULL), iter_is_not_singular(false)
  {}

  Arr_isolated_vertex (const Arr_isolated_vertex& other )
    : p_f (other.p_f), iter_is_not_singular(other.iter_is_not_singular)
  {
    if(other.iter_is_not_singular) {
      iv_it = other.iv_it;
    }
  }

  const Face* face () const
  {
    return (p_f);
  }

  Face* face ()
  {
    return (p_f);
  }

  void set_face (Face* f)
  {
    p_f = f;
    return;
  }

  Isolated_vertex_iterator iterator () const
  {
    CGAL_assertion(iter_is_not_singular);
    return (iv_it);
  }

  Isolated_vertex_iterator iterator ()
  {
    CGAL_assertion(iter_is_not_singular);
    return (iv_it);
  }

  void set_iterator (Isolated_vertex_iterator iv)
  {
    iv_it = iv;
    iter_is_not_singular = true;
    return;
  }
};

template <class V, class H, class F,
          class Allocator = CGAL_ALLOCATOR(int) >
class Arr_dcel_base
{
public:

  // Define the vertex, halfedge and face types.
  typedef Arr_dcel_base<V,H,F>        Self;
  typedef Arr_vertex<V,H,F>           Vertex;
  typedef Arr_halfedge<V,H,F>         Halfedge;
  typedef Arr_face<V,H,F>             Face;
  typedef Arr_outer_ccb<V,H,F>        Outer_ccb;
  typedef Arr_inner_ccb<V,H,F>        Inner_ccb;
  typedef Arr_isolated_vertex<V,H,F>  Isolated_vertex;

protected:

  // The vetices, halfedges and faces are stored in three in-place lists.
  typedef In_place_list<Vertex, false>           Vertex_list;
  typedef In_place_list<Halfedge, false>         Halfedge_list;
  typedef In_place_list<Face, false>             Face_list;
  typedef In_place_list<Outer_ccb, false>        Outer_ccb_list;
  typedef In_place_list<Inner_ccb, false>        Inner_ccb_list;
  typedef In_place_list<Isolated_vertex, false>  Iso_vert_list;

  // Vertex allocator.
  typedef typename Allocator::template rebind<Vertex>    Vertex_alloc_rebind;
  typedef typename Vertex_alloc_rebind::other            Vertex_allocator;

  // Halfedge allocator.
  typedef typename Allocator::template rebind<Halfedge>  Halfedge_alloc_rebind;
  typedef typename Halfedge_alloc_rebind::other          Halfedge_allocator;

  // Face allocator.
  typedef typename Allocator::template rebind<Face>      Face_alloc_rebind;
  typedef typename Face_alloc_rebind::other              Face_allocator;
  
  // Outer CCB allocator.
  typedef typename Allocator::template rebind<Outer_ccb> Out_ccb_alloc_rebind;
  typedef typename Out_ccb_alloc_rebind::other           Outer_ccb_allocator;

  // Inner CCB allocator.
  typedef typename Allocator::template rebind<Inner_ccb> In_ccb_alloc_rebind;
  typedef typename In_ccb_alloc_rebind::other            Inner_ccb_allocator;

  // Isolated vertex allocator.
  typedef typename Allocator::template rebind<Isolated_vertex>
                                                         Iso_vert_alloc_rebind;
  typedef typename Iso_vert_alloc_rebind::other          Iso_vert_allocator;

public:

  typedef typename Halfedge_list::size_type              Size;
  typedef typename Halfedge_list::size_type              size_type;
  typedef typename Halfedge_list::difference_type        difference_type;
  typedef typename Halfedge_list::difference_type        Difference;
  typedef std::bidirectional_iterator_tag                iterator_category;

protected:

  Vertex_list         vertices;             // The vertices container.
  Halfedge_list       halfedges;            // The halfedges container.
  Face_list           faces;                // The faces container.
  Outer_ccb_list      out_ccbs;             // The outer CCBs.
  Inner_ccb_list      in_ccbs;              // The inner CCBs.
  Iso_vert_list       iso_verts;            // The isolated vertices.

  Vertex_allocator    vertex_alloc;         // An allocator for vertices.
  Halfedge_allocator  halfedge_alloc;       // An allocator for halfedges.
  Face_allocator      face_alloc;           // An allocator for faces.
  Outer_ccb_allocator out_ccb_alloc;        // An allocator for outer CCBs.
  Inner_ccb_allocator in_ccb_alloc;         // An allocator for inner CCBs.
  Iso_vert_allocator  iso_vert_alloc;       // Allocator for isolated vertices.

public:

  // Definitions of iterators.
  typedef typename Vertex_list::iterator              Vertex_iterator;
  typedef typename Halfedge_list::iterator            Halfedge_iterator;
  typedef typename Face_list::iterator                Face_iterator;
  typedef CGAL::N_step_adaptor_derived<Halfedge_iterator, 2>
                                                      Edge_iterator;
  
  // Definitions of const iterators.
  typedef typename Vertex_list::const_iterator        Vertex_const_iterator;
  typedef typename Halfedge_list::const_iterator      Halfedge_const_iterator;
  typedef typename Face_list::const_iterator          Face_const_iterator;
  typedef CGAL::N_step_adaptor_derived<Halfedge_const_iterator, 2>
                                                      Edge_const_iterator;

private:

  // Copy constructor - not supported.
  Arr_dcel_base (const Self&) ;

  // Assignment operator - not supported.
  Self& operator= (const Self&);

public:



  Arr_dcel_base ()
  {}
  
  ~Arr_dcel_base ()
  {
    delete_all();
  }



  Size size_of_vertices () const
  { 
    return (vertices.size());
  }

  Size size_of_halfedges () const
  {
    return (halfedges.size());
  }

  Size size_of_faces() const
  {
    return (faces.size());
  }

  Size size_of_outer_ccbs() const
  {
    return (out_ccbs.size());
  }

  Size size_of_inner_ccbs() const
  {
    return (in_ccbs.size());
  }

  Size size_of_isolated_vertices () const
  {
    return (iso_verts.size());
  }


  Vertex_iterator   vertices_begin()  { return vertices.begin(); }
  Vertex_iterator   vertices_end()    { return vertices.end(); }
  Halfedge_iterator halfedges_begin() { return halfedges.begin();}
  Halfedge_iterator halfedges_end()   { return halfedges.end(); }
  Face_iterator     faces_begin()     { return faces.begin(); }
  Face_iterator     faces_end()       { return faces.end(); }
  Edge_iterator     edges_begin()     { return halfedges.begin(); }  
  Edge_iterator     edges_end()       { return halfedges.end(); }  


  Vertex_const_iterator   vertices_begin() const { return vertices.begin(); }
  Vertex_const_iterator   vertices_end() const { return vertices.end(); }
  Halfedge_const_iterator halfedges_begin() const { return halfedges.begin(); }
  Halfedge_const_iterator halfedges_end() const { return halfedges.end(); }
  Face_const_iterator     faces_begin() const { return faces.begin(); }
  Face_const_iterator     faces_end() const { return faces.end(); }
  Edge_const_iterator     edges_begin() const { return halfedges.begin(); }  
  Edge_const_iterator     edges_end() const { return halfedges.end(); }  

  // \name Creation of new DCEL features.

  Vertex* new_vertex()
  {
    Vertex     *v = vertex_alloc.allocate (1);

    vertex_alloc.construct (v, Vertex());
    vertices.push_back (*v);
    return v;
  }
  
  Halfedge* new_edge() 
  {
    // Create two new halfedges.
    Halfedge   *h1 = _new_halfedge ();
    Halfedge   *h2 = _new_halfedge ();

    // Pair them together.
    h1->set_opposite (h2);
    h2->set_opposite (h1);

    return (h1);
  }

  Face* new_face()
  {
    Face       *f = face_alloc.allocate (1);
    
    face_alloc.construct (f, Face());
    faces.push_back (*f);
    return (f);
  }

  Outer_ccb* new_outer_ccb ()
  {
    Outer_ccb  *oc = out_ccb_alloc.allocate (1);
    out_ccb_alloc.construct (oc, Outer_ccb());
    out_ccbs.push_back (*oc);
    return (oc);
  }

  Inner_ccb* new_inner_ccb ()
  {
    Inner_ccb  *ic = in_ccb_alloc.allocate (1);
    
    in_ccb_alloc.construct (ic, Inner_ccb());
    in_ccbs.push_back (*ic);
    return (ic);
  }

  Isolated_vertex* new_isolated_vertex ()
  {
    Isolated_vertex  *iv = iso_vert_alloc.allocate (1);
    
    iso_vert_alloc.construct (iv, Isolated_vertex());
    iso_verts.push_back (*iv);
    return (iv);
  }



  void delete_vertex (Vertex *v)
  {
    vertices.erase (v);
    vertex_alloc.destroy (v);
    vertex_alloc.deallocate (v,1);
  }
  
  void delete_edge (Halfedge *h) 
  {
    Halfedge   *h_opp = h->opposite();

    _delete_halfedge (h);
    _delete_halfedge (h_opp);
  }

  void delete_face(Face *f)
  {
    faces.erase (f);
    face_alloc.destroy (f);
    face_alloc.deallocate (f, 1);
  }

  void delete_outer_ccb (Outer_ccb *oc)
  {
    out_ccbs.erase (oc);
    out_ccb_alloc.destroy (oc);
    out_ccb_alloc.deallocate (oc, 1);
  }

  void delete_inner_ccb (Inner_ccb *ic)
  {
    in_ccbs.erase (ic);
    in_ccb_alloc.destroy (ic);
    in_ccb_alloc.deallocate (ic, 1);
  }

  void delete_isolated_vertex (Isolated_vertex *iv)
  {
    iso_verts.erase (iv);
    iso_vert_alloc.destroy (iv);
    iso_vert_alloc.deallocate (iv, 1);
  }
  
  void delete_all() 
  {
    // Free all vertices.
    Vertex_iterator    vit = vertices.begin(), v_curr;

    while (vit != vertices.end())
    {
      v_curr = vit;
      ++vit;
      delete_vertex (&(*v_curr));
    }

    // Free all halfedges.
    Halfedge_iterator  hit = halfedges.begin(), h_curr;

    while (hit != halfedges.end())
    {
      h_curr = hit;
      ++hit;
      _delete_halfedge (&(*h_curr));
    }

    // Free all faces.
    Face_iterator      fit = faces.begin(), f_curr;

    while (fit != faces.end())
    {
      f_curr = fit;
      ++fit;
      delete_face (&(*f_curr));
    }

    // Free all outer CCBs.
    typename Outer_ccb_list::iterator   ocit = out_ccbs.begin(), oc_curr;

    while (ocit != out_ccbs.end())
    {
      oc_curr = ocit;
      ++ocit;
      delete_outer_ccb (&(*oc_curr));
    }

    // Free all inner CCBs.
    typename Inner_ccb_list::iterator   icit = in_ccbs.begin(), ic_curr;

    while (icit != in_ccbs.end())
    {
      ic_curr = icit;
      ++icit;
      delete_inner_ccb (&(*ic_curr));
    }

    // Free all isolated vertices.
    typename Iso_vert_list::iterator   ivit = iso_verts.begin(), iv_curr;

    while (ivit != iso_verts.end())
    {
      iv_curr = ivit;
      ++ivit;
      delete_isolated_vertex (&(*iv_curr));
    }
  }

  void assign (const Self& dcel)
  {
    // Clear the current contents of the DCEL.
    delete_all();

    // Create duplicated of the DCEL features and map the features of the
    // given DCEL to their corresponding duplicates.
    typedef std::map<const Vertex*, Vertex*>                    Vertex_map;
    typedef std::map<const Halfedge*, Halfedge*>                Halfedge_map;
    typedef std::map<const Face*, Face*>                        Face_map;
    typedef std::map<const Outer_ccb*, Outer_ccb*>              Outer_ccb_map;
    typedef std::map<const Inner_ccb*, Inner_ccb*>              Inner_ccb_map;
    typedef std::map<const Isolated_vertex*, Isolated_vertex*>  Iso_vert_map;

    Vertex_map                v_map;
    Vertex_const_iterator     vit;
    Vertex                   *dup_v;

    for (vit = dcel.vertices_begin(); vit != dcel.vertices_end(); ++vit)
    {
      dup_v = new_vertex();
      dup_v->assign (*vit);
      v_map.insert (typename Vertex_map::value_type (&(*vit), dup_v));
    }

    Halfedge_map              he_map;
    Halfedge_const_iterator   hit;
    Halfedge                 *dup_h;

    for (hit = dcel.halfedges_begin(); hit != dcel.halfedges_end(); ++hit)
    {
      dup_h = _new_halfedge();
      dup_h->assign (*hit);
      he_map.insert (typename Halfedge_map::value_type(&(*hit), dup_h));
    }

    Face_map                  f_map;
    Face_const_iterator       fit;
    Face                     *dup_f;

    for (fit = dcel.faces_begin(); fit != dcel.faces_end(); ++fit)
    {
      dup_f = new_face();
      dup_f->assign (*fit);
      f_map.insert (typename Face_map::value_type(&(*fit), dup_f));
    }

    Outer_ccb_map                            oc_map;
    typename Outer_ccb_list::const_iterator  ocit;
    Outer_ccb                               *dup_oc;

    for (ocit = dcel.out_ccbs.begin(); ocit != dcel.out_ccbs.end(); ++ocit)
    {
      dup_oc = new_outer_ccb();
      oc_map.insert (typename Outer_ccb_map::value_type(&(*ocit), dup_oc));
    }

    Inner_ccb_map                            ic_map;
    typename Inner_ccb_list::const_iterator  icit;
    Inner_ccb                               *dup_ic;

    for (icit = dcel.in_ccbs.begin(); icit != dcel.in_ccbs.end(); ++icit)
    {
      dup_ic = new_inner_ccb();
      ic_map.insert (typename Inner_ccb_map::value_type(&(*icit), dup_ic));
    }

    Iso_vert_map                            iv_map;
    typename Iso_vert_list::const_iterator  ivit;
    Isolated_vertex                        *dup_iv;

    for (ivit = dcel.iso_verts.begin(); ivit != dcel.iso_verts.end(); ++ivit)
    {
      dup_iv = new_isolated_vertex();
      iv_map.insert (typename Iso_vert_map::value_type(&(*ivit), dup_iv));
    }

    // Update the vertex records.
    const Vertex             *v;
    const Halfedge           *h;
    const Face               *f;
    const Outer_ccb          *oc;
    const Inner_ccb          *ic;
    const Isolated_vertex    *iv;
    
    for (vit = dcel.vertices_begin(); vit != dcel.vertices_end(); ++vit)
    {
      v = &(*vit);
      dup_v = (v_map.find (v))->second;

      if (v->is_isolated())
      {
        // Isolated vertex - set its information.
        iv = v->isolated_vertex();
        dup_iv = (iv_map.find (iv))->second;

        dup_v->set_isolated_vertex (dup_iv);
      }
      else
      {
        // Regular vertex - set its incident halfedge.
        h = v->halfedge();
        dup_h = (he_map.find (h))->second;

        dup_v->set_halfedge (dup_h);
      }
    }

    // Update the halfedge records.
    const Halfedge           *opp, *prev, *next;
    Halfedge                 *dup_opp, *dup_prev, *dup_next;

    for (hit = dcel.halfedges_begin(); hit != dcel.halfedges_end(); ++hit)
    {
      h = &(*hit);
      v = h->vertex();
      opp = h->opposite();
      prev = h->prev();
      next = h->next();

      dup_h = (he_map.find (h))->second;
      dup_v = (v_map.find (v))->second;
      dup_opp = (he_map.find (opp))->second;
      dup_prev = (he_map.find (prev))->second;
      dup_next = (he_map.find (next))->second;

      dup_h->set_vertex (dup_v);
      dup_h->set_opposite (dup_opp);
      dup_h->set_prev (dup_prev);
      dup_h->set_next (dup_next);
      dup_h->set_direction (h->direction());

      if (h->is_on_inner_ccb())
      {
        // The halfedge lies on an inner CCB - set its inner CCB record.
        ic = h->inner_ccb();
        dup_ic = (ic_map.find (ic))->second;
        dup_h->set_inner_ccb (dup_ic);
      }
      else
      {
        // The halfedge lies on an outer CCB - set its outer CCB record.
        oc = h->outer_ccb();
        dup_oc = (oc_map.find (oc))->second;
        dup_h->set_outer_ccb (dup_oc);
      }
    }

    // Update the face records, along with the CCB records and isolated vertex
    // records.
    typename Face::Outer_ccb_const_iterator        out_ccb_it;
    typename Face::Inner_ccb_const_iterator        in_ccb_it;
    typename Face::Isolated_vertex_const_iterator  iso_vert_it;
    const Halfedge                      *hccb;
    const Vertex                        *iso_vert;
    Halfedge                            *dup_hccb;
    Vertex                              *dup_iso_vert;

    for (fit = dcel.faces_begin(); fit != dcel.faces_end(); ++fit)
    {
      f = &(*fit);
      dup_f = (f_map.find (f))->second;
      dup_f->set_unbounded (f->is_unbounded());
      dup_f->set_fictitious (f->is_fictitious());

      // Assign the outer CCBs of the face.
      for (out_ccb_it = f->outer_ccbs_begin();
           out_ccb_it != f->outer_ccbs_end(); ++out_ccb_it)
      {
        hccb = *out_ccb_it;

        dup_hccb = (he_map.find (hccb))->second;
        dup_oc = dup_hccb->outer_ccb();

        dup_oc->set_face (dup_f);
        dup_f->add_outer_ccb (dup_oc, dup_hccb);
      }

      // Assign the inner CCBs of the face.
      for (in_ccb_it = f->inner_ccbs_begin();
           in_ccb_it != f->inner_ccbs_end(); ++in_ccb_it)
      {
        hccb = *in_ccb_it;

        dup_hccb = (he_map.find (hccb))->second;
        dup_ic = dup_hccb->inner_ccb();

        dup_ic->set_face (dup_f);
        dup_f->add_inner_ccb (dup_ic, dup_hccb);
      }

      // Assign the isolated vertices.
      for (iso_vert_it = f->isolated_vertices_begin();
           iso_vert_it != f->isolated_vertices_end(); ++iso_vert_it)
      {
        iso_vert = &(*iso_vert_it);

        dup_iso_vert = (v_map.find (iso_vert))->second;
        dup_iv = dup_iso_vert->isolated_vertex();

        dup_iv->set_face (dup_f);
        dup_f->add_isolated_vertex (dup_iv, dup_iso_vert);
      }
    }

    return;
  }

protected:

  Halfedge * _new_halfedge ()
  {
    Halfedge   *h = halfedge_alloc.allocate (1);

    halfedge_alloc.construct (h, Halfedge());
    halfedges.push_back (*h);
    return (h);
  }

  void _delete_halfedge (Halfedge* h)
  {
    halfedges.erase (h);
    halfedge_alloc.destroy (h);
    halfedge_alloc.deallocate (h, 1);
  }
};

CGAL_END_NAMESPACE

#endif