viennagrid/forwards.hpp

Go to the documentation of this file.

#ifndef VIENNAGRID_FORWARDS_H
#define VIENNAGRID_FORWARDS_H

/* =======================================================================
   Copyright (c) 2011-2014, Institute for Microelectronics,
                            Institute for Analysis and Scientific Computing,
                            TU Wien.

                            -----------------
                     ViennaGrid - The Vienna Grid Library
                            -----------------

   License:      MIT (X11), see file LICENSE in the base directory
======================================================================= */

#include <iostream>
#include <vector>
#include <map>
#include <cstddef>     //for std::size_t
#include <cstdlib>     //for EXIT_SUCCESS and EXIT_FAILURE

#define VIENNAGRID_MAJOR_VERSION   2
#define VIENNAGRID_MINOR_VERSION   1
#define VIENNAGRID_BUGFIX_LEVEL    0


#include "viennagrid/storage/static_array.hpp"
#include "viennagrid/storage/forwards.hpp"

//Debug levels:
//VIENNAGRID_DEBUG_ALL          Output every little piece of debug information
//VIENNAGRID_DEBUG_IO           Debug IO operations
//VIENNAGRID_DEBUG_STATUS       Print status messages to std::cout (very little debug info)

#ifdef VIENNAGRID_DEBUG_ALL
  #define VIENNAGRID_DEBUG_IO
  #define VIENNAGRID_DEBUG_STATUS
#endif

namespace viennagrid
{
  namespace detail
  {
    namespace result_of {}
  }

  namespace config
  {
    namespace result_of {}
  }

  namespace io
  {
    namespace detail {}
  }

  template<typename iterator_type, typename distance_type>
  iterator_type advance(iterator_type const & in, distance_type distance)
  {
      iterator_type out(in);
      std::advance(out, static_cast<long>(distance));
      return out;
  }


  typedef std::size_t       dim_type;

  /********* Tags ***********************/

  template <int d>
  struct cartesian_cs;    //Cartesian coordinate system

  struct polar_cs;        //Polar coordinate system (r, phi)
  struct spherical_cs;    //Spherical coordinate system (r, theta, phi)
  struct cylindrical_cs;  //Cylindrical coordinate system (rho, theta, z)

  //Dimension Tag: (for tag dispatching)
  template <int d>
  struct dimension_tag
  {
      static const int value = d;
  };

  //Tags for the handling of elements at different topological levels (see topology::subcell_desc)
  struct full_handling_tag {};
  struct no_handling_tag {};

  struct no_orientation_handling_tag {};

//   Lazy storage reserved for future use
  struct no_orientation_lazy_handling_tag {};
  struct full_lazy_handling_tag {};


  struct coboundary_collection_tag {};
  struct neighbor_collection_tag {};
  struct boundary_information_collection_tag {};
  struct interface_information_collection_tag {};


  /********* Forward definitions of main classes *******************/

  // Simplex family:
  template <int dim>
  struct simplex_tag;

  typedef simplex_tag<0>    vertex_tag;
  typedef simplex_tag<1>    line_tag;
  typedef simplex_tag<1>    edge_tag;
  typedef simplex_tag<2>    triangle_tag;
  typedef simplex_tag<3>    tetrahedron_tag;

  // Hypercube family:
  template <int dim>
  struct hypercube_tag;

  //typedef hypercube_tag<1>    line_tag;
  typedef hypercube_tag<2>  quadrilateral_tag;
  typedef hypercube_tag<3>  hexahedron_tag;

  //see viennagrid/topology/polygon.hpp
  struct polygon_tag;

  //see viennagrid/topology/plc.hpp
  struct plc_tag;


  struct static_layout_tag {};
  struct dynamic_layout_tag {};



  //forward declarations:

  template <typename CoordType, typename CoordinateSystem>
  class spatial_point;

  template<typename ElementTag, typename WrappedConfigType>
  class element;



  template <typename ElementTag, typename BoundaryElementTag = ElementTag>
  struct boundary_elements
  {
    //the default case is simultaneously a pathetic case:
    //cell-handling within the cell

    static const int num = 1;     //1 cell

    typedef ElementTag            tag;
  };


  namespace detail
  {
    template <typename ElementTag, typename BoundaryElementTag, typename BoundaryElementType>
    struct boundary_element_generator {};

    template<typename ElementTag, typename BoundaryElementType>
    struct boundary_element_generator<ElementTag, vertex_tag, BoundaryElementType>
    {
      template<typename element_type, typename inserter_type>
      static void create_boundary_elements(element_type &, inserter_type &) {}
    };

  }





  namespace detail
  {
    template <typename MeshConfigT, typename ElementTypeListT, typename ContainerConfigT>
    class decorated_mesh_view_config;
  }

  // see mesh.hpp
  template <typename WrappedConfigT>
  class mesh;

  // see segmentation.hpp
  template<typename WrappedConfigT>
  class segmentation;

  // see segmentation.hpp
  template<typename SegmentationT>
  class segment_handle;

  namespace detail
  {
    template<typename container_type_, typename change_counter_type>
    struct coboundary_container_wrapper;

    template<typename container_type_, typename change_counter_type>
    struct neighbor_container_wrapper;

    template<typename container_type_, typename change_counter_type>
    struct boundary_information_wrapper;


    template<typename ConfigType>
    typename viennagrid::mesh<ConfigType>::inserter_type &
    inserter(viennagrid::mesh<ConfigType> & mesh_obj);

    template<typename ConfigType>
    typename viennagrid::mesh<ConfigType>::inserter_type const &
    inserter(viennagrid::mesh<ConfigType> const & mesh_obj);

    template<typename SegmentationType>
    typename viennagrid::segment_handle<SegmentationType>::view_type::inserter_type & inserter(segment_handle<SegmentationType> & segment);

    template<typename SegmentationType>
    typename viennagrid::segment_handle<SegmentationType>::view_type::inserter_type const & inserter(segment_handle<SegmentationType> const & segment);
  }





  namespace result_of
  {
    template<typename WrappedConfigT>
    struct mesh;

    template<typename SomethingT>
    struct element_collection {};

    template<typename SomethingT>
    struct container_collection_typemap {};

    template<typename SomethingT>
    struct topologic_cell_dimension;

    template<typename SomethingT, int TopologicDimensionV>
    struct elements_of_topologic_dim;

    template<typename SomethingT>
    struct cells;

    template<typename SomethingT>
    struct cell;

    template<typename SomethingT>
    struct cell_tag;


    template<typename SomethingT>
    struct point {};

    template<typename SomethingT>
    struct coord
    {
      typedef typename coord< typename point<SomethingT>::type >::type type;
    };

    template<typename SomethingT>
    struct geometric_dimension
    {
      static const int value = geometric_dimension< typename point<SomethingT>::type >::value;
    };


    template<typename ElementT>
    struct id
    {
      typedef typename ElementT::id_type type;
    };


    template<typename SomethingT, typename ElementTypeOrTagT>
    struct element;

    template<typename element_tag, typename WrappedConfigType>
    struct element< viennagrid::element<element_tag, WrappedConfigType>, viennagrid::element<element_tag, WrappedConfigType> >
    {
      typedef viennagrid::element<element_tag, WrappedConfigType> type;
    };

    template<typename element_tag, typename WrappedConfigType>
    struct element< viennagrid::element<element_tag, WrappedConfigType>, element_tag >
    {
      typedef viennagrid::element<element_tag, WrappedConfigType> type;
    };

    template<typename SomethingT>
    struct element<SomethingT, viennagrid::null_type>
    {
      typedef viennagrid::null_type type;
    };
    template<typename SomethingT>
    struct vertex
    {
      typedef typename element<SomethingT, vertex_tag>::type type;
    };

    template<typename SomethingT>
    struct line
    {
      typedef typename element<SomethingT, line_tag>::type type;
    };

    template<typename SomethingT>
    struct edge
    {
      typedef typename element<SomethingT, edge_tag>::type type;
    };

    template<typename SomethingT>
    struct triangle
    {
      typedef typename element<SomethingT, triangle_tag>::type type;
    };

    template<typename SomethingT>
    struct quadrilateral
    {
      typedef typename element<SomethingT, quadrilateral_tag>::type type;
    };

    template<typename SomethingT>
    struct polygon
    {
      typedef typename element<SomethingT, polygon_tag>::type type;
    };

    template<typename SomethingT>
    struct plc
    {
      typedef typename element<SomethingT, plc_tag>::type type;
    };

    template<typename SomethingT>
    struct tetrahedron
    {
      typedef typename element<SomethingT, tetrahedron_tag>::type type;
    };

    template<typename SomethingT>
    struct hexahedron
    {
      typedef typename element<SomethingT, hexahedron_tag>::type type;
    };


    template<typename SomethingT, typename ElementTypeOrTagT>
    struct handle;

    template<typename SomethingT>
    struct cell_handle
    {
      typedef typename cell_tag<SomethingT>::type cell_tag;
      typedef typename handle<SomethingT, cell_tag>::type type;
    };

    template<typename SomethingT>
    struct vertex_handle
    {
      typedef typename handle<SomethingT, vertex_tag>::type type;
    };

    template<typename SomethingT>
    struct line_handle
    {
      typedef typename handle<SomethingT, line_tag>::type type;
    };

    template<typename SomethingT>
    struct edge_handle
    {
      typedef typename handle<SomethingT, edge_tag>::type type;
    };

    template<typename SomethingT>
    struct triangle_handle
    {
      typedef typename handle<SomethingT, triangle_tag>::type type;
    };

    template<typename SomethingT>
    struct quadrilateral_handle
    {
      typedef typename handle<SomethingT, quadrilateral_tag>::type type;
    };

    template<typename SomethingT>
    struct polygon_handle
    {
      typedef typename handle<SomethingT, polygon_tag>::type type;
    };

    template<typename SomethingT>
    struct plc_handle
    {
      typedef typename handle<SomethingT, plc_tag>::type type;
    };

    template<typename SomethingT>
    struct tetrahedron_handle
    {
      typedef typename handle<SomethingT, tetrahedron_tag>::type type;
    };

    template<typename SomethingT>
    struct hexahedron_handle
    {
      typedef typename handle<SomethingT, hexahedron_tag>::type type;
    };



    template<typename SomethingT, typename ElementTypeOrTagT>
    struct const_handle;

    template<typename SomethingT>
    struct const_cell_handle
    {
      typedef typename cell_tag<SomethingT>::type cell_tag;
      typedef typename const_handle<SomethingT, cell_tag>::type type;
    };

    template<typename SomethingT>
    struct const_vertex_handle
    {
      typedef typename const_handle<SomethingT, vertex_tag>::type type;
    };

    template<typename SomethingT>
    struct const_line_handle
    {
      typedef typename const_handle<SomethingT, line_tag>::type type;
    };

    template<typename SomethingT>
    struct const_edge_handle
    {
      typedef typename const_handle<SomethingT, edge_tag>::type type;
    };

    template<typename SomethingT>
    struct const_triangle_handle
    {
      typedef typename const_handle<SomethingT, triangle_tag>::type type;
    };

    template<typename SomethingT>
    struct const_quadrilateral_handle
    {
      typedef typename const_handle<SomethingT, quadrilateral_tag>::type type;
    };

    template<typename SomethingT>
    struct const_polygon_handle
    {
      typedef typename const_handle<SomethingT, polygon_tag>::type type;
    };

    template<typename SomethingT>
    struct const_plc_handle
    {
      typedef typename const_handle<SomethingT, plc_tag>::type type;
    };

    template<typename SomethingT>
    struct const_tetrahedron_handle
    {
      typedef typename const_handle<SomethingT, tetrahedron_tag>::type type;
    };

    template<typename SomethingT>
    struct const_hexahedron_handle
    {
      typedef typename const_handle<SomethingT, hexahedron_tag>::type type;
    };







    template<typename SomethingT>
    struct cell_id
    {
      typedef typename id< typename cell<SomethingT>::type >::type type;
    };

    template<typename SomethingT>
    struct vertex_id
    {
      typedef typename id< typename vertex<SomethingT>::type >::type type;
    };

    template<typename SomethingT>
    struct line_id
    {
      typedef typename id< typename line<SomethingT>::type >::type type;
    };

    template<typename SomethingT>
    struct edge_id
    {
      typedef typename id< typename edge<SomethingT>::type >::type type;
    };

    template<typename SomethingT>
    struct triangle_id
    {
      typedef typename id< typename triangle<SomethingT>::type >::type type;
    };

    template<typename SomethingT>
    struct quadrilateral_id
    {
      typedef typename id< typename quadrilateral<SomethingT>::type >::type type;
    };

    template<typename SomethingT>
    struct polygon_id
    {
      typedef typename id< typename polygon<SomethingT>::type >::type type;
    };

    template<typename SomethingT>
    struct plc_id
    {
      typedef typename id< typename plc<SomethingT>::type >::type type;
    };

    template<typename SomethingT>
    struct tetrahedron_id
    {
      typedef typename id< typename tetrahedron<SomethingT>::type >::type type;
    };

    template<typename SomethingT>
    struct hexahedron_id
    {
      typedef typename id< typename hexahedron<SomethingT>::type >::type type;
    };









    template <typename SomethingT,
              typename ElementTypeOrTagT>
    struct element_range;


    template<typename SomethingT>
    struct cell_range
    {
      typedef typename cell_tag<SomethingT>::type cell_tag;
      typedef typename element_range<SomethingT, cell_tag>::type type;
    };

    template<typename SomethingT>
    struct vertex_range
    {
      typedef typename element_range<SomethingT, vertex_tag>::type type;
    };

    template<typename SomethingT>
    struct line_range
    {
      typedef typename element_range<SomethingT, line_tag>::type type;
    };

    template<typename SomethingT>
    struct edge_range
    {
      typedef typename element_range<SomethingT, edge_tag>::type type;
    };

    template<typename SomethingT>
    struct triangle_range
    {
      typedef typename element_range<SomethingT, triangle_tag>::type type;
    };

    template<typename SomethingT>
    struct quadrilateral_range
    {
      typedef typename element_range<SomethingT, quadrilateral_tag>::type type;
    };

    template<typename SomethingT>
    struct polygon_range
    {
      typedef typename element_range<SomethingT, polygon_tag>::type type;
    };

    template<typename SomethingT>
    struct plc_range
    {
      typedef typename element_range<SomethingT, plc_tag>::type type;
    };

    template<typename SomethingT>
    struct tetrahedron_range
    {
      typedef typename element_range<SomethingT, tetrahedron_tag>::type type;
    };

    template<typename SomethingT>
    struct hexahedron_range
    {
      typedef typename element_range<SomethingT, hexahedron_tag>::type type;
    };






    template <typename SomethingT,
              typename ElementTypeOrTagT>
    struct const_element_range;


    template<typename SomethingT>
    struct const_cell_range
    {
      typedef typename cell_tag<SomethingT>::type cell_tag;
      typedef typename const_element_range<SomethingT, cell_tag>::type type;
    };

    template<typename SomethingT>
    struct const_vertex_range
    {
      typedef typename const_element_range<SomethingT, vertex_tag>::type type;
    };

    template<typename SomethingT>
    struct const_line_range
    {
      typedef typename const_element_range<SomethingT, line_tag>::type type;
    };

    template<typename SomethingT>
    struct const_edge_range
    {
      typedef typename const_element_range<SomethingT, edge_tag>::type type;
    };

    template<typename SomethingT>
    struct const_triangle_range
    {
      typedef typename const_element_range<SomethingT, triangle_tag>::type type;
    };

    template<typename SomethingT>
    struct const_quadrilateral_range
    {
      typedef typename const_element_range<SomethingT, quadrilateral_tag>::type type;
    };

    template<typename SomethingT>
    struct const_polygon_range
    {
      typedef typename const_element_range<SomethingT, polygon_tag>::type type;
    };

    template<typename SomethingT>
    struct const_plc_range
    {
      typedef typename const_element_range<SomethingT, plc_tag>::type type;
    };

    template<typename SomethingT>
    struct const_tetrahedron_range
    {
      typedef typename const_element_range<SomethingT, tetrahedron_tag>::type type;
    };

    template<typename SomethingT>
    struct const_hexahedron_range
    {
      typedef typename const_element_range<SomethingT, hexahedron_tag>::type type;
    };




    template <typename ContainerT>
    struct iterator
    {
      typedef typename ContainerT::iterator type;
    };

    template <typename ContainerT>
    struct const_iterator
    {
      typedef typename ContainerT::const_iterator type;
    };

    template <typename ContainerT>
    struct iterator<const ContainerT>
    {
      typedef typename const_iterator<ContainerT>::type type;
    };
    template<typename ElementTypeOrTagT>
    struct element_tag
    {
      typedef ElementTypeOrTagT type;
    };

    template<typename ElementTagT, typename WrappedConfigT>
    struct element_tag< viennagrid::element<ElementTagT, WrappedConfigT> >
    {
      typedef ElementTagT type;
    };

    template<typename ElementTagT, typename WrappedConfigT>
    struct element_tag< const viennagrid::element<ElementTagT, WrappedConfigT> >
    {
      typedef ElementTagT type;
    };
    template<typename SomethingT>
    struct facet_tag
    {
      typedef typename element_tag<SomethingT>::type::facet_tag type;
    };

    template<typename SomethingT>
    struct facet_tag< const SomethingT>
    {
      typedef typename facet_tag<SomethingT>::type  type;
    };

    template<typename WrappedMeshConfigT>
    struct facet_tag< viennagrid::mesh<WrappedMeshConfigT> >
    {
      typedef typename facet_tag< typename cell_tag< viennagrid::mesh<WrappedMeshConfigT> >::type >::type type;
    };

    template<typename WrappedSegmentationConfigT>
    struct facet_tag< viennagrid::segmentation<WrappedSegmentationConfigT> >
    {
      typedef typename facet_tag< typename cell_tag< viennagrid::segmentation<WrappedSegmentationConfigT> >::type >::type type;
    };

    template<typename SegmentationT>
    struct facet_tag< viennagrid::segment_handle<SegmentationT> >
    {
      typedef typename facet_tag< typename cell_tag< viennagrid::segment_handle<SegmentationT> >::type >::type type;
    };
    template<typename SomethingT>
    struct facet
    {
      typedef typename element<SomethingT, typename facet_tag<SomethingT>::type >::type type;
    };

    template<typename SomethingT>
    struct facet< const SomethingT>
    {
      typedef typename facet<SomethingT>::type    type;
    };

    template<typename WrappedMeshConfigT>
    struct facet< viennagrid::mesh<WrappedMeshConfigT> >
    {
      typedef typename facet< typename cell< viennagrid::mesh<WrappedMeshConfigT> >::type >::type type;
    };

    template<typename WrappedSegmentationConfigT>
    struct facet< viennagrid::segmentation<WrappedSegmentationConfigT> >
    {
      typedef typename facet< typename cell< viennagrid::segmentation<WrappedSegmentationConfigT> >::type >::type type;
    };

    template<typename SegmentationT>
    struct facet< viennagrid::segment_handle<SegmentationT> >
    {
      typedef typename facet< typename cell< viennagrid::segment_handle<SegmentationT> >::type >::type type;
    };
    template<typename SomethingT>
    struct facet_handle
    {
      typedef typename handle< SomethingT, typename facet_tag<SomethingT>::type >::type type;
    };

    template<typename SomethingT>
    struct const_facet_handle
    {
      typedef typename const_handle< SomethingT, typename facet_tag<SomethingT>::type >::type type;
    };

    template<typename SomethingT>
    struct facet_id
    {
      typedef typename id< typename facet<SomethingT>::type >::type type;
    };


    template<typename SomethingT>
    struct facet_range
    {
      typedef typename element_range<SomethingT, typename facet_tag<SomethingT>::type >::type type;
    };

    template<typename SomethingT>
    struct const_facet_range
    {
      typedef typename const_element_range<SomethingT, typename facet_tag<SomethingT>::type >::type type;
    };


    template<typename SegmentationT>
    struct segment_handle;
  }


  template<typename ElementTypeOrTagT, typename SomethingT>
  typename result_of::element_range<SomethingT, ElementTypeOrTagT>::type elements(SomethingT & something);


  template<typename ElementTypeOrTagT, typename WrappedConfigType>
  typename result_of::element_range<viennagrid::mesh<WrappedConfigType>, ElementTypeOrTagT>::type
  elements(viennagrid::mesh<WrappedConfigType> & mesh_obj);


  template<typename ElementTypeOrTagT, typename SegmentationT>
  typename result_of::element_range< viennagrid::segment_handle<SegmentationT>, ElementTypeOrTagT>::type
  elements( viennagrid::segment_handle<SegmentationT> & segment)
  { return elements<ElementTypeOrTagT>( segment.view() ); }

  template<typename ElementTypeOrTagT, typename WrappedConfigT>
  typename result_of::element_range<segmentation<WrappedConfigT>, ElementTypeOrTagT>::type
  elements( viennagrid::segmentation<WrappedConfigT> & segm)
  { return elements<ElementTypeOrTagT>( segm.all_elements() ); }


  template<typename sub_element_type_or_tag, typename element_tag, typename WrappedConfigType>
  typename result_of::element_range<viennagrid::element<element_tag, WrappedConfigType>, sub_element_type_or_tag>::type
  elements( viennagrid::element<element_tag, WrappedConfigType> & element);

  template<typename sub_element_type_or_tag, typename element_tag, typename WrappedConfigType>
  typename result_of::const_element_range<viennagrid::element<element_tag, WrappedConfigType>, sub_element_type_or_tag>::type
  elements( const viennagrid::element<element_tag, WrappedConfigType> & element);


  template<typename SomethingT>
  typename result_of::cell_range<SomethingT>::type cells(SomethingT & something)
  { return elements<typename result_of::cell_tag<SomethingT>::type>(something); }

  template<typename ElementT>
  typename result_of::facet_range<ElementT>::type facets(ElementT & element)
  { return elements< typename result_of::facet_tag<ElementT>::type >(element); }

  template<typename SomethingT>
  typename result_of::element_range<SomethingT, vertex_tag>::type vertices(SomethingT & something)
  { return elements<vertex_tag>(something); }

  template<typename SomethingT>
  typename result_of::element_range<SomethingT, line_tag>::type lines(SomethingT & something)
  { return elements<line_tag>(something); }

  template<typename SomethingT>
  typename result_of::element_range<SomethingT, edge_tag>::type edges(SomethingT & something)
  { return elements<edge_tag>(something); }

  template<typename SomethingT>
  typename result_of::element_range<SomethingT, triangle_tag>::type triangles(SomethingT & something)
  { return elements<triangle_tag>(something); }

  template<typename SomethingT>
  typename result_of::element_range<SomethingT, quadrilateral_tag>::type quadrilaterals(SomethingT & something)
  { return elements<quadrilateral_tag>(something); }

  template<typename SomethingT>
  typename result_of::element_range<SomethingT, polygon_tag>::type polygons(SomethingT & something)
  { return elements<polygon_tag>(something); }

  template<typename SomethingT>
  typename result_of::element_range<SomethingT, plc_tag>::type plcs(SomethingT & something)
  { return elements<plc_tag>(something); }

  template<typename SomethingT>
  typename result_of::element_range<SomethingT, tetrahedron_tag>::type tetrahedra(SomethingT & something)
  { return elements<tetrahedron_tag>(something); }

  template<typename SomethingT>
  typename result_of::element_range<SomethingT, hexahedron_tag>::type hexahedra(SomethingT & something)
  { return elements<hexahedron_tag>(something); }



  template<typename ElementTypeOrTagT, typename SomethingT>
  typename result_of::const_element_range<SomethingT, ElementTypeOrTagT>::type elements(SomethingT const & something);

  template<typename ElementTypeOrTagT, typename WrappedConfigType>
  typename result_of::const_element_range<viennagrid::mesh<WrappedConfigType>, ElementTypeOrTagT>::type
  elements(viennagrid::mesh<WrappedConfigType> const & mesh_obj);


  template<typename ElementTypeOrTagT, typename SegmentationT>
  typename result_of::const_element_range< viennagrid::segment_handle<SegmentationT>, ElementTypeOrTagT>::type
  elements( viennagrid::segment_handle<SegmentationT> const & segment)
  { return elements<ElementTypeOrTagT>( segment.view() ); }


  template<typename ElementTypeOrTagT, typename WrappedConfigT>
  typename result_of::const_element_range<viennagrid::segmentation<WrappedConfigT>, ElementTypeOrTagT>::type
  elements(viennagrid::segmentation<WrappedConfigT> const & segm)
  { return elements<ElementTypeOrTagT>( segm.all_elements() ); }


  template<typename SomethingT>
  typename result_of::const_cell_range<SomethingT>::type cells( SomethingT const & something)
  { return elements<typename result_of::cell_tag<SomethingT>::type>(something); }

  template<typename ElementT>
  typename result_of::const_facet_range<ElementT>::type facets(const ElementT & element)
  { return elements< typename result_of::facet_tag<ElementT>::type >(element); }

  template<typename SomethingT>
  typename result_of::const_element_range<SomethingT, vertex_tag>::type vertices(SomethingT const & something)
  { return elements<vertex_tag>(something); }

  template<typename SomethingT>
  typename result_of::const_element_range<SomethingT, line_tag>::type lines(SomethingT const & something)
  { return elements<line_tag>(something); }

  template<typename SomethingT>
  typename result_of::const_element_range<SomethingT, edge_tag>::type edges(SomethingT const & something)
  { return elements<edge_tag>(something); }

  template<typename SomethingT>
  typename result_of::const_element_range<SomethingT, triangle_tag>::type triangles(SomethingT const & something)
  { return elements<triangle_tag>(something); }

  template<typename SomethingT>
  typename result_of::const_element_range<SomethingT, quadrilateral_tag>::type quadrilaterals(SomethingT const & something)
  { return elements<quadrilateral_tag>(something); }

  template<typename SomethingT>
  typename result_of::const_element_range<SomethingT, polygon_tag>::type polygons(SomethingT const & something)
  { return elements<polygon_tag>(something); }

  template<typename SomethingT>
  typename result_of::const_element_range<SomethingT, plc_tag>::type plcs(SomethingT const & something)
  { return elements<plc_tag>(something); }

  template<typename SomethingT>
  typename result_of::const_element_range<SomethingT, tetrahedron_tag>::type tetrahedra(SomethingT const & something)
  { return elements<tetrahedron_tag>(something); }

  template<typename SomethingT>
  typename result_of::const_element_range<SomethingT, hexahedron_tag>::type hexahedra(SomethingT const & something)
  { return elements<hexahedron_tag>(something); }




  template<typename ElementTypeOrTagT, typename MeshOrSegmentHandleTypeT, typename VertexHandleIteratorT>
  typename result_of::handle<MeshOrSegmentHandleTypeT, ElementTypeOrTagT>::type make_element(
        MeshOrSegmentHandleTypeT & mesh_segment,
        VertexHandleIteratorT array_start,
        VertexHandleIteratorT const & array_end );


  template<typename ElementTypeOrTagT, typename MeshOrSegmentHandleTypeT, typename VertexHandleIteratorT, typename IDT>
  typename result_of::handle<MeshOrSegmentHandleTypeT, ElementTypeOrTagT>::type make_element_with_id(
        MeshOrSegmentHandleTypeT & mesh_segment,
        VertexHandleIteratorT array_start,
        VertexHandleIteratorT const & array_end,
        IDT id );

  template<typename MeshOrSegmentHandleTypeT>
  typename result_of::vertex_handle<MeshOrSegmentHandleTypeT>::type make_vertex(MeshOrSegmentHandleTypeT & mesh_segment);

  template<typename MeshOrSegmentHandleTypeT>
  typename result_of::vertex_handle<MeshOrSegmentHandleTypeT>::type make_vertex(
        MeshOrSegmentHandleTypeT & mesh_segment,
        typename result_of::point<MeshOrSegmentHandleTypeT>::type const & point);

#ifndef _MSC_VER
  template<typename MeshOrSegmentHandleTypeT>
  typename result_of::vertex_handle<MeshOrSegmentHandleTypeT>::type make_vertex_with_id(
        MeshOrSegmentHandleTypeT & mesh_segment,
        typename viennagrid::result_of::element<MeshOrSegmentHandleTypeT, vertex_tag>::type::id_type id,
        typename result_of::point<MeshOrSegmentHandleTypeT>::type const & point);
#endif

  template<typename MeshOrSegmentHandleTypeT>
  typename result_of::vertex_handle<MeshOrSegmentHandleTypeT>::type make_unique_vertex(
        MeshOrSegmentHandleTypeT & mesh_segment,
        typename result_of::point<MeshOrSegmentHandleTypeT>::type const & point,
        typename result_of::coord<MeshOrSegmentHandleTypeT>::type tolerance);

  template<typename MeshOrSegmentHandleTypeT>
  typename result_of::vertex_handle<MeshOrSegmentHandleTypeT>::type make_unique_vertex(
        MeshOrSegmentHandleTypeT & mesh_segment,
        typename result_of::point<MeshOrSegmentHandleTypeT>::type const & p);

  template<typename MeshOrSegmentHandleTypeT, typename VertexHandleT>
  typename result_of::line_handle<MeshOrSegmentHandleTypeT>::type make_line(
        MeshOrSegmentHandleTypeT & mesh_segment,
        VertexHandleT v0, VertexHandleT v1);

  template<typename MeshOrSegmentHandleTypeT, typename VertexHandleT>
  typename result_of::edge_handle<MeshOrSegmentHandleTypeT>::type make_edge(
        MeshOrSegmentHandleTypeT & mesh_segment,
        VertexHandleT v0, VertexHandleT v1);

  template<typename MeshOrSegmentHandleTypeT, typename VertexHandleT>
  typename result_of::triangle_handle<MeshOrSegmentHandleTypeT>::type make_triangle(
        MeshOrSegmentHandleTypeT & mesh_segment,
        VertexHandleT v0, VertexHandleT v1, VertexHandleT v2);

  template<typename MeshOrSegmentHandleTypeT, typename VertexHandleT>
  typename result_of::quadrilateral_handle<MeshOrSegmentHandleTypeT>::type make_quadrilateral(
        MeshOrSegmentHandleTypeT & mesh_segment,
        VertexHandleT v0, VertexHandleT v1, VertexHandleT v2, VertexHandleT v3);

  template<typename MeshOrSegmentHandleTypeT, typename LineHandleIteratorT, typename VertexHandleIteratorT, typename PointIteratorT>
  typename result_of::plc_handle<MeshOrSegmentHandleTypeT>::type make_plc(
        MeshOrSegmentHandleTypeT & mesh_segment,
        LineHandleIteratorT    lines_begin,           LineHandleIteratorT     lines_end,
        VertexHandleIteratorT  loose_vertices_begin,  VertexHandleIteratorT   loose_vertices_end,
        PointIteratorT         hole_points_begin,     PointIteratorT          hole_points_end);

  template<typename MeshOrSegmentHandleTypeT, typename VertexHandleT>
  typename result_of::tetrahedron_handle<MeshOrSegmentHandleTypeT>::type make_tetrahedron(
        MeshOrSegmentHandleTypeT & mesh_segment,
        VertexHandleT v0, VertexHandleT v1, VertexHandleT v2, VertexHandleT v3);

  template<typename MeshOrSegmentHandleTypeT, typename VertexHandleT>
  typename result_of::hexahedron_handle<MeshOrSegmentHandleTypeT>::type make_hexahedron(
        MeshOrSegmentHandleTypeT & mesh_segment,
        VertexHandleT v0, VertexHandleT v1, VertexHandleT v2, VertexHandleT v3,
        VertexHandleT v4, VertexHandleT v5, VertexHandleT v6, VertexHandleT v7);

  template<typename ElementT, typename MeshOrSegmentHandleT>
  typename viennagrid::result_of::handle<
      MeshOrSegmentHandleT,
      typename viennagrid::result_of::element_tag<ElementT>::type
    >::type copy_element( ElementT const & element, MeshOrSegmentHandleT & mesh_segment,
                          typename viennagrid::result_of::coord<MeshOrSegmentHandleT>::type tolerance );

  template<typename ElementT, typename MeshOrSegmentHandleT>
  typename viennagrid::result_of::handle<
      MeshOrSegmentHandleT,
      typename viennagrid::result_of::element_tag<ElementT>::type
    >::type copy_element( ElementT const & element, MeshOrSegmentHandleT & mesh_segment );



  template<typename ElementIteratorT, typename OutputMeshOrSegmentHandleT>
  void copy_elements(ElementIteratorT const & begin, ElementIteratorT const & end,
                     OutputMeshOrSegmentHandleT & output_mesh,
                     typename viennagrid::result_of::coord<OutputMeshOrSegmentHandleT>::type tolerance );

  template<typename ElementIteratorT, typename OutputMeshOrSegmentHandleT>
  void copy_elements(ElementIteratorT const & begin, ElementIteratorT const & end,
                     OutputMeshOrSegmentHandleT & output_mesh );

  template<typename InputMeshOrSegmentHandleT, typename ElementHandleIteratorT, typename OutputMeshOrSegmentHandleT>
  void copy_element_by_handles(InputMeshOrSegmentHandleT const & input_mesh,
                            ElementHandleIteratorT const & begin, ElementHandleIteratorT const & end,
                            OutputMeshOrSegmentHandleT & output_mesh,
                            typename viennagrid::result_of::coord<OutputMeshOrSegmentHandleT>::type tolerance );

  template<typename InputMeshOrSegmentHandleT, typename ElementHandleIteratorT, typename OutputMeshOrSegmentHandleT>
  void copy_element_by_handles(InputMeshOrSegmentHandleT const & input_mesh,
                            ElementHandleIteratorT const & begin, ElementHandleIteratorT const & end,
                            OutputMeshOrSegmentHandleT & output_mesh );


  template<typename WrappedMeshConfigT, typename ElementTagT, typename WrappedConfigT>
  viennagrid::element<ElementTagT, WrappedConfigT> & dereference_handle( viennagrid::mesh<WrappedMeshConfigT> &, viennagrid::element<ElementTagT, WrappedConfigT> & element)
  { return element; }

  template<typename WrappedMeshConfigT, typename ElementTagT, typename WrappedConfigT>
  viennagrid::element<ElementTagT, WrappedConfigT> & dereference_handle( viennagrid::segment_handle<WrappedMeshConfigT> &, viennagrid::element<ElementTagT, WrappedConfigT> & element)
  { return element; }

  template<typename HostElementTagT, typename WrappedHostElementConfigT, typename ElementTagT, typename WrappedConfigT>
  viennagrid::element<ElementTagT, WrappedConfigT> & dereference_handle( viennagrid::element<HostElementTagT, WrappedHostElementConfigT> &, viennagrid::element<ElementTagT, WrappedConfigT> & element)
  { return element; }

  template<typename WrappedMeshConfigT, typename ElementTagT, typename WrappedConfigT>
  viennagrid::element<ElementTagT, WrappedConfigT> const & dereference_handle( viennagrid::mesh<WrappedMeshConfigT> const &, viennagrid::element<ElementTagT, WrappedConfigT> const & element)
  { return element; }

  template<typename WrappedMeshConfigT, typename ElementTagT, typename WrappedConfigT>
  viennagrid::element<ElementTagT, WrappedConfigT> const & dereference_handle( viennagrid::mesh<WrappedMeshConfigT> &, viennagrid::element<ElementTagT, WrappedConfigT> const & element)
  { return element; }

  template<typename WrappedMeshConfigT, typename ElementTagT, typename WrappedConfigT>
  viennagrid::element<ElementTagT, WrappedConfigT> const & dereference_handle( viennagrid::mesh<WrappedMeshConfigT> const &, viennagrid::element<ElementTagT, WrappedConfigT> & element)
  { return element; }


  template<typename SegmentationT, typename ElementTagT, typename WrappedConfigT>
  viennagrid::element<ElementTagT, WrappedConfigT> const & dereference_handle( viennagrid::segment_handle<SegmentationT> const &, viennagrid::element<ElementTagT, WrappedConfigT> const & element)
  { return element; }

  template<typename SegmentationT, typename ElementTagT, typename WrappedConfigT>
  viennagrid::element<ElementTagT, WrappedConfigT> const & dereference_handle( viennagrid::segment_handle<SegmentationT> &, viennagrid::element<ElementTagT, WrappedConfigT> const & element)
  { return element; }

  template<typename SegmentationT, typename ElementTagT, typename WrappedConfigT>
  viennagrid::element<ElementTagT, WrappedConfigT> const & dereference_handle( viennagrid::segment_handle<SegmentationT> const &, viennagrid::element<ElementTagT, WrappedConfigT> & element)
  { return element; }


  template<typename HostElementTagT, typename WrappedHostElementConfigT, typename ElementTagT, typename WrappedConfigT>
  viennagrid::element<ElementTagT, WrappedConfigT> const & dereference_handle( viennagrid::element<HostElementTagT, WrappedHostElementConfigT> const &, viennagrid::element<ElementTagT, WrappedConfigT> const & element)
  { return element; }

  template<typename HostElementTagT, typename WrappedHostElementConfigT, typename ElementTagT, typename WrappedConfigT>
  viennagrid::element<ElementTagT, WrappedConfigT> const & dereference_handle( viennagrid::element<HostElementTagT, WrappedHostElementConfigT> &, viennagrid::element<ElementTagT, WrappedConfigT> const & element)
  { return element; }

  template<typename HostElementTagT, typename WrappedHostElementConfigT, typename ElementTagT, typename WrappedConfigT>
  viennagrid::element<ElementTagT, WrappedConfigT> const & dereference_handle( viennagrid::element<HostElementTagT, WrappedHostElementConfigT> const &, viennagrid::element<ElementTagT, WrappedConfigT> & element)
  { return element; }

  template<typename MeshOrSegmentHandleT, typename HandleT>
  HandleT handle( MeshOrSegmentHandleT &, HandleT handle) { return handle; }

  template<typename MeshOrSegmentHandleT, typename HandleT>
  const HandleT handle( MeshOrSegmentHandleT const &, HandleT handle) { return handle; }

  template<typename MeshT, typename MeshViewT, typename HandleT>
  void mark_referencing_elements( MeshT & mesh_obj, MeshViewT & element_view, HandleT host_element );




  template<typename MeshT>
  struct mesh_proxy
  {
    mesh_proxy( MeshT & mesh_obj ) : mesh_obj_(&mesh_obj){}
    MeshT * mesh_obj_;
  };

  template<typename WrappedConfigT>
  mesh_proxy< viennagrid::mesh<WrappedConfigT> > make_view(viennagrid::mesh<WrappedConfigT> & mesh_obj)
  {
    return mesh_proxy< viennagrid::mesh<WrappedConfigT> >( mesh_obj );
  }

  template<typename SegmentationT>
  mesh_proxy< typename SegmentationT::view_type > make_view(segment_handle<SegmentationT> & segment);


  // norm tags for: algorithm/norm.hpp
  struct one_norm_tag {};
  struct two_norm_tag {};
  struct inf_norm_tag {};

  struct seg_cell_normal_tag {};

  struct seg_cell_normal_data {
    typedef viennagrid::spatial_point<double, cartesian_cs<3> >         point_type;
    typedef std::map<std::size_t, point_type>    type;
  };


  namespace detail
  {
    template <typename ElementTagT>
    struct element_refinement;
  }
}

#endif