PolyConnectivity.hh

/* ========================================================================= *
 *                                                                           *
 *                               OpenMesh                                    *
 *           Copyright (c) 2001-2015, RWTH-Aachen University                 *
 *           Department of Computer Graphics and Multimedia                  *
 *                          All rights reserved.                             *
 *                            www.openmesh.org                               *
 *                                                                           *
 *---------------------------------------------------------------------------*
 * This file is part of OpenMesh.                                            *
 *---------------------------------------------------------------------------*
 *                                                                           *
 * Redistribution and use in source and binary forms, with or without        *
 * modification, are permitted provided that the following conditions        *
 * are met:                                                                  *
 *                                                                           *
 * 1. Redistributions of source code must retain the above copyright notice, *
 *    this list of conditions and the following disclaimer.                  *
 *                                                                           *
 * 2. Redistributions in binary form must reproduce the above copyright      *
 *    notice, this list of conditions and the following disclaimer in the    *
 *    documentation and/or other materials provided with the distribution.   *
 *                                                                           *
 * 3. Neither the name of the copyright holder nor the names of its          *
 *    contributors may be used to endorse or promote products derived from   *
 *    this software without specific prior written permission.               *
 *                                                                           *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS       *
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A           *
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,  *
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,       *
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR        *
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF    *
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING      *
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS        *
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.              *
 *                                                                           *
 * ========================================================================= */

/*===========================================================================*\
 *                                                                           *             
 *   $Revision$                                                         *
 *   $Date$                   *
 *                                                                           *
\*===========================================================================*/

#ifndef OPENMESH_POLYCONNECTIVITY_HH
#define OPENMESH_POLYCONNECTIVITY_HH

#include <OpenMesh/Core/Mesh/ArrayKernel.hh>
#include <OpenMesh/Core/Mesh/IteratorsT.hh>
#include <OpenMesh/Core/Mesh/CirculatorsT.hh>

namespace OpenMesh
{

class OPENMESHDLLEXPORT PolyConnectivity : public ArrayKernel
{
public:

  static const VertexHandle                           InvalidVertexHandle;
  static const HalfedgeHandle                         InvalidHalfedgeHandle;
  static const EdgeHandle                             InvalidEdgeHandle;
  static const FaceHandle                             InvalidFaceHandle;

  typedef PolyConnectivity                            This;

  //--- iterators ---

  typedef Iterators::GenericIteratorT<This, This::VertexHandle, ArrayKernel , &ArrayKernel::has_vertex_status, &ArrayKernel::n_vertices> VertexIter;
  typedef Iterators::GenericIteratorT<This, This::HalfedgeHandle, ArrayKernel , &ArrayKernel::has_halfedge_status, &ArrayKernel::n_halfedges> HalfedgeIter;
  typedef Iterators::GenericIteratorT<This, This::EdgeHandle, ArrayKernel , &ArrayKernel::has_edge_status, &ArrayKernel::n_edges> EdgeIter;
  typedef Iterators::GenericIteratorT<This, This::FaceHandle, ArrayKernel , &ArrayKernel::has_face_status, &ArrayKernel::n_faces> FaceIter;

  typedef VertexIter ConstVertexIter;
  typedef HalfedgeIter ConstHalfedgeIter;
  typedef EdgeIter ConstEdgeIter;
  typedef FaceIter ConstFaceIter;

  //--- circulators ---


  /*
   * Vertex-centered circulators
   */

  typedef Iterators::GenericCirculatorT_DEPRECATED<This,  This::VertexHandle,  This::VertexHandle,
          &Iterators::GenericCirculatorBaseT<This>::toVertexHandle>
  VertexVertexIter;
  typedef Iterators::GenericCirculatorT<This,  This::VertexHandle,  This::VertexHandle,
            &Iterators::GenericCirculatorBaseT<This>::toVertexHandle> VertexVertexCWIter;

  typedef Iterators::GenericCirculatorT<This,  This::VertexHandle,  This::VertexHandle,
          &Iterators::GenericCirculatorBaseT<This>::toVertexHandle, false>
  VertexVertexCCWIter;

  typedef Iterators::GenericCirculatorT_DEPRECATED<This,  This::VertexHandle,  This::HalfedgeHandle,
          &Iterators::GenericCirculatorBaseT<This>::toHalfedgeHandle>
  VertexOHalfedgeIter;
  typedef Iterators::GenericCirculatorT<This,  This::VertexHandle,  This::HalfedgeHandle,
      &Iterators::GenericCirculatorBaseT<This>::toHalfedgeHandle> VertexOHalfedgeCWIter;

  typedef Iterators::GenericCirculatorT<This,  This::VertexHandle,  This::HalfedgeHandle,
      &Iterators::GenericCirculatorBaseT<This>::toHalfedgeHandle, false>
  VertexOHalfedgeCCWIter;

  typedef Iterators::GenericCirculatorT_DEPRECATED<This,  This::VertexHandle,  This::HalfedgeHandle,
          &Iterators::GenericCirculatorBaseT<This>::toOppositeHalfedgeHandle>
  VertexIHalfedgeIter;
  typedef Iterators::GenericCirculatorT<This,  This::VertexHandle,  This::HalfedgeHandle,
      &Iterators::GenericCirculatorBaseT<This>::toOppositeHalfedgeHandle> VertexIHalfedgeCWIter;

  typedef Iterators::GenericCirculatorT<This,  This::VertexHandle,  This::HalfedgeHandle,
          &Iterators::GenericCirculatorBaseT<This>::toOppositeHalfedgeHandle, false>
  VertexIHalfedgeCCWIter;

  typedef Iterators::GenericCirculatorT_DEPRECATED<This,  This::VertexHandle,  This::FaceHandle,
          &Iterators::GenericCirculatorBaseT<This>::toFaceHandle>
  VertexFaceIter;
  typedef Iterators::GenericCirculatorT<This,  This::VertexHandle,  This::FaceHandle,
      &Iterators::GenericCirculatorBaseT<This>::toFaceHandle> VertexFaceCWIter;

  typedef Iterators::GenericCirculatorT<This,  This::VertexHandle,  This::FaceHandle,
          &Iterators::GenericCirculatorBaseT<This>::toFaceHandle, false>
  VertexFaceCCWIter;

  typedef Iterators::GenericCirculatorT_DEPRECATED<This,  This::VertexHandle,  This::EdgeHandle,
          &Iterators::GenericCirculatorBaseT<This>::toEdgeHandle>
  VertexEdgeIter;
  typedef Iterators::GenericCirculatorT<This,  This::VertexHandle,  This::EdgeHandle,
      &Iterators::GenericCirculatorBaseT<This>::toEdgeHandle> VertexEdgeCWIter;
  typedef Iterators::GenericCirculatorT<This,  This::VertexHandle,  This::EdgeHandle,
          &Iterators::GenericCirculatorBaseT<This>::toEdgeHandle, false>
  VertexEdgeCCWIter;

  typedef Iterators::GenericCirculatorT_DEPRECATED<This, This::FaceHandle, This::HalfedgeHandle,
      &Iterators::GenericCirculatorBaseT<This>::toHalfedgeHandle>
  HalfedgeLoopIter;
  typedef Iterators::GenericCirculatorT<This, This::FaceHandle, This::HalfedgeHandle,
      &Iterators::GenericCirculatorBaseT<This>::toHalfedgeHandle> HalfedgeLoopCWIter;
  typedef Iterators::GenericCirculatorT<This, This::FaceHandle, This::HalfedgeHandle,
      &Iterators::GenericCirculatorBaseT<This>::toHalfedgeHandle, false>
  HalfedgeLoopCCWIter;

  typedef VertexVertexIter        ConstVertexVertexIter;
  typedef VertexVertexCWIter      ConstVertexVertexCWIter;
  typedef VertexVertexCCWIter     ConstVertexVertexCCWIter;
  typedef VertexOHalfedgeIter     ConstVertexOHalfedgeIter;
  typedef VertexOHalfedgeCWIter   ConstVertexOHalfedgeCWIter;
  typedef VertexOHalfedgeCCWIter  ConstVertexOHalfedgeCCWIter;
  typedef VertexIHalfedgeIter     ConstVertexIHalfedgeIter;
  typedef VertexIHalfedgeCWIter   ConstVertexIHalfedgeCWIter;
  typedef VertexIHalfedgeCCWIter  ConstVertexIHalfedgeCCWIter;
  typedef VertexFaceIter          ConstVertexFaceIter;
  typedef VertexFaceCWIter        ConstVertexFaceCWIter;
  typedef VertexFaceCCWIter       ConstVertexFaceCCWIter;
  typedef VertexEdgeIter          ConstVertexEdgeIter;
  typedef VertexEdgeCWIter        ConstVertexEdgeCWIter;
  typedef VertexEdgeCCWIter       ConstVertexEdgeCCWIter;

  /*
   * Face-centered circulators
   */

  typedef Iterators::GenericCirculatorT_DEPRECATED<This,  This::FaceHandle,  This::VertexHandle,
          &Iterators::GenericCirculatorBaseT<This>::toVertexHandle>
  FaceVertexIter;
  typedef Iterators::GenericCirculatorT<This,  This::FaceHandle,  This::VertexHandle,
      &Iterators::GenericCirculatorBaseT<This>::toVertexHandle> FaceVertexCCWIter;

  typedef Iterators::GenericCirculatorT<This,  This::FaceHandle,  This::VertexHandle,
      &Iterators::GenericCirculatorBaseT<This>::toVertexHandle, false>
  FaceVertexCWIter;

  typedef Iterators::GenericCirculatorT_DEPRECATED<This,  This::FaceHandle,  This::HalfedgeHandle,
          &Iterators::GenericCirculatorBaseT<This>::toHalfedgeHandle>
  FaceHalfedgeIter;
  typedef Iterators::GenericCirculatorT<This,  This::FaceHandle,  This::HalfedgeHandle,
      &Iterators::GenericCirculatorBaseT<This>::toHalfedgeHandle> FaceHalfedgeCCWIter;

  typedef Iterators::GenericCirculatorT<This,  This::FaceHandle,  This::HalfedgeHandle,
          &Iterators::GenericCirculatorBaseT<This>::toHalfedgeHandle, false>
  FaceHalfedgeCWIter;

  typedef Iterators::GenericCirculatorT_DEPRECATED<This,  This::FaceHandle,  This::EdgeHandle,
          &Iterators::GenericCirculatorBaseT<This>::toEdgeHandle>
  FaceEdgeIter;
  typedef Iterators::GenericCirculatorT<This,  This::FaceHandle,  This::EdgeHandle,
      &Iterators::GenericCirculatorBaseT<This>::toEdgeHandle> FaceEdgeCCWIter;

  typedef Iterators::GenericCirculatorT<This,  This::FaceHandle,  This::EdgeHandle,
          &Iterators::GenericCirculatorBaseT<This>::toEdgeHandle, false>
  FaceEdgeCWIter;

  typedef Iterators::GenericCirculatorT_DEPRECATED<This,  This::FaceHandle,  This::FaceHandle,
          &Iterators::GenericCirculatorBaseT<This>::toOppositeFaceHandle>
  FaceFaceIter;
  typedef Iterators::GenericCirculatorT<This,  This::FaceHandle,  This::FaceHandle,
      &Iterators::GenericCirculatorBaseT<This>::toOppositeFaceHandle> FaceFaceCCWIter;

  typedef Iterators::GenericCirculatorT<This,  This::FaceHandle,  This::FaceHandle,
          &Iterators::GenericCirculatorBaseT<This>::toOppositeFaceHandle, false>
  FaceFaceCWIter;

  typedef FaceVertexIter        ConstFaceVertexIter;
  typedef FaceVertexCWIter      ConstFaceVertexCWIter;
  typedef FaceVertexCCWIter     ConstFaceVertexCCWIter;
  typedef FaceHalfedgeIter      ConstFaceHalfedgeIter;
  typedef FaceHalfedgeCWIter    ConstFaceHalfedgeCWIter;
  typedef FaceHalfedgeCCWIter   ConstFaceHalfedgeCCWIter;
  typedef FaceEdgeIter          ConstFaceEdgeIter;
  typedef FaceEdgeCWIter        ConstFaceEdgeCWIter;
  typedef FaceEdgeCCWIter       ConstFaceEdgeCCWIter;
  typedef FaceFaceIter          ConstFaceFaceIter;
  typedef FaceFaceCWIter        ConstFaceFaceCWIter;
  typedef FaceFaceCCWIter       ConstFaceFaceCCWIter;

  /*
   * Halfedge circulator
   */
  typedef HalfedgeLoopIter      ConstHalfedgeLoopIter;
  typedef HalfedgeLoopCWIter    ConstHalfedgeLoopCWIter;
  typedef HalfedgeLoopCCWIter   ConstHalfedgeLoopCCWIter;


  // --- shortcuts

  typedef VertexHandle    VHandle;
  typedef HalfedgeHandle  HHandle;
  typedef EdgeHandle      EHandle;
  typedef FaceHandle      FHandle;

  typedef VertexIter    VIter;
  typedef HalfedgeIter  HIter;
  typedef EdgeIter      EIter;
  typedef FaceIter      FIter;

  typedef ConstVertexIter    CVIter;
  typedef ConstHalfedgeIter  CHIter;
  typedef ConstEdgeIter      CEIter;
  typedef ConstFaceIter      CFIter;

  typedef VertexVertexIter        VVIter;
  typedef VertexVertexCWIter      VVCWIter;
  typedef VertexVertexCCWIter     VVCCWIter;
  typedef VertexOHalfedgeIter     VOHIter;
  typedef VertexOHalfedgeCWIter   VOHCWIter;
  typedef VertexOHalfedgeCCWIter  VOHCCWIter;
  typedef VertexIHalfedgeIter     VIHIter;
  typedef VertexIHalfedgeCWIter   VIHICWter;
  typedef VertexIHalfedgeCCWIter  VIHICCWter;
  typedef VertexEdgeIter          VEIter;
  typedef VertexEdgeCWIter        VECWIter;
  typedef VertexEdgeCCWIter       VECCWIter;
  typedef VertexFaceIter          VFIter;
  typedef VertexFaceCWIter        VFCWIter;
  typedef VertexFaceCCWIter       VFCCWIter;
  typedef FaceVertexIter          FVIter;
  typedef FaceVertexCWIter        FVCWIter;
  typedef FaceVertexCCWIter       FVCCWIter;
  typedef FaceHalfedgeIter        FHIter;
  typedef FaceHalfedgeCWIter      FHCWIter;
  typedef FaceHalfedgeCCWIter     FHCWWIter;
  typedef FaceEdgeIter            FEIter;
  typedef FaceEdgeCWIter          FECWIter;
  typedef FaceEdgeCCWIter         FECWWIter;
  typedef FaceFaceIter            FFIter;

  typedef ConstVertexVertexIter         CVVIter;
  typedef ConstVertexVertexCWIter       CVVCWIter;
  typedef ConstVertexVertexCCWIter      CVVCCWIter;
  typedef ConstVertexOHalfedgeIter      CVOHIter;
  typedef ConstVertexOHalfedgeCWIter    CVOHCWIter;
  typedef ConstVertexOHalfedgeCCWIter   CVOHCCWIter;
  typedef ConstVertexIHalfedgeIter      CVIHIter;
  typedef ConstVertexIHalfedgeCWIter    CVIHCWIter;
  typedef ConstVertexIHalfedgeCCWIter   CVIHCCWIter;
  typedef ConstVertexEdgeIter           CVEIter;
  typedef ConstVertexEdgeCWIter         CVECWIter;
  typedef ConstVertexEdgeCCWIter        CVECCWIter;
  typedef ConstVertexFaceIter           CVFIter;
  typedef ConstVertexFaceCWIter         CVFCWIter;
  typedef ConstVertexFaceCCWIter        CVFCCWIter;
  typedef ConstFaceVertexIter           CFVIter;
  typedef ConstFaceVertexCWIter         CFVCWIter;
  typedef ConstFaceVertexCCWIter        CFVCCWIter;
  typedef ConstFaceHalfedgeIter         CFHIter;
  typedef ConstFaceHalfedgeCWIter       CFHCWIter;
  typedef ConstFaceHalfedgeCCWIter      CFHCCWIter;
  typedef ConstFaceEdgeIter             CFEIter;
  typedef ConstFaceEdgeCWIter           CFECWIter;
  typedef ConstFaceEdgeCCWIter          CFECCWIter;
  typedef ConstFaceFaceIter             CFFIter;
  typedef ConstFaceFaceCWIter           CFFCWIter;
  typedef ConstFaceFaceCCWIter          CFFCCWIter;

public:

  PolyConnectivity()  {}
  virtual ~PolyConnectivity() {}

  inline static bool is_triangles()
  { return false; }

  inline void assign_connectivity(const PolyConnectivity& _other)
  { ArrayKernel::assign_connectivity(_other); }
  

  inline VertexHandle add_vertex()
  { return new_vertex(); }

  FaceHandle add_face(const std::vector<VertexHandle>& _vhandles);
 
   
  FaceHandle add_face(VertexHandle _vh0, VertexHandle _vh1, VertexHandle _vh2);

  FaceHandle add_face(VertexHandle _vh0, VertexHandle _vh1, VertexHandle _vh2, VertexHandle _vh3);
 
  FaceHandle add_face(const VertexHandle* _vhandles, size_t _vhs_size);




  bool is_collapse_ok(HalfedgeHandle _he);
    
    
  void delete_vertex(VertexHandle _vh, bool _delete_isolated_vertices = true);

  void delete_edge(EdgeHandle _eh, bool _delete_isolated_vertices=true);

  void delete_face(FaceHandle _fh, bool _delete_isolated_vertices=true);

  

  VertexIter vertices_begin();
  ConstVertexIter vertices_begin() const;
  VertexIter vertices_end();
  ConstVertexIter vertices_end() const;

  HalfedgeIter halfedges_begin();
  ConstHalfedgeIter halfedges_begin() const;
  HalfedgeIter halfedges_end();
  ConstHalfedgeIter halfedges_end() const;

  EdgeIter edges_begin();
  ConstEdgeIter edges_begin() const;
  EdgeIter edges_end();
  ConstEdgeIter edges_end() const;

  FaceIter faces_begin();
  ConstFaceIter faces_begin() const;
  FaceIter faces_end();
  ConstFaceIter faces_end() const;



  VertexIter vertices_sbegin()
  { return VertexIter(*this, VertexHandle(0), true); }
  ConstVertexIter vertices_sbegin() const
  { return ConstVertexIter(*this, VertexHandle(0), true); }

  HalfedgeIter halfedges_sbegin()
  { return HalfedgeIter(*this, HalfedgeHandle(0), true); }
  ConstHalfedgeIter halfedges_sbegin() const
  { return ConstHalfedgeIter(*this, HalfedgeHandle(0), true); }

  EdgeIter edges_sbegin()
  { return EdgeIter(*this, EdgeHandle(0), true); }
  ConstEdgeIter edges_sbegin() const
  { return ConstEdgeIter(*this, EdgeHandle(0), true); }

  FaceIter faces_sbegin()
  { return FaceIter(*this, FaceHandle(0), true); }
  ConstFaceIter faces_sbegin() const
  { return ConstFaceIter(*this, FaceHandle(0), true); }


  //--- circulators ---


  VertexVertexIter vv_iter(VertexHandle _vh)
  { return VertexVertexIter(*this, _vh); }
  VertexVertexCWIter vv_cwiter(VertexHandle _vh)
  { return VertexVertexCWIter(*this, _vh); }
  VertexVertexCCWIter vv_ccwiter(VertexHandle _vh)
  { return VertexVertexCCWIter(*this, _vh); }
  VertexIHalfedgeIter vih_iter(VertexHandle _vh)
  { return VertexIHalfedgeIter(*this, _vh); }
  VertexIHalfedgeCWIter vih_cwiter(VertexHandle _vh)
  { return VertexIHalfedgeCWIter(*this, _vh); }
  VertexIHalfedgeCCWIter vih_ccwiter(VertexHandle _vh)
  { return VertexIHalfedgeCCWIter(*this, _vh); }
  VertexOHalfedgeIter voh_iter(VertexHandle _vh)
  { return VertexOHalfedgeIter(*this, _vh); }
  VertexOHalfedgeCWIter voh_cwiter(VertexHandle _vh)
  { return VertexOHalfedgeCWIter(*this, _vh); }
  VertexOHalfedgeCCWIter voh_ccwiter(VertexHandle _vh)
  { return VertexOHalfedgeCCWIter(*this, _vh); }
  VertexEdgeIter ve_iter(VertexHandle _vh)
  { return VertexEdgeIter(*this, _vh); }
  VertexEdgeCWIter ve_cwiter(VertexHandle _vh)
  { return VertexEdgeCWIter(*this, _vh); }
  VertexEdgeCCWIter ve_ccwiter(VertexHandle _vh)
  { return VertexEdgeCCWIter(*this, _vh); }
  VertexFaceIter vf_iter(VertexHandle _vh)
  { return VertexFaceIter(*this, _vh); }
  VertexFaceCWIter vf_cwiter(VertexHandle _vh)
  { return VertexFaceCWIter(*this, _vh); }
  VertexFaceCCWIter vf_ccwiter(VertexHandle _vh)
  { return VertexFaceCCWIter(*this, _vh); }

  ConstVertexVertexIter cvv_iter(VertexHandle _vh) const
  { return ConstVertexVertexIter(*this, _vh); }
  ConstVertexVertexCWIter cvv_cwiter(VertexHandle _vh) const
  { return ConstVertexVertexCWIter(*this, _vh); }
  ConstVertexVertexCCWIter cvv_ccwiter(VertexHandle _vh) const
  { return ConstVertexVertexCCWIter(*this, _vh); }
  ConstVertexIHalfedgeIter cvih_iter(VertexHandle _vh) const
  { return ConstVertexIHalfedgeIter(*this, _vh); }
  ConstVertexIHalfedgeCWIter cvih_cwiter(VertexHandle _vh) const
  { return ConstVertexIHalfedgeCWIter(*this, _vh); }
  ConstVertexIHalfedgeCCWIter cvih_ccwiter(VertexHandle _vh) const
  { return ConstVertexIHalfedgeCCWIter(*this, _vh); }
  ConstVertexOHalfedgeIter cvoh_iter(VertexHandle _vh) const
  { return ConstVertexOHalfedgeIter(*this, _vh); }
  ConstVertexOHalfedgeCWIter cvoh_cwiter(VertexHandle _vh) const
  { return ConstVertexOHalfedgeCWIter(*this, _vh); }
  ConstVertexOHalfedgeCCWIter cvoh_ccwiter(VertexHandle _vh) const
  { return ConstVertexOHalfedgeCCWIter(*this, _vh); }
  ConstVertexEdgeIter cve_iter(VertexHandle _vh) const
  { return ConstVertexEdgeIter(*this, _vh); }
  ConstVertexEdgeCWIter cve_cwiter(VertexHandle _vh) const
  { return ConstVertexEdgeCWIter(*this, _vh); }
  ConstVertexEdgeCCWIter cve_ccwiter(VertexHandle _vh) const
  { return ConstVertexEdgeCCWIter(*this, _vh); }
  ConstVertexFaceIter cvf_iter(VertexHandle _vh) const
  { return ConstVertexFaceIter(*this, _vh); }
  ConstVertexFaceCWIter cvf_cwiter(VertexHandle _vh) const
  { return ConstVertexFaceCWIter(*this, _vh); }
  ConstVertexFaceCCWIter cvf_ccwiter(VertexHandle _vh) const
  { return ConstVertexFaceCCWIter(*this, _vh); }

  FaceVertexIter fv_iter(FaceHandle _fh)
  { return FaceVertexIter(*this, _fh); }
  FaceVertexCWIter fv_cwiter(FaceHandle _fh)
  { return FaceVertexCWIter(*this, _fh); }
  FaceVertexCCWIter fv_ccwiter(FaceHandle _fh)
  { return FaceVertexCCWIter(*this, _fh); }
  FaceHalfedgeIter fh_iter(FaceHandle _fh)
  { return FaceHalfedgeIter(*this, _fh); }
  FaceHalfedgeCWIter fh_cwiter(FaceHandle _fh)
  { return FaceHalfedgeCWIter(*this, _fh); }
  FaceHalfedgeCCWIter fh_ccwiter(FaceHandle _fh)
  { return FaceHalfedgeCCWIter(*this, _fh); }
  FaceEdgeIter fe_iter(FaceHandle _fh)
  { return FaceEdgeIter(*this, _fh); }
  FaceEdgeCWIter fe_cwiter(FaceHandle _fh)
  { return FaceEdgeCWIter(*this, _fh); }
  FaceEdgeCCWIter fe_ccwiter(FaceHandle _fh)
  { return FaceEdgeCCWIter(*this, _fh); }
  FaceFaceIter ff_iter(FaceHandle _fh)
  { return FaceFaceIter(*this, _fh); }
  FaceFaceCWIter ff_cwiter(FaceHandle _fh)
  { return FaceFaceCWIter(*this, _fh); }
  FaceFaceCCWIter ff_ccwiter(FaceHandle _fh)
  { return FaceFaceCCWIter(*this, _fh); }

  ConstFaceVertexIter cfv_iter(FaceHandle _fh) const
  { return ConstFaceVertexIter(*this, _fh); }
  ConstFaceVertexCWIter cfv_cwiter(FaceHandle _fh) const
  { return ConstFaceVertexCWIter(*this, _fh); }
  ConstFaceVertexCCWIter cfv_ccwiter(FaceHandle _fh) const
  { return ConstFaceVertexCCWIter(*this, _fh); }
  ConstFaceHalfedgeIter cfh_iter(FaceHandle _fh) const
  { return ConstFaceHalfedgeIter(*this, _fh); }
  ConstFaceHalfedgeCWIter cfh_cwiter(FaceHandle _fh) const
  { return ConstFaceHalfedgeCWIter(*this, _fh); }
  ConstFaceHalfedgeCCWIter cfh_ccwiter(FaceHandle _fh) const
  { return ConstFaceHalfedgeCCWIter(*this, _fh); }
  ConstFaceEdgeIter cfe_iter(FaceHandle _fh) const
  { return ConstFaceEdgeIter(*this, _fh); }
  ConstFaceEdgeCWIter cfe_cwiter(FaceHandle _fh) const
  { return ConstFaceEdgeCWIter(*this, _fh); }
  ConstFaceEdgeCCWIter cfe_ccwiter(FaceHandle _fh) const
  { return ConstFaceEdgeCCWIter(*this, _fh); }
  ConstFaceFaceIter cff_iter(FaceHandle _fh) const
  { return ConstFaceFaceIter(*this, _fh); }
  ConstFaceFaceCWIter cff_cwiter(FaceHandle _fh) const
  { return ConstFaceFaceCWIter(*this, _fh); }
  ConstFaceFaceCCWIter cff_ccwiter(FaceHandle _fh) const
  { return ConstFaceFaceCCWIter(*this, _fh); }
  
  // 'begin' circulators
  
  VertexVertexIter vv_begin(VertexHandle _vh)
  { return VertexVertexIter(*this, _vh); }
  VertexVertexCWIter vv_cwbegin(VertexHandle _vh)
  { return VertexVertexCWIter(*this, _vh); }
  VertexVertexCCWIter vv_ccwbegin(VertexHandle _vh)
  { return VertexVertexCCWIter(*this, _vh); }
  VertexIHalfedgeIter vih_begin(VertexHandle _vh)
  { return VertexIHalfedgeIter(*this, _vh); }
  VertexIHalfedgeCWIter vih_cwbegin(VertexHandle _vh)
  { return VertexIHalfedgeCWIter(*this, _vh); }
  VertexIHalfedgeCCWIter vih_ccwbegin(VertexHandle _vh)
  { return VertexIHalfedgeCCWIter(*this, _vh); }
  VertexOHalfedgeIter voh_begin(VertexHandle _vh)
  { return VertexOHalfedgeIter(*this, _vh); }
  VertexOHalfedgeCWIter voh_cwbegin(VertexHandle _vh)
  { return VertexOHalfedgeCWIter(*this, _vh); }
  VertexOHalfedgeCCWIter voh_ccwbegin(VertexHandle _vh)
  { return VertexOHalfedgeCCWIter(*this, _vh); }
  VertexEdgeIter ve_begin(VertexHandle _vh)
  { return VertexEdgeIter(*this, _vh); }
  VertexEdgeCWIter ve_cwbegin(VertexHandle _vh)
  { return VertexEdgeCWIter(*this, _vh); }
  VertexEdgeCCWIter ve_ccwbegin(VertexHandle _vh)
  { return VertexEdgeCCWIter(*this, _vh); }
  VertexFaceIter vf_begin(VertexHandle _vh)
  { return VertexFaceIter(*this, _vh); }
  VertexFaceCWIter vf_cwbegin(VertexHandle _vh)
  { return VertexFaceCWIter(*this, _vh); }
  VertexFaceCCWIter vf_ccwbegin(VertexHandle _vh)
  { return VertexFaceCCWIter(*this, _vh); }


  ConstVertexVertexIter cvv_begin(VertexHandle _vh) const
  { return ConstVertexVertexIter(*this, _vh); }
  ConstVertexVertexCWIter cvv_cwbegin(VertexHandle _vh) const
  { return ConstVertexVertexCWIter(*this, _vh); }
  ConstVertexVertexCCWIter cvv_ccwbegin(VertexHandle _vh) const
  { return ConstVertexVertexCCWIter(*this, _vh); }
  ConstVertexIHalfedgeIter cvih_begin(VertexHandle _vh) const
  { return ConstVertexIHalfedgeIter(*this, _vh); }
  ConstVertexIHalfedgeCWIter cvih_cwbegin(VertexHandle _vh) const
  { return ConstVertexIHalfedgeCWIter(*this, _vh); }
  ConstVertexIHalfedgeCCWIter cvih_ccwbegin(VertexHandle _vh) const
  { return ConstVertexIHalfedgeCCWIter(*this, _vh); }
  ConstVertexOHalfedgeIter cvoh_begin(VertexHandle _vh) const
  { return ConstVertexOHalfedgeIter(*this, _vh); }
  ConstVertexOHalfedgeCWIter cvoh_cwbegin(VertexHandle _vh) const
  { return ConstVertexOHalfedgeCWIter(*this, _vh); }
  ConstVertexOHalfedgeCCWIter cvoh_ccwbegin(VertexHandle _vh) const
  { return ConstVertexOHalfedgeCCWIter(*this, _vh); }
  ConstVertexEdgeIter cve_begin(VertexHandle _vh) const
  { return ConstVertexEdgeIter(*this, _vh); }
  ConstVertexEdgeCWIter cve_cwbegin(VertexHandle _vh) const
  { return ConstVertexEdgeCWIter(*this, _vh); }
  ConstVertexEdgeCCWIter cve_ccwbegin(VertexHandle _vh) const
  { return ConstVertexEdgeCCWIter(*this, _vh); }
  ConstVertexFaceIter cvf_begin(VertexHandle _vh) const
  { return ConstVertexFaceIter(*this, _vh); }
  ConstVertexFaceCWIter cvf_cwbegin(VertexHandle _vh) const
  { return ConstVertexFaceCWIter(*this, _vh); }
  ConstVertexFaceCCWIter cvf_ccwbegin(VertexHandle _vh) const
  { return ConstVertexFaceCCWIter(*this, _vh); }

  FaceVertexIter fv_begin(FaceHandle _fh)
  { return FaceVertexIter(*this, _fh); }
  FaceVertexCWIter fv_cwbegin(FaceHandle _fh)
  { return FaceVertexCWIter(*this, _fh); }
  FaceVertexCCWIter fv_ccwbegin(FaceHandle _fh)
  { return FaceVertexCCWIter(*this, _fh); }
  FaceHalfedgeIter fh_begin(FaceHandle _fh)
  { return FaceHalfedgeIter(*this, _fh); }
  FaceHalfedgeCWIter fh_cwbegin(FaceHandle _fh)
  { return FaceHalfedgeCWIter(*this, _fh); }
  FaceHalfedgeCCWIter fh_ccwbegin(FaceHandle _fh)
  { return FaceHalfedgeCCWIter(*this, _fh); }
  FaceEdgeIter fe_begin(FaceHandle _fh)
  { return FaceEdgeIter(*this, _fh); }
  FaceEdgeCWIter fe_cwbegin(FaceHandle _fh)
  { return FaceEdgeCWIter(*this, _fh); }
  FaceEdgeCCWIter fe_ccwbegin(FaceHandle _fh)
  { return FaceEdgeCCWIter(*this, _fh); }
  FaceFaceIter ff_begin(FaceHandle _fh)
  { return FaceFaceIter(*this, _fh); }
  FaceFaceCWIter ff_cwbegin(FaceHandle _fh)
  { return FaceFaceCWIter(*this, _fh); }
  FaceFaceCCWIter ff_ccwbegin(FaceHandle _fh)
  { return FaceFaceCCWIter(*this, _fh); }
  HalfedgeLoopIter hl_begin(HalfedgeHandle _heh)
  { return HalfedgeLoopIter(*this, _heh); }
  HalfedgeLoopCWIter hl_cwbegin(HalfedgeHandle _heh)
  { return HalfedgeLoopCWIter(*this, _heh); }
  HalfedgeLoopCCWIter hl_ccwbegin(HalfedgeHandle _heh)
  { return HalfedgeLoopCCWIter(*this, _heh); }

  ConstFaceVertexIter cfv_begin(FaceHandle _fh) const
  { return ConstFaceVertexIter(*this, _fh); }
  ConstFaceVertexCWIter cfv_cwbegin(FaceHandle _fh) const
  { return ConstFaceVertexCWIter(*this, _fh); }
  ConstFaceVertexCCWIter cfv_ccwbegin(FaceHandle _fh) const
  { return ConstFaceVertexCCWIter(*this, _fh); }
  ConstFaceHalfedgeIter cfh_begin(FaceHandle _fh) const
  { return ConstFaceHalfedgeIter(*this, _fh); }
  ConstFaceHalfedgeCWIter cfh_cwbegin(FaceHandle _fh) const
  { return ConstFaceHalfedgeCWIter(*this, _fh); }
  ConstFaceHalfedgeCCWIter cfh_ccwbegin(FaceHandle _fh) const
  { return ConstFaceHalfedgeCCWIter(*this, _fh); }
  ConstFaceEdgeIter cfe_begin(FaceHandle _fh) const
  { return ConstFaceEdgeIter(*this, _fh); }
  ConstFaceEdgeCWIter cfe_cwbegin(FaceHandle _fh) const
  { return ConstFaceEdgeCWIter(*this, _fh); }
  ConstFaceEdgeCCWIter cfe_ccwbegin(FaceHandle _fh) const
  { return ConstFaceEdgeCCWIter(*this, _fh); }
  ConstFaceFaceIter cff_begin(FaceHandle _fh) const
  { return ConstFaceFaceIter(*this, _fh); }
  ConstFaceFaceCWIter cff_cwbegin(FaceHandle _fh) const
  { return ConstFaceFaceCWIter(*this, _fh); }
  ConstFaceFaceCCWIter cff_ccwbegin(FaceHandle _fh) const
  { return ConstFaceFaceCCWIter(*this, _fh); }
  ConstHalfedgeLoopIter chl_begin(HalfedgeHandle _heh) const
  { return ConstHalfedgeLoopIter(*this, _heh); }
  ConstHalfedgeLoopCWIter chl_cwbegin(HalfedgeHandle _heh) const
  { return ConstHalfedgeLoopCWIter(*this, _heh); }
  ConstHalfedgeLoopCCWIter chl_ccwbegin(HalfedgeHandle _heh) const
  { return ConstHalfedgeLoopCCWIter(*this, _heh); }
  
  // 'end' circulators
  
  VertexVertexIter vv_end(VertexHandle _vh)
  { return VertexVertexIter(*this, _vh, true); }
  VertexVertexCWIter vv_cwend(VertexHandle _vh)
  { return VertexVertexCWIter(*this, _vh, true); }
  VertexVertexCCWIter vv_ccwend(VertexHandle _vh)
  { return VertexVertexCCWIter(*this, _vh, true); }
  VertexIHalfedgeIter vih_end(VertexHandle _vh)
  { return VertexIHalfedgeIter(*this, _vh, true); }
  VertexIHalfedgeCWIter vih_cwend(VertexHandle _vh)
  { return VertexIHalfedgeCWIter(*this, _vh, true); }
  VertexIHalfedgeCCWIter vih_ccwend(VertexHandle _vh)
  { return VertexIHalfedgeCCWIter(*this, _vh, true); }
  VertexOHalfedgeIter voh_end(VertexHandle _vh)
  { return VertexOHalfedgeIter(*this, _vh, true); }
  VertexOHalfedgeCWIter voh_cwend(VertexHandle _vh)
  { return VertexOHalfedgeCWIter(*this, _vh, true); }
  VertexOHalfedgeCCWIter voh_ccwend(VertexHandle _vh)
  { return VertexOHalfedgeCCWIter(*this, _vh, true); }
  VertexEdgeIter ve_end(VertexHandle _vh)
  { return VertexEdgeIter(*this, _vh, true); }
  VertexEdgeCWIter ve_cwend(VertexHandle _vh)
  { return VertexEdgeCWIter(*this, _vh, true); }
  VertexEdgeCCWIter ve_ccwend(VertexHandle _vh)
  { return VertexEdgeCCWIter(*this, _vh, true); }
  VertexFaceIter vf_end(VertexHandle _vh)
  { return VertexFaceIter(*this, _vh, true); }
  VertexFaceCWIter vf_cwend(VertexHandle _vh)
  { return VertexFaceCWIter(*this, _vh, true); }
  VertexFaceCCWIter vf_ccwend(VertexHandle _vh)
  { return VertexFaceCCWIter(*this, _vh, true); }

  ConstVertexVertexIter cvv_end(VertexHandle _vh) const
  { return ConstVertexVertexIter(*this, _vh, true); }
  ConstVertexVertexCWIter cvv_cwend(VertexHandle _vh) const
  { return ConstVertexVertexCWIter(*this, _vh, true); }
  ConstVertexVertexCCWIter cvv_ccwend(VertexHandle _vh) const
  { return ConstVertexVertexCCWIter(*this, _vh, true); }
  ConstVertexIHalfedgeIter cvih_end(VertexHandle _vh) const
  { return ConstVertexIHalfedgeIter(*this, _vh, true); }
  ConstVertexIHalfedgeCWIter cvih_cwend(VertexHandle _vh) const
  { return ConstVertexIHalfedgeCWIter(*this, _vh, true); }
  ConstVertexIHalfedgeCCWIter cvih_ccwend(VertexHandle _vh) const
  { return ConstVertexIHalfedgeCCWIter(*this, _vh, true); }
  ConstVertexOHalfedgeIter cvoh_end(VertexHandle _vh) const
  { return ConstVertexOHalfedgeIter(*this, _vh, true); }
  ConstVertexOHalfedgeCWIter cvoh_cwend(VertexHandle _vh) const
  { return ConstVertexOHalfedgeCWIter(*this, _vh, true); }
  ConstVertexOHalfedgeCCWIter cvoh_ccwend(VertexHandle _vh) const
  { return ConstVertexOHalfedgeCCWIter(*this, _vh, true); }
  ConstVertexEdgeIter cve_end(VertexHandle _vh) const
  { return ConstVertexEdgeIter(*this, _vh, true); }
  ConstVertexEdgeCWIter cve_cwend(VertexHandle _vh) const
  { return ConstVertexEdgeCWIter(*this, _vh, true); }
  ConstVertexEdgeCCWIter cve_ccwend(VertexHandle _vh) const
  { return ConstVertexEdgeCCWIter(*this, _vh, true); }
  ConstVertexFaceIter cvf_end(VertexHandle _vh) const
  { return ConstVertexFaceIter(*this, _vh, true); }
  ConstVertexFaceCWIter cvf_cwend(VertexHandle _vh) const
  { return ConstVertexFaceCWIter(*this, _vh, true); }
  ConstVertexFaceCCWIter cvf_ccwend(VertexHandle _vh) const
  { return ConstVertexFaceCCWIter(*this, _vh, true); }

  FaceVertexIter fv_end(FaceHandle _fh)
  { return FaceVertexIter(*this, _fh, true); }
  FaceVertexCWIter fv_cwend(FaceHandle _fh)
  { return FaceVertexCWIter(*this, _fh, true); }
  FaceVertexCCWIter fv_ccwend(FaceHandle _fh)
  { return FaceVertexCCWIter(*this, _fh, true); }
  FaceHalfedgeIter fh_end(FaceHandle _fh)
  { return FaceHalfedgeIter(*this, _fh, true); }
  FaceHalfedgeCWIter fh_cwend(FaceHandle _fh)
  { return FaceHalfedgeCWIter(*this, _fh, true); }
  FaceHalfedgeCCWIter fh_ccwend(FaceHandle _fh)
  { return FaceHalfedgeCCWIter(*this, _fh, true); }
  FaceEdgeIter fe_end(FaceHandle _fh)
  { return FaceEdgeIter(*this, _fh, true); }
  FaceEdgeCWIter fe_cwend(FaceHandle _fh)
  { return FaceEdgeCWIter(*this, _fh, true); }
  FaceEdgeCCWIter fe_ccwend(FaceHandle _fh)
  { return FaceEdgeCCWIter(*this, _fh, true); }
  FaceFaceIter ff_end(FaceHandle _fh)
  { return FaceFaceIter(*this, _fh, true); }
  FaceFaceCWIter ff_cwend(FaceHandle _fh)
  { return FaceFaceCWIter(*this, _fh, true); }
  FaceFaceCCWIter ff_ccwend(FaceHandle _fh)
  { return FaceFaceCCWIter(*this, _fh, true); }
  HalfedgeLoopIter hl_end(HalfedgeHandle _heh)
  { return HalfedgeLoopIter(*this, _heh, true); }
  HalfedgeLoopCWIter hl_cwend(HalfedgeHandle _heh)
  { return HalfedgeLoopCWIter(*this, _heh, true); }
  HalfedgeLoopCCWIter hl_ccwend(HalfedgeHandle _heh)
  { return HalfedgeLoopCCWIter(*this, _heh, true); }

  ConstFaceVertexIter cfv_end(FaceHandle _fh) const
  { return ConstFaceVertexIter(*this, _fh, true); }
  ConstFaceVertexCWIter cfv_cwend(FaceHandle _fh) const
  { return ConstFaceVertexCWIter(*this, _fh, true); }
  ConstFaceVertexCCWIter cfv_ccwend(FaceHandle _fh) const
  { return ConstFaceVertexCCWIter(*this, _fh, true); }
  ConstFaceHalfedgeIter cfh_end(FaceHandle _fh) const
  { return ConstFaceHalfedgeIter(*this, _fh, true); }
  ConstFaceHalfedgeCWIter cfh_cwend(FaceHandle _fh) const
  { return ConstFaceHalfedgeCWIter(*this, _fh, true); }
  ConstFaceHalfedgeCCWIter cfh_ccwend(FaceHandle _fh) const
  { return ConstFaceHalfedgeCCWIter(*this, _fh, true); }
  ConstFaceEdgeIter cfe_end(FaceHandle _fh) const
  { return ConstFaceEdgeIter(*this, _fh, true); }
  ConstFaceEdgeCWIter cfe_cwend(FaceHandle _fh) const
  { return ConstFaceEdgeCWIter(*this, _fh, true); }
  ConstFaceEdgeCCWIter cfe_ccwend(FaceHandle _fh) const
  { return ConstFaceEdgeCCWIter(*this, _fh, true); }
  ConstFaceFaceIter cff_end(FaceHandle _fh) const
  { return ConstFaceFaceIter(*this, _fh, true); }
  ConstFaceFaceCWIter cff_cwend(FaceHandle _fh) const
  { return ConstFaceFaceCWIter(*this, _fh, true); }
  ConstFaceFaceCCWIter cff_ccwend(FaceHandle _fh) const
  { return ConstFaceFaceCCWIter(*this, _fh, true); }
  ConstHalfedgeLoopIter chl_end(HalfedgeHandle _heh) const
  { return ConstHalfedgeLoopIter(*this, _heh, true); }
  ConstHalfedgeLoopCWIter chl_cwend(HalfedgeHandle _heh) const
  { return ConstHalfedgeLoopCWIter(*this, _heh, true); }
  ConstHalfedgeLoopCCWIter chl_ccwend(HalfedgeHandle _heh) const
  { return ConstHalfedgeLoopCCWIter(*this, _heh, true); }


  template<
      typename CONTAINER_TYPE,
      typename ITER_TYPE,
      ITER_TYPE (CONTAINER_TYPE::*begin_fn)() const,
      ITER_TYPE (CONTAINER_TYPE::*end_fn)() const>
  class EntityRange {
      public:
          EntityRange(CONTAINER_TYPE &container) : container_(container) {}
          ITER_TYPE begin() const { return (container_.*begin_fn)(); }
          ITER_TYPE end() const { return (container_.*end_fn)(); }

      private:
          CONTAINER_TYPE &container_;
  };
  typedef EntityRange<
          const PolyConnectivity,
          PolyConnectivity::ConstVertexIter,
          &PolyConnectivity::vertices_begin,
          &PolyConnectivity::vertices_end> ConstVertexRange;
  typedef EntityRange<
          const PolyConnectivity,
          PolyConnectivity::ConstHalfedgeIter,
          &PolyConnectivity::halfedges_begin,
          &PolyConnectivity::halfedges_end> ConstHalfedgeRange;
  typedef EntityRange<
          const PolyConnectivity,
          PolyConnectivity::ConstEdgeIter,
          &PolyConnectivity::edges_begin,
          &PolyConnectivity::edges_end> ConstEdgeRange;
  typedef EntityRange<
          const PolyConnectivity,
          PolyConnectivity::ConstFaceIter,
          &PolyConnectivity::faces_begin,
          &PolyConnectivity::faces_end> ConstFaceRange;

  ConstVertexRange vertices() const { return ConstVertexRange(*this); }

  ConstHalfedgeRange halfedges() const { return ConstHalfedgeRange(*this); }

  ConstEdgeRange edges() const { return ConstEdgeRange(*this); }

  ConstFaceRange faces() const { return ConstFaceRange(*this); }

  template<
      typename CONTAINER_TYPE,
      typename ITER_TYPE,
      typename CENTER_ENTITY_TYPE,
      ITER_TYPE (CONTAINER_TYPE::*begin_fn)(CENTER_ENTITY_TYPE) const,
      ITER_TYPE (CONTAINER_TYPE::*end_fn)(CENTER_ENTITY_TYPE) const>
  class CirculatorRange {
      public:
          CirculatorRange(
                  const CONTAINER_TYPE &container,
                  CENTER_ENTITY_TYPE center) :
              container_(container), center_(center) {}
          ITER_TYPE begin() { return (container_.*begin_fn)(center_); }
          ITER_TYPE end() { return (container_.*end_fn)(center_); }

      private:
          const CONTAINER_TYPE &container_;
          CENTER_ENTITY_TYPE center_;
  };

  typedef CirculatorRange<
          PolyConnectivity,
          ConstVertexVertexCWIter,
          VertexHandle,
          &PolyConnectivity::cvv_cwbegin,
          &PolyConnectivity::cvv_cwend> ConstVertexVertexRange;
  typedef CirculatorRange<
          PolyConnectivity,
          ConstVertexIHalfedgeIter,
          VertexHandle,
          &PolyConnectivity::cvih_begin,
          &PolyConnectivity::cvih_end> ConstVertexIHalfedgeRange;
  typedef CirculatorRange<
          PolyConnectivity,
          ConstVertexOHalfedgeIter, VertexHandle,
          &PolyConnectivity::cvoh_begin,
          &PolyConnectivity::cvoh_end> ConstVertexOHalfedgeRange;
  typedef CirculatorRange<
          PolyConnectivity,
          ConstVertexEdgeIter,
          VertexHandle,
          &PolyConnectivity::cve_begin,
          &PolyConnectivity::cve_end> ConstVertexEdgeRange;
  typedef CirculatorRange<
          PolyConnectivity,
          ConstVertexFaceIter,
          VertexHandle,
          &PolyConnectivity::cvf_begin,
          &PolyConnectivity::cvf_end> ConstVertexFaceRange;
  typedef CirculatorRange<
          PolyConnectivity,
          ConstFaceVertexIter,
          FaceHandle,
          &PolyConnectivity::cfv_begin,
          &PolyConnectivity::cfv_end> ConstFaceVertexRange;
  typedef CirculatorRange<
          PolyConnectivity,
          ConstFaceHalfedgeIter,
          FaceHandle,
          &PolyConnectivity::cfh_begin,
          &PolyConnectivity::cfh_end> ConstFaceHalfedgeRange;
  typedef CirculatorRange<
          PolyConnectivity,
          ConstFaceEdgeIter,
          FaceHandle,
          &PolyConnectivity::cfe_begin,
          &PolyConnectivity::cfe_end> ConstFaceEdgeRange;
  typedef CirculatorRange<
          PolyConnectivity,
          ConstFaceFaceIter,
          FaceHandle,
          &PolyConnectivity::cff_begin,
          &PolyConnectivity::cff_end> ConstFaceFaceRange;

  ConstVertexVertexRange vv_range(VertexHandle _vh) const {
      return ConstVertexVertexRange(*this, _vh);
  }

  ConstVertexIHalfedgeRange vih_range(VertexHandle _vh) const {
      return ConstVertexIHalfedgeRange(*this, _vh);
  }

  ConstVertexOHalfedgeRange voh_range(VertexHandle _vh) const {
      return ConstVertexOHalfedgeRange(*this, _vh);
  }

  ConstVertexEdgeRange ve_range(VertexHandle _vh) const {
      return ConstVertexEdgeRange(*this, _vh);
  }

  ConstVertexFaceRange vf_range(VertexHandle _vh) const {
      return ConstVertexFaceRange(*this, _vh);
  }

  ConstFaceVertexRange fv_range(FaceHandle _fh) const {
      return ConstFaceVertexRange(*this, _fh);
  }

  ConstFaceHalfedgeRange fh_range(FaceHandle _fh) const {
      return ConstFaceHalfedgeRange(*this, _fh);
  }

  ConstFaceEdgeRange fe_range(FaceHandle _fh) const {
      return ConstFaceEdgeRange(*this, _fh);
  }

  ConstFaceFaceRange ff_range(FaceHandle _fh) const {
      return ConstFaceFaceRange(*this, _fh);
  }


  //===========================================================================
  //===========================================================================

  bool is_boundary(HalfedgeHandle _heh) const
  { return ArrayKernel::is_boundary(_heh); }

  bool is_boundary(EdgeHandle _eh) const
  {
    return (is_boundary(halfedge_handle(_eh, 0)) ||
            is_boundary(halfedge_handle(_eh, 1)));
  }

  bool is_boundary(VertexHandle _vh) const
  {
    HalfedgeHandle heh(halfedge_handle(_vh));
    return (!(heh.is_valid() && face_handle(heh).is_valid()));
  }

  bool is_boundary(FaceHandle _fh, bool _check_vertex=false) const;

  bool is_manifold(VertexHandle _vh) const;

  // --- shortcuts ---
  
  inline FaceHandle opposite_face_handle(HalfedgeHandle _heh) const
  { return face_handle(opposite_halfedge_handle(_heh)); }
    
  // --- misc ---

  void adjust_outgoing_halfedge(VertexHandle _vh);

  HalfedgeHandle find_halfedge(VertexHandle _start_vh, VertexHandle _end_vh) const;
  uint valence(VertexHandle _vh) const;
  uint valence(FaceHandle _fh) const;
  
  // --- connectivity operattions 
    
  void collapse(HalfedgeHandle _heh);
  bool is_simple_link(EdgeHandle _eh) const;
  bool is_simply_connected(FaceHandle _fh) const;
  FaceHandle remove_edge(EdgeHandle _eh);
  void reinsert_edge(EdgeHandle _eh);
  HalfedgeHandle insert_edge(HalfedgeHandle _prev_heh, HalfedgeHandle _next_heh);
    
  void split(FaceHandle _fh, VertexHandle _vh);

  void split_copy(FaceHandle _fh, VertexHandle _vh);
  
  void triangulate(FaceHandle _fh);

  void triangulate();
  
  void split_edge(EdgeHandle _eh, VertexHandle _vh);

  void split_edge_copy(EdgeHandle _eh, VertexHandle _vh);


  const Vertex&    deref(VertexHandle _h)   const { return vertex(_h); }
  Vertex&          deref(VertexHandle _h)         { return vertex(_h); }
  const Halfedge&  deref(HalfedgeHandle _h) const { return halfedge(_h); }
  Halfedge&        deref(HalfedgeHandle _h)       { return halfedge(_h); }
  const Edge&      deref(EdgeHandle _h)     const { return edge(_h); }
  Edge&            deref(EdgeHandle _h)           { return edge(_h); }
  const Face&      deref(FaceHandle _h)     const { return face(_h); }
  Face&            deref(FaceHandle _h)           { return face(_h); }

protected:  
  void collapse_edge(HalfedgeHandle _hh);
  void collapse_loop(HalfedgeHandle _hh);



private: // Working storage for add_face()
       struct AddFaceEdgeInfo
       {
               HalfedgeHandle halfedge_handle;
               bool is_new;
               bool needs_adjust;
       };
       std::vector<AddFaceEdgeInfo> edgeData_; //
       std::vector<std::pair<HalfedgeHandle, HalfedgeHandle> > next_cache_; // cache for set_next_halfedge and vertex' set_halfedge

};

}//namespace OpenMesh

#endif//OPENMESH_POLYCONNECTIVITY_HH