// Copyright 2000 by Robert Dick.
// All rights reserved.

/*###########################################################################*/
inline RawGraph::vertex_index RawGraph::size_vertex() const {
	return vertex_.size();
}

/*===========================================================================*/
inline RawGraph::edge_index RawGraph::size_edge() const {
	return edge_.size();
}

/*===========================================================================*/
inline RawGraph::vertex_index
RawGraph::vertex_offset(const_vertex_iterator x) const {
	return x - vertex_.begin();
}

/*===========================================================================*/
inline RawGraph::edge_index
RawGraph::edge_offset(const_edge_iterator x) const {
	return x - edge_.begin();
}

/*===========================================================================*/
inline RawGraph::const_reverse_vertex_iterator
RawGraph::vertex_rbegin() const {
	return vertex_.rbegin();
}

/*===========================================================================*/
inline RawGraph::vertex_iterator
RawGraph::vertex(const vertex_index i) {
	return vertex_.begin() + i;
}

/*===========================================================================*/
inline RawGraph::const_vertex_iterator
RawGraph::vertex(const vertex_index i) const {
	return runconst(*this).vertex(i);
}

/*===========================================================================*/
inline RawGraph::edge_iterator
RawGraph::edge(const edge_index i) {
	return edge_.begin() + i;
}

/*===========================================================================*/
inline RawGraph::const_edge_iterator
RawGraph::edge(const edge_index i) const {
	return runconst(*this).edge(i);
}

/*===========================================================================*/
inline
RawGraph::edge_type::edge_type(const vertex_index from_i,
const vertex_index to_i) :
	from_(from_i),
	to_(to_i)
{}

/*###########################################################################*/
inline RawGraph::vertex_index
RawGraph::vertex_index::operator++(int) {
	vertex_index tmp(*this);
	++index_;
	return tmp;
}

/*===========================================================================*/
inline RawGraph::vertex_index
RawGraph::vertex_index::operator--(int) {
	vertex_index tmp(*this);
	--index_;
	return tmp;
}

/*===========================================================================*/
inline RawGraph::vertex_index &
RawGraph::vertex_index::operator+=(const vertex_index i) {
	index_ += i.index_;
	return *this;
}

/*===========================================================================*/
inline RawGraph::vertex_index &
RawGraph::vertex_index::operator-=(const vertex_index i) {
	index_ -= i.index_;
	return *this;
}

/*===========================================================================*/
inline RawGraph::vertex_index
operator+(const RawGraph::vertex_index a,
const RawGraph::vertex_index b) {
	return RawGraph::vertex_index(a) += b;
}

/*===========================================================================*/
inline RawGraph::vertex_index
operator-(const RawGraph::vertex_index a,
const RawGraph::vertex_index b) {
	return RawGraph::vertex_index(a) -= b;
}

/*###########################################################################*/
inline RawGraph::edge_index
RawGraph::edge_index::operator++(int) {
	edge_index tmp(*this);
	++index_;
	return tmp;
}

/*===========================================================================*/
inline RawGraph::edge_index
RawGraph::edge_index::operator--(int) {
	edge_index tmp(*this);
	--index_;
	return tmp;
}

/*===========================================================================*/
inline RawGraph::edge_index &
RawGraph::edge_index::operator+=(const edge_index i) {
	index_ += i.index_;
	return *this;
}

/*===========================================================================*/
inline RawGraph::edge_index &
RawGraph::edge_index::operator-=(const edge_index i) {
	index_ -= i.index_;
	return *this;
}

/*===========================================================================*/
inline RawGraph::edge_index
operator+(const RawGraph::edge_index & a,
const RawGraph::edge_index & b) {
	return RawGraph::edge_index(a) += b;
}

/*===========================================================================*/
inline RawGraph::edge_index
operator-(const RawGraph::edge_index & a,
const RawGraph::edge_index & b) {
	return RawGraph::edge_index(a) -= b;
}

/*###########################################################################*/
template <typename V, typename E>
Graph<V, E>::vertex_index
Graph<V, E>::add_vertex(const V & data) {
	v_data_.push_back(data);
	return super::add_vertex();
}

/*===========================================================================*/
template <typename V, typename E>
Graph<V, E>::edge_index
Graph<V, E>::add_edge(vertex_index from, vertex_index to,
const E & data) {
	e_data_.push_back(data);
	return super::add_edge(from, to);
}

/*===========================================================================*/
template <typename V, typename E>
void Graph<V, E>::erase_vertex(const vertex_index i) {
	super::erase_vertex(i);
	v_data_.erase(&v_data_[i]);
}

/*===========================================================================*/
template <typename V, typename E>
void Graph<V, E>::erase_edge(const edge_index i) {
	super::erase_edge(i);
	e_data_.erase(&e_data_[i]);
}

/*===========================================================================*/
template <typename V, typename E>
void Graph<V, E>::pack_memory() {
	super::pack_memory();
	RVector<V> v_data(v_data_);
	RVector<E> e_data(e_data_);
	v_data_.rswap(v_data);
	e_data_.rswap(e_data);
}

/*===========================================================================*/
template<typename V, typename E>
void Graph<V, E>::clear() {
	super::clear();
	v_data_.clear();
	e_data_.clear();
}

/*===========================================================================*/
template <typename V, typename E>
void Graph<V, E>::rswap(RawGraph & g) {
	super::rswap(g);

// This checks to make sure they're the same type.
	
	if (Graph * gg = dynamic_cast<Graph *>(&g)) {
		v_data_.rswap(gg->v_data_);
		e_data_.rswap(gg->e_data_);
	}
}

/*===========================================================================*/
template <typename V, typename E>
void Graph<V, E>::self_check_deep() const {
	self_check();
	v_data_.self_check_deep();
	v_data_.self_check_deep();
}

/*###########################################################################*/
template <typename V, typename E>
void Graph<V, E>::print_to_default(ostream & os) const {
	super::print_to(os);

	MAP(x, v_data_.size()) {
		os << "vertex " << x << " data:\n" << v_data_[x] << "\n";
	}

	MAP(x, e_data_.size()) {
		os << "edge " << x << " data:\n" << e_data_[x] << "\n";
	}
}