lemongraph 0.0.1

data/ext/lemongraph/arc_map.cc

@@ -0,0 +1,1007 @@
+/* Copyright (C) 2022 Théotime Bollengier <theotime.bollengier@ensta-bretagne.fr>
+ *
+ * This file is part of LemonGraph. <https://gitlab.ensta-bretagne.fr/bollenth/lemongraph>
+ *
+ * LemonGraph is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published
+ * by the Free Software Foundation, either version 3 of the License,
+ * or (at your option) any later version.
+ *
+ * LemonGraph is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LemonGraph. If not, see <https://www.gnu.org/licenses/>. 
+ */
+
+
+#include <ruby.h>
+#include "lemongraph.hh"
+
+
+VALUE c_ArcMap;
+
+
+namespace LemonGraph {
+
+class ArcMap {
+private:
+	VALUE m_self;
+	VALUE m_graph;
+	VALUE m_default_value;
+	VALUE m_default_proc;
+	union {
+		lemon::ListDigraph::ArcMap<RBValue> *m_diarcmap;
+		lemon::ListGraph::ArcMap<RBValue>   *m_unarcmap;
+		void                                *m_ptr;
+	};
+	bool  m_diunbar;
+public:
+	ArcMap();
+	~ArcMap();
+	void initialize(VALUE self, VALUE graph, VALUE default_value, VALUE default_proc);
+	void mark();
+	bool is_for_directed_graph() const { return m_diunbar; }
+	VALUE graph() const { return m_graph; }
+	VALUE default_value() const { return m_default_value; }
+	void  set_default_value(VALUE dflt) { m_default_value = dflt; }
+	VALUE default_proc() const { return m_default_proc; }
+	void  set_default_proc(VALUE prc);
+	RBValue& operator[](lemon::ListDigraph::Arc& a);
+	RBValue& operator[](lemon::ListGraph::Arc& a);
+	VALUE get(VALUE arc);
+	void  set(VALUE arc, VALUE value);
+	VALUE keys();
+	VALUE values();
+	VALUE length();
+	VALUE is_empty();
+	VALUE each_arc();
+	VALUE each_value();
+	VALUE each_pair();
+	void  clear();
+	VALUE del(VALUE arc);
+	VALUE del_if();
+	VALUE has_arc(VALUE arc);
+	VALUE has_value(VALUE val);
+	bool  is_equal(const ArcMap& other);
+	VALUE hash();
+	
+private:
+	void  check_key_di(VALUE arc);
+	void  check_key_un(VALUE arc);
+	VALUE value_or_default(VALUE val, VALUE arckey);
+};
+
+
+ArcMap::ArcMap() :
+	m_self(Qnil),
+	m_graph(Qnil),
+	m_default_value(Qnil),
+	m_default_proc(Qnil),
+	m_ptr(NULL),
+	m_diunbar(false)
+{
+}
+
+
+ArcMap::~ArcMap()
+{
+	if (m_ptr) {
+		if (m_diunbar)
+			delete m_diarcmap;
+		else if (rb_class_of(m_graph) == c_Graph)
+			delete m_unarcmap;
+	}
+	m_ptr = NULL;
+}
+
+
+void ArcMap::mark()
+{
+	rb_gc_mark(m_graph);
+	rb_gc_mark(m_default_value);
+	rb_gc_mark(m_default_proc);
+	if (!m_ptr)
+		return;
+	if (m_diunbar) {
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		for (lemon::ListDigraph::ArcIt a(g); a != lemon::INVALID; ++a)
+			rb_gc_mark((*m_diarcmap)[a].value);
+	}
+	else if (rb_class_of(m_graph) == c_Graph) {
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		for (lemon::ListGraph::ArcIt a(g); a != lemon::INVALID; ++a)
+			rb_gc_mark((*m_unarcmap)[a].value);
+	}
+}
+
+
+void ArcMap::initialize(VALUE self, VALUE graph, VALUE default_value, VALUE default_proc)
+{
+	if (m_self != Qnil)
+		rb_raise(rb_eRuntimeError, "ArcMap already initialized");
+	m_self = self;
+	m_graph = graph;
+	m_default_value = default_value;
+	m_default_proc = default_proc;
+	if (rb_obj_is_kind_of(m_graph, c_Digraph) == Qtrue) {
+		m_diunbar = true;
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		m_diarcmap = new lemon::ListDigraph::ArcMap<RBValue>(g);
+	}
+	else if (rb_obj_is_kind_of(m_graph, c_Graph) == Qtrue) {
+		m_diunbar = false;
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		m_unarcmap = new lemon::ListGraph::ArcMap<RBValue>(g);
+	}
+	else {
+		rb_raise(rb_eTypeError, "expecting a %" PRIsVALUE " or a %" PRIsVALUE ", not a %s",
+				rb_class_name(c_Digraph), rb_class_name(c_Graph), rb_obj_classname(m_graph));
+	}
+}
+
+
+void ArcMap::set_default_proc(VALUE prc)
+{
+	if (!rb_obj_is_kind_of(prc, rb_cProc) && prc != Qnil) {
+		rb_raise(rb_eTypeError, "expecting a %" PRIsVALUE ", not a %s",
+				rb_class_name(rb_cProc), rb_obj_classname(prc));
+	}
+	m_default_proc = prc;
+}
+
+
+VALUE ArcMap::value_or_default(VALUE val, VALUE arckey)
+{
+	if (val == Qundef) {
+		if (m_default_proc != Qnil) {
+			VALUE args = rb_ary_new_from_args(2, arckey, m_self);
+			val = rb_proc_call(m_default_proc, args);
+		}
+		else
+			val = m_default_value;
+	}
+	return val;
+}
+
+
+void ArcMap::check_key_di(VALUE arc)
+{
+	if (rb_class_of(arc) != c_DiArc) {
+		rb_raise(rb_eTypeError, "expecting a %" PRIsVALUE " as key, not a %s",
+				rb_class_name(c_DiArc), rb_obj_classname(arc));
+	}
+	VALUE rbg = rb_iv_get(arc, "@graph");
+	if (rbg != m_graph)
+		rb_raise(rb_eRuntimeError, "key arc and arc map do not belong to the same graph");
+}
+
+
+void ArcMap::check_key_un(VALUE arc)
+{
+	if (rb_class_of(arc) != c_UnArc) {
+		rb_raise(rb_eTypeError, "expecting a %" PRIsVALUE " as key, not a %s",
+				rb_class_name(c_UnArc), rb_obj_classname(arc));
+	}
+	VALUE rbg = rb_iv_get(arc, "@graph");
+	if (rbg != m_graph)
+		rb_raise(rb_eRuntimeError, "key arc and arc map do not belong to the same graph");
+}
+
+
+RBValue& ArcMap::operator[](lemon::ListDigraph::Arc& a)
+{
+	if (!m_diarcmap)
+		rb_raise(rb_eRuntimeError, "accessing empty ArcMap");
+	return (*m_diarcmap)[a];
+}
+
+
+RBValue& ArcMap::operator[](lemon::ListGraph::Arc& a)
+{
+	if (!m_unarcmap)
+		rb_raise(rb_eRuntimeError, "accessing empty ArcMap");
+	return (*m_unarcmap)[a];
+}
+
+
+VALUE ArcMap::get(VALUE arc)
+{
+	VALUE v = Qundef;
+	if (m_diunbar) {
+		check_key_di(arc);
+		lemon::ListDigraph::Arc a = lemongraph_rbdiarc2diarc(arc);
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		if (!g.valid(a))
+			rb_raise(rb_eRuntimeError, "key arc is not a valid arc for its graph");
+		v = (*m_diarcmap)[a].value;
+	}
+	else {
+		check_key_un(arc);
+		lemon::ListGraph::Arc a = lemongraph_rbunarc2unarc(arc);
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		if (!g.valid(a))
+			rb_raise(rb_eRuntimeError, "key arc is not a valid arc for its graph");
+		v = (*m_unarcmap)[a].value;
+	}
+	return value_or_default(v, arc);
+}
+
+
+void ArcMap::set(VALUE arc, VALUE value)
+{
+	if (m_diunbar) {
+		check_key_di(arc);
+		lemon::ListDigraph::Arc a = lemongraph_rbdiarc2diarc(arc);
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		if (!g.valid(a))
+			rb_raise(rb_eRuntimeError, "key arc is not a valid arc for its graph");
+		m_diarcmap->set(a, RBValue(value));
+	}
+	else {
+		check_key_un(arc);
+		lemon::ListGraph::Arc a = lemongraph_rbunarc2unarc(arc);
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		if (!g.valid(a))
+			rb_raise(rb_eRuntimeError, "key arc is not a valid arc for its graph");
+		m_unarcmap->set(a, RBValue(value));
+	}
+}
+
+
+VALUE ArcMap::del(VALUE arc)
+{
+	VALUE v = Qundef;
+	if (m_diunbar) {
+		check_key_di(arc);
+		lemon::ListDigraph::Arc a = lemongraph_rbdiarc2diarc(arc);
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		if (!g.valid(a))
+			rb_raise(rb_eRuntimeError, "key arc is not a valid arc for its graph");
+		v = (*m_diarcmap)[a].value;
+		m_diarcmap->set(a, Qundef);
+	}
+	else {
+		check_key_un(arc);
+		lemon::ListGraph::Arc a = lemongraph_rbunarc2unarc(arc);
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		if (!g.valid(a))
+			rb_raise(rb_eRuntimeError, "key arc is not a valid arc for its graph");
+		v = (*m_unarcmap)[a].value;
+		m_unarcmap->set(a, Qundef);
+	}
+	return value_or_default(v, arc);
+}
+
+
+VALUE ArcMap::has_arc(VALUE arc)
+{
+	VALUE klass = rb_class_of(arc);
+	if (m_diunbar) {
+		if (klass != c_DiArc)
+			return Qfalse;
+		if (rb_iv_get(arc, "@graph") != m_graph)
+			return Qfalse;
+		lemon::ListDigraph::Arc a = lemongraph_rbdiarc2diarc(arc);
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		if (!g.valid(a))
+			return Qfalse;
+		if ((*m_diarcmap)[a].is_valid())
+			return Qtrue;
+	}
+	else {
+		if (klass != c_UnArc)
+			return Qfalse;
+		if (rb_iv_get(arc, "@graph") != m_graph)
+			return Qfalse;
+		lemon::ListGraph::Arc a = lemongraph_rbunarc2unarc(arc);
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		if (!g.valid(a))
+			return Qfalse;
+		if ((*m_unarcmap)[a].is_valid())
+			return Qtrue;
+	}
+	return Qfalse;
+}
+
+
+VALUE ArcMap::has_value(VALUE value)
+{
+	if (m_diunbar) {
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		for (lemon::ListDigraph::ArcIt a(g); a != lemon::INVALID; ++a) {
+			VALUE v = (*m_diarcmap)[a].value;
+			if (v != Qundef) {
+				if (rb_funcallv(v, id_eqeq, 1, &value) == Qtrue)
+					return Qtrue;
+			}
+		}
+	}
+	else {
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		for (lemon::ListGraph::ArcIt a(g); a != lemon::INVALID; ++a) {
+			VALUE v = (*m_unarcmap)[a].value;
+			if (v != Qundef) {
+				if (rb_funcallv(v, id_eqeq, 1, &value) == Qtrue)
+					return Qtrue;
+			}
+		}
+	}
+	return Qfalse;
+}
+
+
+VALUE ArcMap::keys()
+{
+	int cnt = 0;
+	VALUE ar;
+	if (m_diunbar) {
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		for (lemon::ListDigraph::ArcIt a(g); a != lemon::INVALID; ++a) {
+			if ((*m_diarcmap)[a].is_valid())
+				cnt++;
+		}
+		ar = rb_ary_new_capa(cnt);
+		for (lemon::ListDigraph::ArcIt a(g); a != lemon::INVALID; ++a) {
+			if ((*m_diarcmap)[a].is_valid())
+				rb_ary_push(ar, lemongraph_make_diarc(a, m_graph));
+		}
+	}
+	else {
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		for (lemon::ListGraph::ArcIt a(g); a != lemon::INVALID; ++a) {
+			if ((*m_unarcmap)[a].is_valid())
+				cnt++;
+		}
+		ar = rb_ary_new_capa(cnt);
+		for (lemon::ListGraph::ArcIt a(g); a != lemon::INVALID; ++a) {
+			if ((*m_unarcmap)[a].is_valid())
+				rb_ary_push(ar, lemongraph_make_unarc(a, m_graph));
+		}
+	}
+	return ar;
+}
+
+
+VALUE ArcMap::values()
+{
+	int cnt = 0;
+	VALUE ar;
+	if (m_diunbar) {
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		for (lemon::ListDigraph::ArcIt a(g); a != lemon::INVALID; ++a) {
+			if ((*m_diarcmap)[a].is_valid())
+				cnt++;
+		}
+		ar = rb_ary_new_capa(cnt);
+		for (lemon::ListDigraph::ArcIt a(g); a != lemon::INVALID; ++a) {
+			if ((*m_diarcmap)[a].is_valid())
+				rb_ary_push(ar, (*m_diarcmap)[a].value);
+		}
+	}
+	else {
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		for (lemon::ListGraph::ArcIt a(g); a != lemon::INVALID; ++a) {
+			if ((*m_unarcmap)[a].is_valid())
+				cnt++;
+		}
+		ar = rb_ary_new_capa(cnt);
+		for (lemon::ListGraph::ArcIt a(g); a != lemon::INVALID; ++a) {
+			if ((*m_unarcmap)[a].is_valid())
+				rb_ary_push(ar, (*m_unarcmap)[a].value);
+		}
+	}
+	return ar;
+}
+
+
+VALUE ArcMap::length()
+{
+	int cnt = 0;
+	if (m_diunbar) {
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		for (lemon::ListDigraph::ArcIt a(g); a != lemon::INVALID; ++a) {
+			if ((*m_diarcmap)[a].is_valid())
+				cnt++;
+		}
+	}
+	else {
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		for (lemon::ListGraph::ArcIt a(g); a != lemon::INVALID; ++a) {
+			if ((*m_unarcmap)[a].is_valid())
+				cnt++;
+		}
+	}
+	return INT2NUM(cnt);
+}
+
+
+VALUE ArcMap::is_empty()
+{
+	if (m_diunbar) {
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		for (lemon::ListDigraph::ArcIt a(g); a != lemon::INVALID; ++a) {
+			if ((*m_diarcmap)[a].is_valid())
+				return Qfalse;
+		}
+	}
+	else {
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		for (lemon::ListGraph::ArcIt a(g); a != lemon::INVALID; ++a) {
+			if ((*m_unarcmap)[a].is_valid())
+				return Qfalse;
+		}
+	}
+	return Qtrue;
+}
+
+
+static VALUE lemongraph_arcmap_enum_length(VALUE obj, VALUE args, VALUE eobj)
+{
+	(void)args;
+	(void)eobj;
+	return lemongraph_arcmap_length(obj);
+}
+
+
+VALUE ArcMap::each_arc()
+{
+	RETURN_SIZED_ENUMERATOR(m_self, 0, 0, lemongraph_arcmap_enum_length);
+	if (m_diunbar) {
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		for (lemon::ListDigraph::ArcIt a(g); a != lemon::INVALID; ++a) {
+			if ((*m_diarcmap)[a].is_valid())
+				rb_yield(lemongraph_make_diarc(a, m_graph));
+		}
+	}
+	else {
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		for (lemon::ListGraph::ArcIt a(g); a != lemon::INVALID; ++a) {
+			if ((*m_unarcmap)[a].is_valid())
+				rb_yield(lemongraph_make_unarc(a, m_graph));
+		}
+	}
+	return m_self;
+}
+
+
+VALUE ArcMap::each_value()
+{
+	RETURN_SIZED_ENUMERATOR(m_self, 0, 0, lemongraph_arcmap_enum_length);
+	if (m_diunbar) {
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		for (lemon::ListDigraph::ArcIt a(g); a != lemon::INVALID; ++a) {
+			VALUE v = (*m_diarcmap)[a].value;
+			if (v != Qundef)
+				rb_yield(v);
+		}
+	}
+	else {
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		for (lemon::ListGraph::ArcIt a(g); a != lemon::INVALID; ++a) {
+			VALUE v = (*m_unarcmap)[a].value;
+			if (v != Qundef)
+				rb_yield(v);
+		}
+	}
+	return m_self;
+}
+
+
+VALUE ArcMap::each_pair()
+{
+	RETURN_SIZED_ENUMERATOR(m_self, 0, 0, lemongraph_arcmap_enum_length);
+	if (m_diunbar) {
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		for (lemon::ListDigraph::ArcIt a(g); a != lemon::INVALID; ++a) {
+			VALUE v = (*m_diarcmap)[a].value;
+			if (v != Qundef)
+				rb_yield_values(2, lemongraph_make_diarc(a, m_graph), v);
+		}
+	}
+	else {
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		for (lemon::ListGraph::ArcIt a(g); a != lemon::INVALID; ++a) {
+			VALUE v = (*m_unarcmap)[a].value;
+			if (v != Qundef)
+				rb_yield_values(2, lemongraph_make_unarc(a, m_graph), v);
+		}
+	}
+	return m_self;
+}
+
+
+VALUE ArcMap::del_if()
+{
+	RETURN_SIZED_ENUMERATOR(m_self, 0, 0, lemongraph_arcmap_enum_length);
+	if (m_diunbar) {
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		for (lemon::ListDigraph::ArcIt a(g); a != lemon::INVALID; ++a) {
+			VALUE v = (*m_diarcmap)[a].value;
+			if (v != Qundef) {
+				VALUE b = rb_yield_values(2, lemongraph_make_diarc(a, m_graph), v);
+				if (b != Qnil && b != Qfalse)
+					m_diarcmap->set(a, Qundef);
+			}
+		}
+	}
+	else {
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		for (lemon::ListGraph::ArcIt a(g); a != lemon::INVALID; ++a) {
+			VALUE v = (*m_unarcmap)[a].value;
+			if (v != Qundef) {
+				VALUE b = rb_yield_values(2, lemongraph_make_unarc(a, m_graph), v);
+				if (b != Qnil && b != Qfalse)
+					m_unarcmap->set(a, Qundef);
+			}
+		}
+	}
+	return m_self;
+}
+
+
+void ArcMap::clear()
+{
+	if (m_diunbar) {
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		for (lemon::ListDigraph::ArcIt a(g); a != lemon::INVALID; ++a)
+			m_diarcmap->set(a, Qundef);
+	}
+	else {
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		for (lemon::ListGraph::ArcIt a(g); a != lemon::INVALID; ++a)
+			m_unarcmap->set(a, Qundef);
+	}
+}
+
+
+bool ArcMap::is_equal(const ArcMap& other)
+{
+	if (other.m_graph != m_graph)
+		return false;
+	if (other.m_diunbar != m_diunbar)
+		return false;
+	if (rb_funcallv(other.m_default_value, id_eqeq, 1, &m_default_value) != Qtrue)
+		return false;
+	if (rb_funcallv(other.m_default_proc, id_eqeq, 1, &m_default_proc) != Qtrue)
+		return false;
+	if (m_diunbar) {
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		for (lemon::ListDigraph::ArcIt a(g); a != lemon::INVALID; ++a) {
+			if ((*m_diarcmap)[a].value == Qundef) {
+				if ((*other.m_diarcmap)[a].value != Qundef)
+					return false;
+			}
+			else if (rb_funcall((*m_diarcmap)[a].value, id_eqeq, 1, (*other.m_diarcmap)[a].value) != Qtrue)
+				return false;
+		}
+	}
+	else {
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		for (lemon::ListGraph::ArcIt a(g); a != lemon::INVALID; ++a) {
+			if ((*m_unarcmap)[a].value == Qundef) {
+				if ((*other.m_unarcmap)[a].value != Qundef)
+					return false;
+			}
+			else if (rb_funcall((*m_unarcmap)[a].value, id_eqeq, 1, (*other.m_unarcmap)[a].value) != Qtrue)
+				return false;
+		}
+	}
+	return true;
+}
+
+
+VALUE ArcMap::hash()
+{
+	st_index_t size = NUM2INT(length());
+	st_index_t hval = rb_hash_start(size);
+	hval = rb_hash_uint(hval, (st_index_t)lemongraph_arcmap_hash);
+	hval = rb_hash_uint(hval, NUM2LONG(rb_hash(m_graph)));
+	hval = rb_hash_uint(hval, NUM2LONG(rb_hash(m_default_value)));
+	hval = rb_hash_uint(hval, NUM2LONG(rb_hash(m_default_proc)));
+	if (m_diunbar) {
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		for (lemon::ListDigraph::ArcIt a(g); a != lemon::INVALID; ++a) {
+			VALUE v = (*m_diarcmap)[a].value;
+			if (v != Qundef) {
+				hval = rb_hash_uint(hval, lemon::ListDigraph::id(a));
+				hval = rb_hash_uint(hval, NUM2LONG(rb_hash(v)));
+			}
+		}
+	}
+	else {
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		for (lemon::ListGraph::ArcIt a(g); a != lemon::INVALID; ++a) {
+			VALUE v = (*m_unarcmap)[a].value;
+			if (v != Qundef) {
+				hval = rb_hash_uint(hval, lemon::ListGraph::id(a));
+				hval = rb_hash_uint(hval, NUM2LONG(rb_hash(v)));
+			}
+		}
+	}
+	hval = rb_hash_end(hval);
+	return ST2FIX(hval);
+}
+
+
+} // namespace LemonGraph
+
+
+static void lemongraph_arcmap_mark(void *p)
+{
+	LemonGraph::ArcMap *nm = (LemonGraph::ArcMap*)p;
+	nm->mark();
+}
+
+
+static void lemongraph_arcmap_free(void *p)
+{
+	LemonGraph::ArcMap *nm = (LemonGraph::ArcMap*)p;
+	delete nm;
+}
+
+
+static size_t lemongraph_arcmap_size(const void* p)
+{
+	return 0;
+}
+
+
+static const rb_data_type_t lemongraph_arcmap_type = {
+	.wrap_struct_name = "LemonGraph::ArcMap",
+	.function = {
+		.dmark = lemongraph_arcmap_mark,
+		.dfree = lemongraph_arcmap_free,
+		.dsize = lemongraph_arcmap_size,
+	},
+	.parent = NULL,
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+
+VALUE lemongraph_arcmap_alloc(VALUE klass)
+{
+	LemonGraph::ArcMap *nm = new LemonGraph::ArcMap();
+	return TypedData_Wrap_Struct(klass, &lemongraph_arcmap_type, nm);
+}
+
+
+static inline LemonGraph::ArcMap& lemongraph_arcmap_rb2ref(VALUE obj) {
+	LemonGraph::ArcMap *nm;
+	TypedData_Get_Struct(obj, LemonGraph::ArcMap, &lemongraph_arcmap_type, nm);
+	return *nm;
+}
+
+
+/* Returns a new arc map related to _graph_.
+ *
+ * If no block is given, _default_value_ will be returned when 
+ * a value is fetched for a arc for which no value was set.
+ *
+ * If a block is given, it will be called if needed
+ * to provide values for arcs for which no value was set, instead of returning _default_value_.
+ *
+ * @return [ArcMap]
+ * @overload initialize(graph, default_value = nil)
+ *  @param graph [Graph, Digraph] the graph this arc map is to be bound to
+ *  @param default_value [Object] the default value returned for arcs with no value.
+ * @overload initialize(graph)
+ *  @param graph [Graph, Digraph] the graph this arc map is to be bound to
+ *  @yieldparam arc [Graph::Arc,Digraph::Arc] the arc for which to provide a value
+ *  @yieldparam arcmap [ArcMap] _self_
+ *  @yieldreturn [Object] the default value returned for this _arc_
+ */
+VALUE lemongraph_arcmap_initialize(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rbg; 
+	VALUE dflt = Qnil;
+	VALUE proc = Qnil;
+	rb_scan_args(argc, argv, "11&", &rbg, &dflt, &proc);
+	LemonGraph::ArcMap& nm = lemongraph_arcmap_rb2ref(self);
+	nm.initialize(self, rbg, dflt, proc);
+	return self;
+}
+
+
+
+/* Method called by _dup_ and _clone_ methods.
+ * @return [self]
+ */
+VALUE lemongraph_arcmap_initialize_copy(VALUE self, VALUE orig)
+{
+	rb_call_super(1, &orig);
+	LemonGraph::ArcMap& from = lemongraph_arcmap_rb2ref(orig);
+	LemonGraph::ArcMap& to   = lemongraph_arcmap_rb2ref(self);
+	to.initialize(self, from.graph(), from.default_value(), from.default_proc());
+	if (from.is_for_directed_graph()) {
+		for (lemon::ListDigraph::ArcIt a(lemongraph_digraph_rb2ref(from.graph())); a != lemon::INVALID; ++a) {
+			const LemonGraph::RBValue& v = from[a];
+			if (v.is_valid())
+				to[a] = v;
+		}
+	}
+	else {
+		for (lemon::ListGraph::ArcIt a(lemongraph_graph_rb2ref(from.graph())); a != lemon::INVALID; ++a) {
+			const LemonGraph::RBValue& v = from[a];
+			if (v.is_valid())
+				to[a] = v;
+		}
+	}
+	return self;
+}
+
+
+/* Returns the graph this arc map is related to.
+ * @return [Graph,Digraph]
+ */
+VALUE lemongraph_arcmap_graph(VALUE self)
+{
+	LemonGraph::ArcMap& nm = lemongraph_arcmap_rb2ref(self);
+	return nm.graph();
+}
+
+
+/* Returns the default value set for this arc map.
+ * @return [Object]
+ */
+VALUE lemongraph_arcmap_get_dflt_val(VALUE self)
+{
+	LemonGraph::ArcMap& nm = lemongraph_arcmap_rb2ref(self);
+	return nm.default_value();
+}
+
+
+/* Sets the default value for this arc map.
+ */
+VALUE lemongraph_arcmap_set_dflt_val(VALUE self, VALUE dflt)
+{
+	LemonGraph::ArcMap& nm = lemongraph_arcmap_rb2ref(self);
+	nm.set_default_value(dflt);
+	return self;
+}
+
+
+/* Returns the default proc set for this arc map.
+ * @return [Proc, nil]
+ */
+VALUE lemongraph_arcmap_get_dflt_proc(VALUE self)
+{
+	LemonGraph::ArcMap& nm = lemongraph_arcmap_rb2ref(self);
+	return nm.default_proc();
+}
+
+
+/* Sets the default proc for this arc map.
+ *
+ * If set, the default proc is called when a value is fetched for a arc
+ * which was not assigned a value.
+ * The proc parameters must be the arc key and the arc map.
+ *
+ * Set to _nil_ to reset it so that the default value is returned 
+ * when needed instead of calling the default proc.
+ * @param proc [Proc, nil]
+ */
+VALUE lemongraph_arcmap_set_dflt_proc(VALUE self, VALUE proc)
+{
+	LemonGraph::ArcMap& nm = lemongraph_arcmap_rb2ref(self);
+	nm.set_default_proc(proc);
+	return self;
+}
+
+
+/* Returns the value associated with the given arc key.
+ * @param key [Graph::Arc,Digraph::Arc]
+ * @return [Object]
+ */
+VALUE lemongraph_arcmap_get(VALUE self, VALUE key)
+{
+	LemonGraph::ArcMap& nm = lemongraph_arcmap_rb2ref(self);
+	return nm.get(key);
+}
+
+
+/* Associates the given value with the given arc key; returns value.
+ * @param key [Graph::Arc, Digraph::Arc]
+ * @param value [Object]
+ */
+VALUE lemongraph_arcmap_set(VALUE self, VALUE key, VALUE value)
+{
+	LemonGraph::ArcMap& nm = lemongraph_arcmap_rb2ref(self);
+	nm.set(key, value);
+	return value;
+}
+
+
+/* Returns an array containing all arc keys for which a value has been set.
+ * @return [Array<Graph::Arc,Digraph::Arc>]
+ */
+VALUE lemongraph_arcmap_arcs(VALUE self)
+{
+	LemonGraph::ArcMap& nm = lemongraph_arcmap_rb2ref(self);
+	return nm.keys();
+}
+
+
+/* Returns an array containing all values set for arcs.
+ * @return [Array<Object>]
+ */
+VALUE lemongraph_arcmap_values(VALUE self)
+{
+	LemonGraph::ArcMap& nm = lemongraph_arcmap_rb2ref(self);
+	return nm.values();
+}
+
+
+/* Return the count of entries in _slef_ for which a value has been set
+ * @return [Integer]
+ */
+VALUE lemongraph_arcmap_length(VALUE self)
+{
+	LemonGraph::ArcMap& nm = lemongraph_arcmap_rb2ref(self);
+	return nm.length();
+}
+
+
+/* Returns _true_ if there are no entries, _false_ otherwise
+ * @return [Boolean]
+ */
+VALUE lemongraph_arcmap_is_empty(VALUE self)
+{
+	LemonGraph::ArcMap& nm = lemongraph_arcmap_rb2ref(self);
+	return nm.is_empty();
+}
+
+
+/* Calls the block, if given, once for each arc key for which a value has been set.
+ * The arcs are passed as parameters to the block.
+ *
+ * Returns _self_, or, if no block is given, an Enumerator is returned.
+ * @return [self, Enumerator]
+ * @overload each_arc
+ *  @yieldparam arc [Graph::Arc,Digraph::Arc]
+ *  @return [self]
+ * @overload each_arc
+ *  @return [Enumerator]
+ */
+VALUE lemongraph_arcmap_each_arc(VALUE self)
+{
+	LemonGraph::ArcMap& nm = lemongraph_arcmap_rb2ref(self);
+	return nm.each_arc();
+}
+
+
+/* Calls the block, if given, once for each value that has been set.
+ * The values are passed as parameters to the block.
+ *
+ * Returns _self_, or, if no block is given, an Enumerator is returned.
+ * @return [self, Enumerator]
+ * @overload each_value
+ *  @yieldparam value [Object]
+ *  @return [self]
+ * @overload each_value
+ *  @return [Enumerator]
+ */
+VALUE lemongraph_arcmap_each_value(VALUE self)
+{
+	LemonGraph::ArcMap& nm = lemongraph_arcmap_rb2ref(self);
+	return nm.each_value();
+}
+
+
+/* Calls the block, if given, once for each arc key and value pair.
+ * The arcs and values are passed as parameters to the block.
+ *
+ * Returns _self_, or, if no block is given, an Enumerator is returned.
+ * @return [self, Enumerator]
+ * @overload each_pair
+ *  @yieldparam arc [Graph::Arc,Digraph::Arc]
+ *  @yieldparam value [Object]
+ *  @return [self]
+ * @overload each_pair
+ *  @return [Enumerator]
+ * @overload each
+ *  @yieldparam arc [Graph::Arc,Digraph::Arc]
+ *  @yieldparam value [Object]
+ *  @return [self]
+ * @overload each
+ *  @return [Enumerator]
+ */
+VALUE lemongraph_arcmap_each_pair(VALUE self)
+{
+	LemonGraph::ArcMap& nm = lemongraph_arcmap_rb2ref(self);
+	return nm.each_pair();
+}
+
+
+/* Removes all values.
+ * @return [self]
+ */
+VALUE lemongraph_arcmap_clear(VALUE self)
+{
+	LemonGraph::ArcMap& nm = lemongraph_arcmap_rb2ref(self);
+	nm.clear();
+	return self;
+}
+
+
+/* Deletes the entry for the given arc and returns its associated value, or the default one.
+ * @param key [Graph::Arc,Digraph::Arc]
+ */
+VALUE lemongraph_arcmap_delete(VALUE self, VALUE key)
+{
+	LemonGraph::ArcMap& nm = lemongraph_arcmap_rb2ref(self);
+	return nm.del(key);
+}
+
+
+/* Delete entries for which the block returns a truthy value.
+ * Returns _self_, or, if no block is given, an Enumerator is returned.
+ *
+ * @return [self, Enumerator]
+ * @overload delete_if
+ *  Calls the block with each arc-value pair;
+ *  deletes each entry for which the block returns a truthy value;
+ *  returns self
+ *  @yieldparam arc [Graph::Arc,Digraph::Arc]
+ *  @yieldparam value [Object]
+ *  @yieldreturn [Boolean] whether to delete or not the entry
+ *  @return [self]
+ * @overload delete_if
+ *  @return [Enumerator]
+ */
+VALUE lemongraph_arcmap_delete_if(VALUE self)
+{
+	LemonGraph::ArcMap& nm = lemongraph_arcmap_rb2ref(self);
+	return nm.del_if();
+}
+
+
+/* Returns _true_ if a value was set for _arc_, otherwise _false_.
+ * @param arc [Graph::Arc,Digraph::Arc]
+ * @return [Boolean]
+ */
+VALUE lemongraph_arcmap_has_arc(VALUE self, VALUE arc)
+{
+	LemonGraph::ArcMap& nm = lemongraph_arcmap_rb2ref(self);
+	return nm.has_arc(arc);
+}
+
+
+/* Returns _true_ if _value_ is a value in _self_, otherwise _false_.
+ * @return [Boolean]
+ */
+VALUE lemongraph_arcmap_has_value(VALUE self, VALUE value)
+{
+	LemonGraph::ArcMap& nm = lemongraph_arcmap_rb2ref(self);
+	return nm.has_value(value);
+}
+
+
+/* Returns _true_ if _other_ is a ArcMap and share the same graph, default value and proc as _self_ 
+ * and and all entries from _other_ and _self_ are equal (==).
+ * @return [Boolean]
+ */
+VALUE lemongraph_arcmap_is_equal(VALUE self, VALUE other)
+{
+	if (rb_obj_is_kind_of(other, c_ArcMap) != Qtrue)
+		return Qfalse;
+	LemonGraph::ArcMap& m = lemongraph_arcmap_rb2ref(self);
+	LemonGraph::ArcMap& o = lemongraph_arcmap_rb2ref(other);
+	return o.is_equal(m) ? Qtrue : Qfalse;
+}
+
+
+/* Returns the integer hash value for _self_.
+ * @return [Integer]
+ */
+VALUE lemongraph_arcmap_hash(VALUE self)
+{
+	LemonGraph::ArcMap& nm = lemongraph_arcmap_rb2ref(self);
+	return nm.hash();
+}
+
+
+