lemongraph 0.0.1

data/ext/lemongraph/node_map.cc

@@ -0,0 +1,1011 @@
+/* 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/>. 
+ */
+
+
+/* TODO:
+ * select, select!, reject, reject!
+ */
+
+
+#include <ruby.h>
+#include "lemongraph.hh"
+
+
+VALUE c_NodeMap;
+
+
+namespace LemonGraph {
+
+class NodeMap {
+private:
+	VALUE m_self;
+	VALUE m_graph;
+	VALUE m_default_value;
+	VALUE m_default_proc;
+	union {
+		lemon::ListDigraph::NodeMap<RBValue> *m_dinodemap;
+		lemon::ListGraph::NodeMap<RBValue>   *m_unnodemap;
+		void                                 *m_ptr;
+	};
+	bool  m_diunbar;
+public:
+	NodeMap();
+	~NodeMap();
+	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::Node& n);
+	RBValue& operator[](lemon::ListGraph::Node& n);
+	VALUE get(VALUE node);
+	void  set(VALUE node, VALUE value);
+	VALUE keys();
+	VALUE values();
+	VALUE length();
+	VALUE is_empty();
+	VALUE each_node();
+	VALUE each_value();
+	VALUE each_pair();
+	void  clear();
+	VALUE del(VALUE node);
+	VALUE del_if();
+	VALUE has_node(VALUE node);
+	VALUE has_value(VALUE val);
+	bool  is_equal(const NodeMap& other);
+	VALUE hash();
+	
+private:
+	void  check_key_di(VALUE node);
+	void  check_key_un(VALUE node);
+	VALUE value_or_default(VALUE val, VALUE nodekey);
+};
+
+
+NodeMap::NodeMap() :
+	m_self(Qnil),
+	m_graph(Qnil),
+	m_default_value(Qnil),
+	m_default_proc(Qnil),
+	m_ptr(NULL),
+	m_diunbar(false)
+{
+}
+
+
+NodeMap::~NodeMap()
+{
+	if (m_ptr) {
+		if (m_diunbar)
+			delete m_dinodemap;
+		else if (rb_class_of(m_graph) == c_Graph)
+			delete m_unnodemap;
+	}
+	m_ptr = NULL;
+}
+
+
+void NodeMap::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::NodeIt n(g); n != lemon::INVALID; ++n)
+			rb_gc_mark((*m_dinodemap)[n].value);
+	}
+	else if (rb_class_of(m_graph) == c_Graph) {
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		for (lemon::ListGraph::NodeIt n(g); n != lemon::INVALID; ++n)
+			rb_gc_mark((*m_unnodemap)[n].value);
+	}
+}
+
+
+void NodeMap::initialize(VALUE self, VALUE graph, VALUE default_value, VALUE default_proc)
+{
+	if (m_self != Qnil)
+		rb_raise(rb_eRuntimeError, "NodeMap 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_dinodemap = new lemon::ListDigraph::NodeMap<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_unnodemap = new lemon::ListGraph::NodeMap<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 NodeMap::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 NodeMap::value_or_default(VALUE val, VALUE nodekey)
+{
+	if (val == Qundef) {
+		if (m_default_proc != Qnil) {
+			VALUE args = rb_ary_new_from_args(2, nodekey, m_self);
+			val = rb_proc_call(m_default_proc, args);
+		}
+		else
+			val = m_default_value;
+	}
+	return val;
+}
+
+
+void NodeMap::check_key_di(VALUE node)
+{
+	if (rb_class_of(node) != c_DiNode) {
+		rb_raise(rb_eTypeError, "expecting a %" PRIsVALUE " as key, not a %s",
+				rb_class_name(c_DiNode), rb_obj_classname(node));
+	}
+	VALUE rbg = rb_iv_get(node, "@graph");
+	if (rbg != m_graph)
+		rb_raise(rb_eRuntimeError, "key node and node map do not belong to the same graph");
+}
+
+
+void NodeMap::check_key_un(VALUE node)
+{
+	if (rb_class_of(node) != c_UnNode) {
+		rb_raise(rb_eTypeError, "expecting a %" PRIsVALUE " as key, not a %s",
+				rb_class_name(c_UnNode), rb_obj_classname(node));
+	}
+	VALUE rbg = rb_iv_get(node, "@graph");
+	if (rbg != m_graph)
+		rb_raise(rb_eRuntimeError, "key node and node map do not belong to the same graph");
+}
+
+
+RBValue& NodeMap::operator[](lemon::ListDigraph::Node& n)
+{
+	if (!m_dinodemap)
+		rb_raise(rb_eRuntimeError, "accessing empty NodeMap");
+	return (*m_dinodemap)[n];
+}
+
+
+RBValue& NodeMap::operator[](lemon::ListGraph::Node& n)
+{
+	if (!m_unnodemap)
+		rb_raise(rb_eRuntimeError, "accessing empty NodeMap");
+	return (*m_unnodemap)[n];
+}
+
+
+VALUE NodeMap::get(VALUE node)
+{
+	VALUE v = Qundef;
+	if (m_diunbar) {
+		check_key_di(node);
+		lemon::ListDigraph::Node n = lemongraph_rbdinode2dinode(node);
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		if (!g.valid(n))
+			rb_raise(rb_eRuntimeError, "key node is not a valid node for its graph");
+		v = (*m_dinodemap)[n].value;
+	}
+	else {
+		check_key_un(node);
+		lemon::ListGraph::Node n = lemongraph_rbunnode2unnode(node);
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		if (!g.valid(n))
+			rb_raise(rb_eRuntimeError, "key node is not a valid node for its graph");
+		v = (*m_unnodemap)[n].value;
+	}
+	return value_or_default(v, node);
+}
+
+
+void NodeMap::set(VALUE node, VALUE value)
+{
+	if (m_diunbar) {
+		check_key_di(node);
+		lemon::ListDigraph::Node n = lemongraph_rbdinode2dinode(node);
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		if (!g.valid(n))
+			rb_raise(rb_eRuntimeError, "key node is not a valid node for its graph");
+		m_dinodemap->set(n, RBValue(value));
+	}
+	else {
+		check_key_un(node);
+		lemon::ListGraph::Node n = lemongraph_rbunnode2unnode(node);
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		if (!g.valid(n))
+			rb_raise(rb_eRuntimeError, "key node is not a valid node for its graph");
+		m_unnodemap->set(n, RBValue(value));
+	}
+}
+
+
+VALUE NodeMap::del(VALUE node)
+{
+	VALUE v = Qundef;
+	if (m_diunbar) {
+		check_key_di(node);
+		lemon::ListDigraph::Node n = lemongraph_rbdinode2dinode(node);
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		if (!g.valid(n))
+			rb_raise(rb_eRuntimeError, "key node is not a valid node for its graph");
+		v = (*m_dinodemap)[n].value;
+		m_dinodemap->set(n, Qundef);
+	}
+	else {
+		check_key_un(node);
+		lemon::ListGraph::Node n = lemongraph_rbunnode2unnode(node);
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		if (!g.valid(n))
+			rb_raise(rb_eRuntimeError, "key node is not a valid node for its graph");
+		v = (*m_unnodemap)[n].value;
+		m_unnodemap->set(n, Qundef);
+	}
+	return value_or_default(v, node);
+}
+
+
+VALUE NodeMap::has_node(VALUE node)
+{
+	VALUE klass = rb_class_of(node);
+	if (m_diunbar) {
+		if (klass != c_DiNode)
+			return Qfalse;
+		if (rb_iv_get(node, "@graph") != m_graph)
+			return Qfalse;
+		lemon::ListDigraph::Node n = lemongraph_rbdinode2dinode(node);
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		if (!g.valid(n))
+			return Qfalse;
+		if ((*m_dinodemap)[n].is_valid())
+			return Qtrue;
+	}
+	else {
+		if (klass != c_UnNode)
+			return Qfalse;
+		if (rb_iv_get(node, "@graph") != m_graph)
+			return Qfalse;
+		lemon::ListGraph::Node n = lemongraph_rbunnode2unnode(node);
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		if (!g.valid(n))
+			return Qfalse;
+		if ((*m_unnodemap)[n].is_valid())
+			return Qtrue;
+	}
+	return Qfalse;
+}
+
+
+VALUE NodeMap::has_value(VALUE value)
+{
+	if (m_diunbar) {
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		for (lemon::ListDigraph::NodeIt n(g); n != lemon::INVALID; ++n) {
+			VALUE v = (*m_dinodemap)[n].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::NodeIt n(g); n != lemon::INVALID; ++n) {
+			VALUE v = (*m_unnodemap)[n].value;
+			if (v != Qundef) {
+				if (rb_funcallv(v, id_eqeq, 1, &value) == Qtrue)
+					return Qtrue;
+			}
+		}
+	}
+	return Qfalse;
+}
+
+
+VALUE NodeMap::keys()
+{
+	int cnt = 0;
+	VALUE ar;
+	if (m_diunbar) {
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		for (lemon::ListDigraph::NodeIt n(g); n != lemon::INVALID; ++n) {
+			if ((*m_dinodemap)[n].is_valid())
+				cnt++;
+		}
+		ar = rb_ary_new_capa(cnt);
+		for (lemon::ListDigraph::NodeIt n(g); n != lemon::INVALID; ++n) {
+			if ((*m_dinodemap)[n].is_valid())
+				rb_ary_push(ar, lemongraph_make_dinode(n, m_graph));
+		}
+	}
+	else {
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		for (lemon::ListGraph::NodeIt n(g); n != lemon::INVALID; ++n) {
+			if ((*m_unnodemap)[n].is_valid())
+				cnt++;
+		}
+		ar = rb_ary_new_capa(cnt);
+		for (lemon::ListGraph::NodeIt n(g); n != lemon::INVALID; ++n) {
+			if ((*m_unnodemap)[n].is_valid())
+				rb_ary_push(ar, lemongraph_make_unnode(n, m_graph));
+		}
+	}
+	return ar;
+}
+
+
+VALUE NodeMap::values()
+{
+	int cnt = 0;
+	VALUE ar;
+	if (m_diunbar) {
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		for (lemon::ListDigraph::NodeIt n(g); n != lemon::INVALID; ++n) {
+			if ((*m_dinodemap)[n].is_valid())
+				cnt++;
+		}
+		ar = rb_ary_new_capa(cnt);
+		for (lemon::ListDigraph::NodeIt n(g); n != lemon::INVALID; ++n) {
+			if ((*m_dinodemap)[n].is_valid())
+				rb_ary_push(ar, (*m_dinodemap)[n].value);
+		}
+	}
+	else {
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		for (lemon::ListGraph::NodeIt n(g); n != lemon::INVALID; ++n) {
+			if ((*m_unnodemap)[n].is_valid())
+				cnt++;
+		}
+		ar = rb_ary_new_capa(cnt);
+		for (lemon::ListGraph::NodeIt n(g); n != lemon::INVALID; ++n) {
+			if ((*m_unnodemap)[n].is_valid())
+				rb_ary_push(ar, (*m_unnodemap)[n].value);
+		}
+	}
+	return ar;
+}
+
+
+VALUE NodeMap::length()
+{
+	int cnt = 0;
+	if (m_diunbar) {
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		for (lemon::ListDigraph::NodeIt n(g); n != lemon::INVALID; ++n) {
+			if ((*m_dinodemap)[n].is_valid())
+				cnt++;
+		}
+	}
+	else {
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		for (lemon::ListGraph::NodeIt n(g); n != lemon::INVALID; ++n) {
+			if ((*m_unnodemap)[n].is_valid())
+				cnt++;
+		}
+	}
+	return INT2NUM(cnt);
+}
+
+
+VALUE NodeMap::is_empty()
+{
+	if (m_diunbar) {
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		for (lemon::ListDigraph::NodeIt n(g); n != lemon::INVALID; ++n) {
+			if ((*m_dinodemap)[n].is_valid())
+				return Qfalse;
+		}
+	}
+	else {
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		for (lemon::ListGraph::NodeIt n(g); n != lemon::INVALID; ++n) {
+			if ((*m_unnodemap)[n].is_valid())
+				return Qfalse;
+		}
+	}
+	return Qtrue;
+}
+
+
+static VALUE lemongraph_nodemap_enum_length(VALUE obj, VALUE args, VALUE eobj)
+{
+	(void)args;
+	(void)eobj;
+	return lemongraph_nodemap_length(obj);
+}
+
+
+VALUE NodeMap::each_node()
+{
+	RETURN_SIZED_ENUMERATOR(m_self, 0, 0, lemongraph_nodemap_enum_length);
+	if (m_diunbar) {
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		for (lemon::ListDigraph::NodeIt n(g); n != lemon::INVALID; ++n) {
+			if ((*m_dinodemap)[n].is_valid())
+				rb_yield(lemongraph_make_dinode(n, m_graph));
+		}
+	}
+	else {
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		for (lemon::ListGraph::NodeIt n(g); n != lemon::INVALID; ++n) {
+			if ((*m_unnodemap)[n].is_valid())
+				rb_yield(lemongraph_make_unnode(n, m_graph));
+		}
+	}
+	return m_self;
+}
+
+
+VALUE NodeMap::each_value()
+{
+	RETURN_SIZED_ENUMERATOR(m_self, 0, 0, lemongraph_nodemap_enum_length);
+	if (m_diunbar) {
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		for (lemon::ListDigraph::NodeIt n(g); n != lemon::INVALID; ++n) {
+			VALUE v = (*m_dinodemap)[n].value;
+			if (v != Qundef)
+				rb_yield(v);
+		}
+	}
+	else {
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		for (lemon::ListGraph::NodeIt n(g); n != lemon::INVALID; ++n) {
+			VALUE v = (*m_unnodemap)[n].value;
+			if (v != Qundef)
+				rb_yield(v);
+		}
+	}
+	return m_self;
+}
+
+
+VALUE NodeMap::each_pair()
+{
+	RETURN_SIZED_ENUMERATOR(m_self, 0, 0, lemongraph_nodemap_enum_length);
+	if (m_diunbar) {
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		for (lemon::ListDigraph::NodeIt n(g); n != lemon::INVALID; ++n) {
+			VALUE v = (*m_dinodemap)[n].value;
+			if (v != Qundef)
+				rb_yield_values(2, lemongraph_make_dinode(n, m_graph), v);
+		}
+	}
+	else {
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		for (lemon::ListGraph::NodeIt n(g); n != lemon::INVALID; ++n) {
+			VALUE v = (*m_unnodemap)[n].value;
+			if (v != Qundef)
+				rb_yield_values(2, lemongraph_make_unnode(n, m_graph), v);
+		}
+	}
+	return m_self;
+}
+
+
+VALUE NodeMap::del_if()
+{
+	RETURN_SIZED_ENUMERATOR(m_self, 0, 0, lemongraph_nodemap_enum_length);
+	if (m_diunbar) {
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		for (lemon::ListDigraph::NodeIt n(g); n != lemon::INVALID; ++n) {
+			VALUE v = (*m_dinodemap)[n].value;
+			if (v != Qundef) {
+				VALUE b = rb_yield_values(2, lemongraph_make_dinode(n, m_graph), v);
+				if (b != Qnil && b != Qfalse)
+					m_dinodemap->set(n, Qundef);
+			}
+		}
+	}
+	else {
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		for (lemon::ListGraph::NodeIt n(g); n != lemon::INVALID; ++n) {
+			VALUE v = (*m_unnodemap)[n].value;
+			if (v != Qundef) {
+				VALUE b = rb_yield_values(2, lemongraph_make_unnode(n, m_graph), v);
+				if (b != Qnil && b != Qfalse)
+					m_unnodemap->set(n, Qundef);
+			}
+		}
+	}
+	return m_self;
+}
+
+
+void NodeMap::clear()
+{
+	if (m_diunbar) {
+		lemon::ListDigraph& g = lemongraph_digraph_rb2ref(m_graph);
+		for (lemon::ListDigraph::NodeIt n(g); n != lemon::INVALID; ++n)
+			m_dinodemap->set(n, Qundef);
+	}
+	else {
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		for (lemon::ListGraph::NodeIt n(g); n != lemon::INVALID; ++n)
+			m_unnodemap->set(n, Qundef);
+	}
+}
+
+
+bool NodeMap::is_equal(const NodeMap& 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::NodeIt n(g); n != lemon::INVALID; ++n) {
+			if ((*m_dinodemap)[n].value == Qundef) {
+				if ((*other.m_dinodemap)[n].value != Qundef)
+					return false;
+			}
+			else if (rb_funcall((*m_dinodemap)[n].value, id_eqeq, 1, (*other.m_dinodemap)[n].value) != Qtrue)
+				return false;
+		}
+	}
+	else {
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		for (lemon::ListGraph::NodeIt n(g); n != lemon::INVALID; ++n) {
+			if ((*m_unnodemap)[n].value == Qundef) {
+				if ((*other.m_unnodemap)[n].value != Qundef)
+					return false;
+			}
+			else if (rb_funcall((*m_unnodemap)[n].value, id_eqeq, 1, (*other.m_unnodemap)[n].value) != Qtrue)
+				return false;
+		}
+	}
+	return true;
+}
+
+
+VALUE NodeMap::hash()
+{
+	st_index_t size = NUM2INT(length());
+	st_index_t hval = rb_hash_start(size);
+	hval = rb_hash_uint(hval, (st_index_t)lemongraph_nodemap_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::NodeIt n(g); n != lemon::INVALID; ++n) {
+			VALUE v = (*m_dinodemap)[n].value;
+			if (v != Qundef) {
+				hval = rb_hash_uint(hval, lemon::ListDigraph::id(n));
+				hval = rb_hash_uint(hval, NUM2LONG(rb_hash(v)));
+			}
+		}
+	}
+	else {
+		lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+		for (lemon::ListGraph::NodeIt n(g); n != lemon::INVALID; ++n) {
+			VALUE v = (*m_unnodemap)[n].value;
+			if (v != Qundef) {
+				hval = rb_hash_uint(hval, lemon::ListGraph::id(n));
+				hval = rb_hash_uint(hval, NUM2LONG(rb_hash(v)));
+			}
+		}
+	}
+	hval = rb_hash_end(hval);
+	return ST2FIX(hval);
+}
+
+
+} // namespace LemonGraph
+
+
+static void lemongraph_nodemap_mark(void *p)
+{
+	LemonGraph::NodeMap *nm = (LemonGraph::NodeMap*)p;
+	nm->mark();
+}
+
+
+static void lemongraph_nodemap_free(void *p)
+{
+	LemonGraph::NodeMap *nm = (LemonGraph::NodeMap*)p;
+	delete nm;
+}
+
+
+static size_t lemongraph_nodemap_size(const void* p)
+{
+	return 0;
+}
+
+
+static const rb_data_type_t lemongraph_nodemap_type = {
+	.wrap_struct_name = "LemonGraph::NodeMap",
+	.function = {
+		.dmark = lemongraph_nodemap_mark,
+		.dfree = lemongraph_nodemap_free,
+		.dsize = lemongraph_nodemap_size,
+	},
+	.parent = NULL,
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+
+VALUE lemongraph_nodemap_alloc(VALUE klass)
+{
+	LemonGraph::NodeMap *nm = new LemonGraph::NodeMap();
+	return TypedData_Wrap_Struct(klass, &lemongraph_nodemap_type, nm);
+}
+
+
+static inline LemonGraph::NodeMap& lemongraph_nodemap_rb2ref(VALUE obj) {
+	LemonGraph::NodeMap *nm;
+	TypedData_Get_Struct(obj, LemonGraph::NodeMap, &lemongraph_nodemap_type, nm);
+	return *nm;
+}
+
+
+/* Returns a new node map related to _graph_.
+ *
+ * If no block is given, _default_value_ will be returned when 
+ * a value is fetched for a node for which no value was set.
+ *
+ * If a block is given, it will be called if needed
+ * to provide values for nodes for which no value was set, instead of returning _default_value_.
+ *
+ * @return [NodeMap]
+ * @overload initialize(graph, default_value = nil)
+ *  @param graph [Graph, Digraph] the graph this node map is to be bound to
+ *  @param default_value [Object] the default value returned for nodes with no value.
+ * @overload initialize(graph)
+ *  @param graph [Graph, Digraph] the graph this node map is to be bound to
+ *  @yieldparam node [Graph::Node,Digraph::Node] the node for which to provide a value
+ *  @yieldparam nodemap [NodeMap] _self_
+ *  @yieldreturn [Object] the default value returned for this _node_
+ */
+VALUE lemongraph_nodemap_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::NodeMap& nm = lemongraph_nodemap_rb2ref(self);
+	nm.initialize(self, rbg, dflt, proc);
+	return self;
+}
+
+
+
+/* Method called by _dup_ and _clone_ methods.
+ * @return [self]
+ */
+VALUE lemongraph_nodemap_initialize_copy(VALUE self, VALUE orig)
+{
+	rb_call_super(1, &orig);
+	LemonGraph::NodeMap& from = lemongraph_nodemap_rb2ref(orig);
+	LemonGraph::NodeMap& to   = lemongraph_nodemap_rb2ref(self);
+	to.initialize(self, from.graph(), from.default_value(), from.default_proc());
+	if (from.is_for_directed_graph()) {
+		for (lemon::ListDigraph::NodeIt n(lemongraph_digraph_rb2ref(from.graph())); n != lemon::INVALID; ++n) {
+			const LemonGraph::RBValue& v = from[n];
+			if (v.is_valid())
+				to[n] = v;
+		}
+	}
+	else {
+		for (lemon::ListGraph::NodeIt n(lemongraph_graph_rb2ref(from.graph())); n != lemon::INVALID; ++n) {
+			const LemonGraph::RBValue& v = from[n];
+			if (v.is_valid())
+				to[n] = v;
+		}
+	}
+	return self;
+}
+
+
+/* Returns the graph this node map is related to.
+ * @return [Graph,Digraph]
+ */
+VALUE lemongraph_nodemap_graph(VALUE self)
+{
+	LemonGraph::NodeMap& nm = lemongraph_nodemap_rb2ref(self);
+	return nm.graph();
+}
+
+
+/* Returns the default value set for this node map.
+ * @return [Object]
+ */
+VALUE lemongraph_nodemap_get_dflt_val(VALUE self)
+{
+	LemonGraph::NodeMap& nm = lemongraph_nodemap_rb2ref(self);
+	return nm.default_value();
+}
+
+
+/* Sets the default value for this node map.
+ */
+VALUE lemongraph_nodemap_set_dflt_val(VALUE self, VALUE dflt)
+{
+	LemonGraph::NodeMap& nm = lemongraph_nodemap_rb2ref(self);
+	nm.set_default_value(dflt);
+	return self;
+}
+
+
+/* Returns the default proc set for this node map.
+ * @return [Proc, nil]
+ */
+VALUE lemongraph_nodemap_get_dflt_proc(VALUE self)
+{
+	LemonGraph::NodeMap& nm = lemongraph_nodemap_rb2ref(self);
+	return nm.default_proc();
+}
+
+
+/* Sets the default proc for this node map.
+ *
+ * If set, the default proc is called when a value is fetched for a node
+ * which was not assigned a value.
+ * The proc parameters must be the node key and the node 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_nodemap_set_dflt_proc(VALUE self, VALUE proc)
+{
+	LemonGraph::NodeMap& nm = lemongraph_nodemap_rb2ref(self);
+	nm.set_default_proc(proc);
+	return self;
+}
+
+
+/* Returns the value associated with the given node key.
+ * @param key [Graph::Node,Digraph::Node]
+ * @return [Object]
+ */
+VALUE lemongraph_nodemap_get(VALUE self, VALUE key)
+{
+	LemonGraph::NodeMap& nm = lemongraph_nodemap_rb2ref(self);
+	return nm.get(key);
+}
+
+
+/* Associates the given value with the given node key; returns value.
+ * @param key [Graph::Node, Digraph::Node]
+ * @param value [Object]
+ */
+VALUE lemongraph_nodemap_set(VALUE self, VALUE key, VALUE value)
+{
+	LemonGraph::NodeMap& nm = lemongraph_nodemap_rb2ref(self);
+	nm.set(key, value);
+	return value;
+}
+
+
+/* Returns an array containing all node keys for which a value has been set.
+ * @return [Array<Graph::Node,Digraph::Node>]
+ */
+VALUE lemongraph_nodemap_nodes(VALUE self)
+{
+	LemonGraph::NodeMap& nm = lemongraph_nodemap_rb2ref(self);
+	return nm.keys();
+}
+
+
+/* Returns an array containing all values set for nodes.
+ * @return [Array<Object>]
+ */
+VALUE lemongraph_nodemap_values(VALUE self)
+{
+	LemonGraph::NodeMap& nm = lemongraph_nodemap_rb2ref(self);
+	return nm.values();
+}
+
+
+/* Return the count of entries in _slef_ for which a value has been set
+ * @return [Integer]
+ */
+VALUE lemongraph_nodemap_length(VALUE self)
+{
+	LemonGraph::NodeMap& nm = lemongraph_nodemap_rb2ref(self);
+	return nm.length();
+}
+
+
+/* Returns _true_ if there are no entries, _false_ otherwise
+ * @return [Boolean]
+ */
+VALUE lemongraph_nodemap_is_empty(VALUE self)
+{
+	LemonGraph::NodeMap& nm = lemongraph_nodemap_rb2ref(self);
+	return nm.is_empty();
+}
+
+
+/* Calls the block, if given, once for each node key for which a value has been set.
+ * The nodes are passed as parameters to the block.
+ *
+ * Returns _self_, or, if no block is given, an Enumerator is returned.
+ * @return [self, Enumerator]
+ * @overload each_node
+ *  @yieldparam node [Graph::Node,Digraph::Node]
+ *  @return [self]
+ * @overload each_node
+ *  @return [Enumerator]
+ */
+VALUE lemongraph_nodemap_each_node(VALUE self)
+{
+	LemonGraph::NodeMap& nm = lemongraph_nodemap_rb2ref(self);
+	return nm.each_node();
+}
+
+
+/* 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_nodemap_each_value(VALUE self)
+{
+	LemonGraph::NodeMap& nm = lemongraph_nodemap_rb2ref(self);
+	return nm.each_value();
+}
+
+
+/* Calls the block, if given, once for each node key and value pair.
+ * The nodes 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 node [Graph::Node,Digraph::Node]
+ *  @yieldparam value [Object]
+ *  @return [self]
+ * @overload each_pair
+ *  @return [Enumerator]
+ * @overload each
+ *  @yieldparam node [Graph::Node,Digraph::Node]
+ *  @yieldparam value [Object]
+ *  @return [self]
+ * @overload each
+ *  @return [Enumerator]
+ */
+VALUE lemongraph_nodemap_each_pair(VALUE self)
+{
+	LemonGraph::NodeMap& nm = lemongraph_nodemap_rb2ref(self);
+	return nm.each_pair();
+}
+
+
+/* Removes all values.
+ * @return [self]
+ */
+VALUE lemongraph_nodemap_clear(VALUE self)
+{
+	LemonGraph::NodeMap& nm = lemongraph_nodemap_rb2ref(self);
+	nm.clear();
+	return self;
+}
+
+
+/* Deletes the entry for the given node and returns its associated value, or the default one.
+ * @param key [Graph::Node,Digraph::Node]
+ */
+VALUE lemongraph_nodemap_delete(VALUE self, VALUE key)
+{
+	LemonGraph::NodeMap& nm = lemongraph_nodemap_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 node-value pair;
+ *  deletes each entry for which the block returns a truthy value;
+ *  returns self
+ *  @yieldparam node [Graph::Node,Digraph::Node]
+ *  @yieldparam value [Object]
+ *  @yieldreturn [Boolean] whether to delete or not the entry
+ *  @return [self]
+ * @overload delete_if
+ *  @return [Enumerator]
+ */
+VALUE lemongraph_nodemap_delete_if(VALUE self)
+{
+	LemonGraph::NodeMap& nm = lemongraph_nodemap_rb2ref(self);
+	return nm.del_if();
+}
+
+
+/* Returns _true_ if a value was set for _node_, otherwise _false_.
+ * @param node [Graph::Node,Digraph::Node]
+ * @return [Boolean]
+ */
+VALUE lemongraph_nodemap_has_node(VALUE self, VALUE node)
+{
+	LemonGraph::NodeMap& nm = lemongraph_nodemap_rb2ref(self);
+	return nm.has_node(node);
+}
+
+
+/* Returns _true_ if _value_ is a value in _self_, otherwise _false_.
+ * @return [Boolean]
+ */
+VALUE lemongraph_nodemap_has_value(VALUE self, VALUE value)
+{
+	LemonGraph::NodeMap& nm = lemongraph_nodemap_rb2ref(self);
+	return nm.has_value(value);
+}
+
+
+/* Returns _true_ if _other_ is a NodeMap 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_nodemap_is_equal(VALUE self, VALUE other)
+{
+	if (rb_obj_is_kind_of(other, c_NodeMap) != Qtrue)
+		return Qfalse;
+	LemonGraph::NodeMap& m = lemongraph_nodemap_rb2ref(self);
+	LemonGraph::NodeMap& o = lemongraph_nodemap_rb2ref(other);
+	return o.is_equal(m) ? Qtrue : Qfalse;
+}
+
+
+/* Returns the integer hash value for _self_.
+ * @return [Integer]
+ */
+VALUE lemongraph_nodemap_hash(VALUE self)
+{
+	LemonGraph::NodeMap& nm = lemongraph_nodemap_rb2ref(self);
+	return nm.hash();
+}
+
+