#pragma once

#ifndef TCG_VERTEX_H

#define TCG_VERTEX_H

// tcg includes

#include "list.h"

#include "point.h"

namespace tcg {

template <typename v=""></typename>

struct vertex_traits {

  typedef typename V::point_type point_type;

  typedef typename V::edges_const_iterator edges_const_iterator;

  typedef typename V::edges_iterator edges_iterator;

};

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

template <typename point=""></typename>

class Vertex {

protected:

  Point m_p;

  int m_index;

  tcg::list<int> m_edgeList;</int>

public:

  typedef Point point_type;

  typedef tcg::list<int>::const_iterator edges_const_iterator;</int>

  typedef tcg::list<int>::iterator edges_iterator;</int>

public:

  Vertex() : m_index(-1) {}

  Vertex(const point_type &p) : m_p(p), m_index(-1) {}

  ~Vertex() {}

  void setIndex(int idx) { m_index = idx; }

  int getIndex() const { return m_index; }

  const tcg::list<int> &edges() const { return m_edgeList; }</int>

  tcg::list<int> &edges() { return m_edgeList; }</int>

  int edgesCount() const { return int(m_edgeList.size()); }

  int edge(int e) const { return int(m_edgeList[e]); }

  void addEdge(int e) { m_edgeList.push_back(e); }

  edges_iterator eraseEdge(edges_iterator it) { return m_edgeList.erase(it); }

  edges_const_iterator edgesBegin() const { return m_edgeList.begin(); }

  edges_const_iterator edgesEnd() const { return m_edgeList.end(); }

  edges_iterator edgesBegin() { return m_edgeList.begin(); }

  edges_iterator edgesEnd() { return m_edgeList.end(); }

  void setP(const point_type &p) { m_p = p; }

  const point_type &P() const { return m_p; }

  point_type &P() { return m_p; }

  bool operator==(const Vertex &v) const { return (m_p == v.m_p); }

  bool operator!=(const Vertex &v) const { return (m_p != v.m_p); }

};

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

template <typename p=""></typename>

struct point_traits<vertex<p>> {</vertex<p>

  typedef Vertex
 point_type;

  typedef typename point_traits
::value_type value_type;

  typedef typename point_traits
::float_type float_type;

  static inline value_type x(const point_type &p) { return p.P().x; }

  static inline value_type y(const point_type &p) { return p.P().y; }

};

}  // namespace tcg

#endif  // TCG_VERTEX_H