#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