#pragma once

#ifndef TCG_MESH_BGL_H

#define TCG_MESH_BGL_H

// TCG includes

#include "mesh.h"

// Boost includes

#include <boost graph="" graph_traits.hpp=""></boost>

/*

  \file     tcg_mesh_bgl.h

  \brief    This file contains TCG adapters to Boost's Graph Library (BGL).

*/

//************************************************************************************

//    boost::graph_traits to tcg::Mesh concept type

//************************************************************************************

namespace boost {

template <typename e,="" f="" typename="" v,=""></typename>

struct graph_traits<typename e,="" f="" tcg::mesh<v,="">> {</typename>

  // Preliminar typedefs

  typedef typename tcg::Mesh<v, e,="" f=""> mesh_type;</v,>

  typedef typename mesh_type::vertex_type vertex_type;

  typedef typename mesh_type::edge_type edge_type;

  typedef typename vertex_type::edges_const_iterator edge_const_iterator;

  // V/E descriptors

  typedef int vertex_descriptor;

  struct edge_descriptor  // NOTE: Can't use std::pair due to std conflicts

  {

    int m_e, m_src;

    edge_descriptor() : m_e(-1), m_src(-1) {}

    edge_descriptor(int e, int src) : m_e(e), m_src(src) {}

    bool operator==(const edge_descriptor &e_d) {

      return m_e == e_d.m_e;

    }  // Undirected

    bool operator!=(const edge_descriptor &e_d) { return !operator==(e_d); }

  };

  // Iterators

  struct out_edge_iterator : public edge_const_iterator {

    int m_src;

    out_edge_iterator() : edge_const_iterator(), m_src(-1) {}

    out_edge_iterator(const edge_const_iterator &it, int src)

        : edge_const_iterator(it), m_src(src) {}

    edge_descriptor operator*() const {

      return edge_descriptor(edge_const_iterator::operator*(), m_src);

    }

  };

  typedef typename tcg::list<vertex_type>::const_iterator vertex_iterator;</vertex_type>

  typedef typename tcg::list<edge_type>::const_iterator edge_iterator;</edge_type>

  // Categories

  typedef undirected_tag directed_category;

  typedef allow_parallel_edge_tag edge_parallel_category;

  typedef struct our_category : public bidirectional_graph_tag,

                                public vertex_list_graph_tag,

                                public edge_list_graph_tag {

  } traversal_category;

  // Sizes

  typedef int vertices_size_type;

  typedef int edges_size_type;

  typedef int degree_size_type;

  // Functions

  static inline vertex_descriptor null_vertex() { return -1; }

};

template <typename e,="" f="" typename="" v,=""></typename>

struct graph_traits<typename e,="" f="" tcg::trimesh<v,="">></typename>

    : public graph_traits<typename e,="" f="" tcg::mesh<v,="">> {};</typename>

}  // namespace boost

//************************************************************************************

//    tcg::bgl  helpers to edge data

//************************************************************************************

namespace tcg {

namespace bgl {

template <typename mesh=""></typename>

inline int source(

    const typename boost::graph_traits<mesh>::edge_descriptor &edge_descr,</mesh>

    const Mesh &mesh) {

  return edge_descr.m_src;

}

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

template <typename mesh=""></typename>

inline int target(

    const typename boost::graph_traits<mesh>::edge_descriptor &edge_descr,</mesh>

    const Mesh &mesh) {

  const typename Mesh::edge_type &ed = mesh.edge(edge_descr.m_e);

  return (ed.vertex(0) == edge_descr.m_src) ? ed.vertex(1) : ed.vertex(0);

}

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

template <typename mesh=""></typename>

inline std::pair<typename boost::graph_traits<mesh="">::out_edge_iterator,</typename>

                 typename boost::graph_traits<mesh>::out_edge_iterator></mesh>

out_edges(int v, const Mesh &mesh) {

  typedef

      typename boost::graph_traits<mesh>::out_edge_iterator out_edge_iterator;</mesh>

  return make_pair(out_edge_iterator(mesh.vertex(v).edgesBegin(), v),

                   out_edge_iterator(mesh.vertex(v).edgesEnd(), v));

}

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

template <typename mesh=""></typename>

inline int out_degree(int v, const Mesh &mesh) {

  return mesh.vertex(v).edgesCount();

}

}

}  // namespace tcg::bgl

#endif  // TCG_MESH_BGL_H