denes
/
graph
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

reverting the allocator idea

Browse Source
for/release
Denes Matetelki 12 years ago
parent 62b1ce8006
commit 9a020e81e8
1 changed files with 69 additions and 100 deletions
Show Stats Download Patch File Download Diff File

169
graph.hpp
Unescape View File

@ -11,8 +11,7 @@
template <typename V, template <typename V,
typename E = int, typename E = int>
typename Alloc = std::allocator<V> >
class Graph { class Graph {
private: private:
@ -50,10 +49,10 @@ public:
typedef Edge& edge_reference; typedef Edge& edge_reference;
Graph(bool isdirected = true) : m_directed(isdirected), m_vertices(), m_allocator(Alloc()) {} Graph(bool isdirected = true) : m_directed(isdirected), m_vertices() {}
Graph(const Graph<V, E, Alloc>& o) : m_directed(o.m_directed), m_vertices(o.m_vertices), m_allocator(o.m_allocator) {} Graph(const Graph<V, E>& o) : m_directed(o.m_directed), m_vertices(o.m_vertices) {}
Graph<V, E, Alloc>& operator=(Graph<V, E, Alloc> o) { swap(o); return *this; } Graph<V, E>& operator=(Graph<V, E> o) { swap(o); return *this; }
void swap(Graph& o) { std::swap (m_directed, o.m_directed); std::swap(m_vertices, o.m_vertices); std::swap(m_allocator, o.m_allocator);} void swap(Graph& o) { std::swap (m_directed, o.m_directed); std::swap(m_vertices, o.m_vertices); }
// Properties // Properties
bool directed() const { return m_directed; } bool directed() const { return m_directed; }
@ -184,11 +183,10 @@ private:
struct Vertex { struct Vertex {
Vertex(const_reference data, Alloc allocator); Vertex(const_reference data) : m_data(m_data), m_edges() {}
Vertex(const Vertex& o); Vertex(const Vertex& o) : m_data(o.m_data), m_edges(o.m_edges) {}
~Vertex();
Vertex& operator=(Vertex o) { swap(o); return *this; } Vertex& operator=(Vertex o) { swap(o); return *this; }
void swap(Vertex& o) { std::swap(m_data, o.m_data); std::swap(m_edges, o.m_edges); std::swap(m_allocator, o.m_allocator);} void swap(Vertex& o) { std::swap(m_data, o.m_data); std::swap(m_edges, o.m_edges); }
bool operator==(const Vertex& other) const; bool operator==(const Vertex& other) const;
@ -199,7 +197,6 @@ private:
pointer m_data; pointer m_data;
std::list<EdgeTo> m_edges; std::list<EdgeTo> m_edges;
Alloc& m_allocator;
}; };
typename std::vector<Vertex >::const_iterator find(const_reference data) const; typename std::vector<Vertex >::const_iterator find(const_reference data) const;
@ -207,28 +204,27 @@ private:
bool m_directed; bool m_directed;
std::vector<Vertex> m_vertices; std::vector<Vertex> m_vertices;
Alloc m_allocator;
}; };
// Edge // Edge
template <typename V, typename E, typename Alloc> template <typename V, typename E>
inline Graph<V, E, Alloc>::Edge::Edge(pointer source, pointer destination, E weight) inline Graph<V, E>::Edge::Edge(pointer source, pointer destination, E weight)
: m_source(source) : m_source(source)
, m_destination(destination) , m_destination(destination)
, m_weight(weight) , m_weight(weight)
{} {}
template <typename V, typename E, typename Alloc> template <typename V, typename E>
inline Graph<V, E, Alloc>::Edge::Edge(const Edge& o) inline Graph<V, E>::Edge::Edge(const Edge& o)
: m_source(o.m_source) : m_source(o.m_source)
, m_destination(o.m_destination) , m_destination(o.m_destination)
, m_weight(o.m_weight) , m_weight(o.m_weight)
{} {}
template <typename V, typename E, typename Alloc> template <typename V, typename E>
inline void Graph<V, E, Alloc>::Edge::swap(Edge& o) inline void Graph<V, E>::Edge::swap(Edge& o)
{ {
std::swap(m_source, o.m_source); std::swap(m_source, o.m_source);
std::swap(m_destination, o.m_destination); std::swap(m_destination, o.m_destination);
@ -238,16 +234,16 @@ inline void Graph<V, E, Alloc>::Edge::swap(Edge& o)
// edge iterator // edge iterator
template <typename V, typename E, typename Alloc> template <typename V, typename E>
inline Graph<V, E, Alloc>::edge_iterator::edge_iterator(const_reference_self_type o) inline Graph<V, E>::edge_iterator::edge_iterator(const_reference_self_type o)
: m_vertices(o.m_vertices) : m_vertices(o.m_vertices)
, m_vertex_it(o.m_vertex_it) , m_vertex_it(o.m_vertex_it)
, m_edge_it(o.m_edge_it) , m_edge_it(o.m_edge_it)
, m_edge() , m_edge()
{} {}
template <typename V, typename E, typename Alloc> template <typename V, typename E>
bool Graph<V, E, Alloc>::edge_iterator::operator==(const_reference_self_type o) const bool Graph<V, E>::edge_iterator::operator==(const_reference_self_type o) const
{ {
const bool this_is_at_end = m_vertex_it == m_vertices.end(); const bool this_is_at_end = m_vertex_it == m_vertices.end();
const bool other_is_at_end = o.m_vertex_it == o.m_vertices.end(); const bool other_is_at_end = o.m_vertex_it == o.m_vertices.end();
@ -258,8 +254,8 @@ bool Graph<V, E, Alloc>::edge_iterator::operator==(const_reference_self_type o)
*m_edge_it == *(o.m_edge_it); *m_edge_it == *(o.m_edge_it);
} }
template <typename V, typename E, typename Alloc> template <typename V, typename E>
inline void Graph<V, E, Alloc>::edge_iterator::swap(reference_self_type other) inline void Graph<V, E>::edge_iterator::swap(reference_self_type other)
{ {
std::swap(m_vertices, other.m_vertices); std::swap(m_vertices, other.m_vertices);
std::swap(m_vertex_it, other.m_vertex_it); std::swap(m_vertex_it, other.m_vertex_it);
@ -267,8 +263,8 @@ inline void Graph<V, E, Alloc>::edge_iterator::swap(reference_self_type other)
std::swap(m_edge, other.m_edge); std::swap(m_edge, other.m_edge);
} }
template <typename V, typename E, typename Alloc> template <typename V, typename E>
inline Graph<V, E, Alloc>::edge_iterator::edge_iterator(std::vector<Vertex> vertices, bool begin) inline Graph<V, E>::edge_iterator::edge_iterator(std::vector<Vertex> vertices, bool begin)
: m_vertices(vertices), m_vertex_it(), m_edge_it(), m_edge() : m_vertices(vertices), m_vertex_it(), m_edge_it(), m_edge()
{ {
if (begin) { if (begin) {
@ -283,8 +279,8 @@ inline Graph<V, E, Alloc>::edge_iterator::edge_iterator(std::vector<Vertex> vert
} }
} }
template <typename V, typename E, typename Alloc> template <typename V, typename E>
inline void Graph<V, E, Alloc>::edge_iterator::resetEdge() inline void Graph<V, E>::edge_iterator::resetEdge()
{ {
if (m_vertex_it == m_vertices.end() || (*m_vertex_it).m_edges.empty()) { if (m_vertex_it == m_vertices.end() || (*m_vertex_it).m_edges.empty()) {
m_edge = Edge(); m_edge = Edge();
@ -293,8 +289,8 @@ inline void Graph<V, E, Alloc>::edge_iterator::resetEdge()
} }
} }
template <typename V, typename E, typename Alloc> template <typename V, typename E>
void Graph<V, E, Alloc>::edge_iterator::advance(int n) void Graph<V, E>::edge_iterator::advance(int n)
{ {
while (n > 0 && m_vertex_it != m_vertices.end()) { while (n > 0 && m_vertex_it != m_vertices.end()) {
const int edgesAhead = std::distance(m_edge_it, (*m_vertex_it).m_edges.end()) - 1; const int edgesAhead = std::distance(m_edge_it, (*m_vertex_it).m_edges.end()) - 1;
@ -316,21 +312,21 @@ void Graph<V, E, Alloc>::edge_iterator::advance(int n)
// EdgeTo // EdgeTo
template <typename V, typename E, typename Alloc> template <typename V, typename E>
inline Graph<V, E, Alloc>::EdgeTo::EdgeTo(const_reference destination, E weight) inline Graph<V, E>::EdgeTo::EdgeTo(const_reference destination, E weight)
: m_destination(const_cast<pointer>(&destination)) : m_destination(const_cast<pointer>(&destination))
, m_weight(weight) , m_weight(weight)
{} {}
template <typename V, typename E, typename Alloc> template <typename V, typename E>
inline void Graph<V, E, Alloc>::EdgeTo::swap(EdgeTo& o) inline void Graph<V, E>::EdgeTo::swap(EdgeTo& o)
{ {
std::swap(m_destination, o.m_destination); std::swap(m_destination, o.m_destination);
std::swap(m_weight, o.m_weight); std::swap(m_weight, o.m_weight);
} }
template <typename V, typename E, typename Alloc> template <typename V, typename E>
inline bool Graph<V, E, Alloc>::EdgeTo::operator==(const EdgeTo& other) const inline bool Graph<V, E>::EdgeTo::operator==(const EdgeTo& other) const
{ {
return m_destination == other.m_destination && return m_destination == other.m_destination &&
m_weight == other.m_weight; m_weight == other.m_weight;
@ -339,49 +335,22 @@ inline bool Graph<V, E, Alloc>::EdgeTo::operator==(const EdgeTo& other) const
// Vertex // Vertex
template <typename V, typename E, typename Alloc> template <typename V, typename E>
inline Graph<V, E, Alloc>::Vertex::Vertex(const_reference data, Alloc allocator) inline bool Graph<V, E>::Vertex::operator==(const Vertex& other) const
: m_data()
, m_edges()
, m_allocator(allocator)
{
m_data = m_allocator.allocate(1);
m_allocator.construct(m_data, data);
}
template <typename V, typename E, typename Alloc>
inline Graph<V, E, Alloc>::Vertex::Vertex(const Vertex& o)
: m_data()
, m_edges(o.m_edges)
, m_allocator(o.m_allocator)
{
m_data = m_allocator.allocate(1);
m_allocator.construct(m_data, *(o.m_data));
}
template <typename V, typename E, typename Alloc>
inline Graph<V, E, Alloc>::Vertex::~Vertex()
{
m_allocator.destroy(m_data);
m_allocator.deallocate(m_data, 1);
}
template <typename V, typename E, typename Alloc>
inline bool Graph<V, E, Alloc>::Vertex::operator==(const Vertex& other) const
{ {
return m_data == other.m_data && return m_data == other.m_data &&
m_edges.size() == other.m_edges.size() && m_edges.size() == other.m_edges.size() &&
m_edges == other.m_edges; m_edges == other.m_edges;
} }
template <typename V, typename E, typename Alloc> template <typename V, typename E>
inline void Graph<V, E, Alloc>::Vertex::addEdge(const_reference destination, E weight) inline void Graph<V, E>::Vertex::addEdge(const_reference destination, E weight)
{ {
m_edges.push_back(EdgeTo(destination, weight)); m_edges.push_back(EdgeTo(destination, weight));
} }
template <typename V, typename E, typename Alloc> template <typename V, typename E>
inline void Graph<V, E, Alloc>::Vertex::removeEdge(const_reference destination, E weight) inline void Graph<V, E>::Vertex::removeEdge(const_reference destination, E weight)
{ {
m_edges.erase(std::find_if(m_edges.begin(), m_edges.end(), m_edges.erase(std::find_if(m_edges.begin(), m_edges.end(),
[&destination, &weight](const EdgeTo& e) [&destination, &weight](const EdgeTo& e)
@ -389,18 +358,18 @@ inline void Graph<V, E, Alloc>::Vertex::removeEdge(const_reference destination,
e.m_weight == weight;})); e.m_weight == weight;}));
} }
template <typename V, typename E, typename Alloc> template <typename V, typename E>
inline void Graph<V, E, Alloc>::Vertex::removeAllEdgesTo(const_reference destination) inline void Graph<V, E>::Vertex::removeAllEdgesTo(const_reference destination)
{ {
std::remove_if(m_edges.begin(), m_edges.end(), std::remove_if(m_edges.begin(), m_edges.end(),
[&destination](const EdgeTo& e) [&destination](const EdgeTo& e)
{ return *e.m_destination == destination; }); { return *e.m_destination == destination; });
} }
template <typename V, typename E, typename Alloc> template <typename V, typename E>
inline std::vector<typename Graph<V, E, Alloc>::Edge> Graph<V, E, Alloc>::Vertex::edges() const inline std::vector<typename Graph<V, E>::Edge> Graph<V, E>::Vertex::edges() const
{ {
std::vector<Graph<V, E, Alloc>::Edge> retval; std::vector<Graph<V, E>::Edge> retval;
std::for_each(m_edges.begin(), m_edges.end(), std::for_each(m_edges.begin(), m_edges.end(),
[&retval, this](const EdgeTo& e) [&retval, this](const EdgeTo& e)
@ -412,26 +381,26 @@ inline std::vector<typename Graph<V, E, Alloc>::Edge> Graph<V, E, Alloc>::Vertex
// Graph // Graph
template <typename V, typename E, typename Alloc> template <typename V, typename E>
inline typename Graph<V, E, Alloc>::size_type Graph<V, E, Alloc>::numberOfEdges() const inline typename Graph<V, E>::size_type Graph<V, E>::numberOfEdges() const
{ {
return std::accumulate(m_vertices.begin(), m_vertices.end(), 0, return std::accumulate(m_vertices.begin(), m_vertices.end(), 0,
[](int sum, const Vertex& v) [](int sum, const Vertex& v)
{ return sum + v.m_edges.size(); }); { return sum + v.m_edges.size(); });
} }
template <typename V, typename E, typename Alloc> template <typename V, typename E>
inline bool Graph<V, E, Alloc>::addVertex(const_reference data) inline bool Graph<V, E>::addVertex(const_reference data)
{ {
if (find(data) != m_vertices.end()) if (find(data) != m_vertices.end())
return false; return false;
m_vertices.push_back(Vertex(data, m_allocator)); m_vertices.push_back(Vertex(data));
return true; return true;
} }
template <typename V, typename E, typename Alloc> template <typename V, typename E>
inline bool Graph<V, E, Alloc>::removeVertex(const_reference data) inline bool Graph<V, E>::removeVertex(const_reference data)
{ {
typename std::vector<Vertex>::iterator it = find(data); typename std::vector<Vertex>::iterator it = find(data);
if (it == m_vertices.end()) if (it == m_vertices.end())
@ -446,8 +415,8 @@ inline bool Graph<V, E, Alloc>::removeVertex(const_reference data)
return true; return true;
} }
template <typename V, typename E, typename Alloc> template <typename V, typename E>
bool Graph<V, E, Alloc>::addEdge(const_reference source, const_reference destination, E weight) bool Graph<V, E>::addEdge(const_reference source, const_reference destination, E weight)
{ {
typename std::vector<Vertex>::iterator source_it = find(source); typename std::vector<Vertex>::iterator source_it = find(source);
if (source_it == m_vertices.end()) if (source_it == m_vertices.end())
@ -464,8 +433,8 @@ bool Graph<V, E, Alloc>::addEdge(const_reference source, const_reference destina
return true; return true;
} }
template <typename V, typename E, typename Alloc> template <typename V, typename E>
inline bool Graph<V, E, Alloc>::removeEdge(const_reference source, const_reference destination, E weight) inline bool Graph<V, E>::removeEdge(const_reference source, const_reference destination, E weight)
{ {
typename std::vector<Vertex>::iterator source_it = find(source); typename std::vector<Vertex>::iterator source_it = find(source);
if (source_it == m_vertices.end()) if (source_it == m_vertices.end())
@ -482,8 +451,8 @@ inline bool Graph<V, E, Alloc>::removeEdge(const_reference source, const_referen
return true; return true;
} }
template <typename V, typename E, typename Alloc> template <typename V, typename E>
inline bool Graph<V, E, Alloc>::removeAllEdges(const_reference source, const_reference destination) inline bool Graph<V, E>::removeAllEdges(const_reference source, const_reference destination)
{ {
typename std::vector<Vertex>::iterator source_it = find(source); typename std::vector<Vertex>::iterator source_it = find(source);
if (source_it == m_vertices.end()) if (source_it == m_vertices.end())
@ -500,8 +469,8 @@ inline bool Graph<V, E, Alloc>::removeAllEdges(const_reference source, const_ref
return true; return true;
} }
template <typename V, typename E, typename Alloc> template <typename V, typename E>
inline std::vector<typename Graph<V, E, Alloc>::pointer> Graph<V, E, Alloc>::vertices() const inline std::vector<typename Graph<V, E>::pointer> Graph<V, E>::vertices() const
{ {
std::vector<pointer> retval; std::vector<pointer> retval;
std::for_each(m_vertices.begin(), m_vertices.end(), std::for_each(m_vertices.begin(), m_vertices.end(),
@ -510,8 +479,8 @@ inline std::vector<typename Graph<V, E, Alloc>::pointer> Graph<V, E, Alloc>::ver
return retval; return retval;
} }
template <typename V, typename E, typename Alloc> template <typename V, typename E>
std::vector<typename Graph<V, E, Alloc>::pointer> Graph<V, E, Alloc>::neighboursOf(const_reference data) const std::vector<typename Graph<V, E>::pointer> Graph<V, E>::neighboursOf(const_reference data) const
{ {
typename std::vector<pointer> retval; typename std::vector<pointer> retval;
typename std::vector<Vertex >::const_iterator vertex_it = find(data); typename std::vector<Vertex >::const_iterator vertex_it = find(data);
@ -527,8 +496,8 @@ std::vector<typename Graph<V, E, Alloc>::pointer> Graph<V, E, Alloc>::neighbours
return retval; return retval;
} }
template <typename V, typename E, typename Alloc> template <typename V, typename E>
std::vector<E> Graph<V, E, Alloc>::edgesBetween(const_reference source, const_reference destination) const std::vector<E> Graph<V, E>::edgesBetween(const_reference source, const_reference destination) const
{ {
std::vector<E> retval; std::vector<E> retval;
typename std::vector<Vertex>::const_iterator vertex_it = find(source); typename std::vector<Vertex>::const_iterator vertex_it = find(source);
@ -543,10 +512,10 @@ std::vector<E> Graph<V, E, Alloc>::edgesBetween(const_reference source, const_re
return retval; return retval;
} }
template <typename V, typename E, typename Alloc> template <typename V, typename E>
inline std::vector<typename Graph<V, E, Alloc>::Edge> Graph<V, E, Alloc>::edges() const inline std::vector<typename Graph<V, E>::Edge> Graph<V, E>::edges() const
{ {
std::vector<typename Graph<V, E, Alloc>::Edge> retval; std::vector<typename Graph<V, E>::Edge> retval;
std::for_each(m_vertices.begin(), m_vertices.end(), std::for_each(m_vertices.begin(), m_vertices.end(),
[&retval](const Vertex& v) [&retval](const Vertex& v)
@ -558,16 +527,16 @@ inline std::vector<typename Graph<V, E, Alloc>::Edge> Graph<V, E, Alloc>::edges(
} }
template <typename V, typename E, typename Alloc> template <typename V, typename E>
inline typename std::vector<typename Graph<V, E, Alloc>::Vertex >::const_iterator Graph<V, E, Alloc>::find(const_reference data) const inline typename std::vector<typename Graph<V, E>::Vertex >::const_iterator Graph<V, E>::find(const_reference data) const
{ {
return std::find_if(m_vertices.begin(), m_vertices.end(), return std::find_if(m_vertices.begin(), m_vertices.end(),
[&data](const Vertex& v) [&data](const Vertex& v)
{ return *(v.m_data) == data; }); { return *(v.m_data) == data; });
} }
template <typename V, typename E, typename Alloc> template <typename V, typename E>
inline typename std::vector<typename Graph<V, E, Alloc>::Vertex >::iterator Graph<V, E, Alloc>::find(const_reference data) inline typename std::vector<typename Graph<V, E>::Vertex >::iterator Graph<V, E>::find(const_reference data)
{ {
return std::find_if(m_vertices.begin(), m_vertices.end(), return std::find_if(m_vertices.begin(), m_vertices.end(),
[&data](const Vertex& v) [&data](const Vertex& v)

Write Preview
Loading…
Cancel
Save