lemongraph 0.0.1

data/ext/lemongraph/edge_map.cc

@@ -0,0 +1,770 @@
+/* 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_EdgeMap;
+
+
+namespace LemonGraph {
+
+class EdgeMap {
+private:
+	VALUE m_self;
+	VALUE m_graph;
+	VALUE m_default_value;
+	VALUE m_default_proc;
+	lemon::ListGraph::EdgeMap<RBValue>   *m_unedgemap;
+public:
+	EdgeMap();
+	~EdgeMap();
+	void initialize(VALUE self, VALUE graph, VALUE default_value, VALUE default_proc);
+	void mark();
+	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::ListGraph::Edge& e);
+	VALUE get(VALUE edge);
+	void  set(VALUE edge, VALUE value);
+	VALUE keys();
+	VALUE values();
+	VALUE length();
+	VALUE is_empty();
+	VALUE each_edge();
+	VALUE each_value();
+	VALUE each_pair();
+	void  clear();
+	VALUE del(VALUE edge);
+	VALUE del_if();
+	VALUE has_edge(VALUE edge);
+	VALUE has_value(VALUE val);
+	bool  is_equal(const EdgeMap& other);
+	VALUE hash();
+	
+private:
+	void  check_key_un(VALUE edge);
+	VALUE value_or_default(VALUE val, VALUE edgekey);
+};
+
+
+EdgeMap::EdgeMap() :
+	m_self(Qnil),
+	m_graph(Qnil),
+	m_default_value(Qnil),
+	m_default_proc(Qnil),
+	m_unedgemap(NULL)
+{
+}
+
+
+EdgeMap::~EdgeMap()
+{
+	if (m_unedgemap)
+		delete m_unedgemap;
+	m_unedgemap = NULL;
+}
+
+
+void EdgeMap::mark()
+{
+	rb_gc_mark(m_graph);
+	rb_gc_mark(m_default_value);
+	rb_gc_mark(m_default_proc);
+	if (!m_unedgemap)
+		return;
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+	for (lemon::ListGraph::EdgeIt e(g); e != lemon::INVALID; ++e)
+		rb_gc_mark((*m_unedgemap)[e].value);
+}
+
+
+void EdgeMap::initialize(VALUE self, VALUE graph, VALUE default_value, VALUE default_proc)
+{
+	if (m_self != Qnil)
+		rb_raise(rb_eRuntimeError, "EdgeMap 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_Graph) != Qtrue) {
+		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));
+	}
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+	m_unedgemap = new lemon::ListGraph::EdgeMap<RBValue>(g);
+}
+
+
+void EdgeMap::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 EdgeMap::value_or_default(VALUE val, VALUE edgekey)
+{
+	if (val == Qundef) {
+		if (m_default_proc != Qnil) {
+			VALUE args = rb_ary_new_from_args(2, edgekey, m_self);
+			val = rb_proc_call(m_default_proc, args);
+		}
+		else
+			val = m_default_value;
+	}
+	return val;
+}
+
+
+void EdgeMap::check_key_un(VALUE edge)
+{
+	if (rb_class_of(edge) != c_UnEdge) {
+		rb_raise(rb_eTypeError, "expecting a %" PRIsVALUE " as key, not a %s",
+				rb_class_name(c_UnEdge), rb_obj_classname(edge));
+	}
+	VALUE rbg = rb_iv_get(edge, "@graph");
+	if (rbg != m_graph)
+		rb_raise(rb_eRuntimeError, "key edge and edge map do not belong to the same graph");
+}
+
+
+RBValue& EdgeMap::operator[](lemon::ListGraph::Edge& e)
+{
+	if (!m_unedgemap)
+		rb_raise(rb_eRuntimeError, "accessing empty EdgeMap");
+	return (*m_unedgemap)[e];
+}
+
+
+VALUE EdgeMap::get(VALUE edge)
+{
+	VALUE v = Qundef;
+	check_key_un(edge);
+	lemon::ListGraph::Edge e = lemongraph_rbunedge2unedge(edge);
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+	if (!g.valid(e))
+		rb_raise(rb_eRuntimeError, "key edge is not a valid edge for its graph");
+	v = (*m_unedgemap)[e].value;
+	return value_or_default(v, edge);
+}
+
+
+void EdgeMap::set(VALUE edge, VALUE value)
+{
+	check_key_un(edge);
+	lemon::ListGraph::Edge e = lemongraph_rbunedge2unedge(edge);
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+	if (!g.valid(e))
+		rb_raise(rb_eRuntimeError, "key edge is not a valid edge for its graph");
+	m_unedgemap->set(e, RBValue(value));
+}
+
+
+VALUE EdgeMap::del(VALUE edge)
+{
+	VALUE v = Qundef;
+	check_key_un(edge);
+	lemon::ListGraph::Edge e = lemongraph_rbunedge2unedge(edge);
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+	if (!g.valid(e))
+		rb_raise(rb_eRuntimeError, "key edge is not a valid edge for its graph");
+	v = (*m_unedgemap)[e].value;
+	m_unedgemap->set(e, Qundef);
+	return value_or_default(v, edge);
+}
+
+
+VALUE EdgeMap::has_edge(VALUE edge)
+{
+	VALUE klass = rb_class_of(edge);
+	if (klass != c_UnEdge)
+		return Qfalse;
+	if (rb_iv_get(edge, "@graph") != m_graph)
+		return Qfalse;
+	lemon::ListGraph::Edge e = lemongraph_rbunedge2unedge(edge);
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+	if (!g.valid(e))
+		return Qfalse;
+	if ((*m_unedgemap)[e].is_valid())
+		return Qtrue;
+	return Qfalse;
+}
+
+
+VALUE EdgeMap::has_value(VALUE value)
+{
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+	for (lemon::ListGraph::EdgeIt e(g); e != lemon::INVALID; ++e) {
+		VALUE v = (*m_unedgemap)[e].value;
+		if (v != Qundef) {
+			if (rb_funcallv(v, id_eqeq, 1, &value) == Qtrue)
+				return Qtrue;
+		}
+	}
+	return Qfalse;
+}
+
+
+VALUE EdgeMap::keys()
+{
+	int cnt = 0;
+	VALUE ar;
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+	for (lemon::ListGraph::EdgeIt e(g); e != lemon::INVALID; ++e) {
+		if ((*m_unedgemap)[e].is_valid())
+			cnt++;
+	}
+	ar = rb_ary_new_capa(cnt);
+	for (lemon::ListGraph::EdgeIt e(g); e != lemon::INVALID; ++e) {
+		if ((*m_unedgemap)[e].is_valid())
+			rb_ary_push(ar, lemongraph_make_unedge(e, m_graph));
+	}
+	return ar;
+}
+
+
+VALUE EdgeMap::values()
+{
+	int cnt = 0;
+	VALUE ar;
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+	for (lemon::ListGraph::EdgeIt e(g); e != lemon::INVALID; ++e) {
+		if ((*m_unedgemap)[e].is_valid())
+			cnt++;
+	}
+	ar = rb_ary_new_capa(cnt);
+	for (lemon::ListGraph::EdgeIt e(g); e != lemon::INVALID; ++e) {
+		if ((*m_unedgemap)[e].is_valid())
+			rb_ary_push(ar, (*m_unedgemap)[e].value);
+	}
+	return ar;
+}
+
+
+VALUE EdgeMap::length()
+{
+	int cnt = 0;
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+	for (lemon::ListGraph::EdgeIt e(g); e != lemon::INVALID; ++e) {
+		if ((*m_unedgemap)[e].is_valid())
+			cnt++;
+	}
+	return INT2NUM(cnt);
+}
+
+
+VALUE EdgeMap::is_empty()
+{
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+	for (lemon::ListGraph::EdgeIt e(g); e != lemon::INVALID; ++e) {
+		if ((*m_unedgemap)[e].is_valid())
+			return Qfalse;
+	}
+	return Qtrue;
+}
+
+
+static VALUE lemongraph_edgemap_enum_length(VALUE obj, VALUE args, VALUE eobj)
+{
+	(void)args;
+	(void)eobj;
+	return lemongraph_edgemap_length(obj);
+}
+
+
+VALUE EdgeMap::each_edge()
+{
+	RETURN_SIZED_ENUMERATOR(m_self, 0, 0, lemongraph_edgemap_enum_length);
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+	for (lemon::ListGraph::EdgeIt e(g); e != lemon::INVALID; ++e) {
+		if ((*m_unedgemap)[e].is_valid())
+			rb_yield(lemongraph_make_unedge(e, m_graph));
+	}
+	return m_self;
+}
+
+
+VALUE EdgeMap::each_value()
+{
+	RETURN_SIZED_ENUMERATOR(m_self, 0, 0, lemongraph_edgemap_enum_length);
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+	for (lemon::ListGraph::EdgeIt e(g); e != lemon::INVALID; ++e) {
+		VALUE v = (*m_unedgemap)[e].value;
+		if (v != Qundef)
+			rb_yield(v);
+	}
+	return m_self;
+}
+
+
+VALUE EdgeMap::each_pair()
+{
+	RETURN_SIZED_ENUMERATOR(m_self, 0, 0, lemongraph_edgemap_enum_length);
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+	for (lemon::ListGraph::EdgeIt e(g); e != lemon::INVALID; ++e) {
+		VALUE v = (*m_unedgemap)[e].value;
+		if (v != Qundef)
+			rb_yield_values(2, lemongraph_make_unedge(e, m_graph), v);
+	}
+	return m_self;
+}
+
+
+VALUE EdgeMap::del_if()
+{
+	RETURN_SIZED_ENUMERATOR(m_self, 0, 0, lemongraph_edgemap_enum_length);
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+	for (lemon::ListGraph::EdgeIt e(g); e != lemon::INVALID; ++e) {
+		VALUE v = (*m_unedgemap)[e].value;
+		if (v != Qundef) {
+			VALUE b = rb_yield_values(2, lemongraph_make_unedge(e, m_graph), v);
+			if (b != Qnil && b != Qfalse)
+				m_unedgemap->set(e, Qundef);
+		}
+	}
+	return m_self;
+}
+
+
+void EdgeMap::clear()
+{
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+	for (lemon::ListGraph::EdgeIt e(g); e != lemon::INVALID; ++e)
+		m_unedgemap->set(e, Qundef);
+}
+
+
+bool EdgeMap::is_equal(const EdgeMap& other)
+{
+	if (other.m_graph != m_graph)
+		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;
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+	for (lemon::ListGraph::EdgeIt e(g); e != lemon::INVALID; ++e) {
+		if ((*m_unedgemap)[e].value == Qundef) {
+			if ((*other.m_unedgemap)[e].value != Qundef)
+				return false;
+		}
+		else if (rb_funcall((*m_unedgemap)[e].value, id_eqeq, 1, (*other.m_unedgemap)[e].value) != Qtrue)
+			return false;
+	}
+	return true;
+}
+
+
+VALUE EdgeMap::hash()
+{
+	st_index_t size = NUM2INT(length());
+	st_index_t hval = rb_hash_start(size);
+	hval = rb_hash_uint(hval, (st_index_t)lemongraph_edgemap_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)));
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(m_graph);
+	for (lemon::ListGraph::EdgeIt e(g); e != lemon::INVALID; ++e) {
+		VALUE v = (*m_unedgemap)[e].value;
+		if (v != Qundef) {
+			hval = rb_hash_uint(hval, lemon::ListGraph::id(e));
+			hval = rb_hash_uint(hval, NUM2LONG(rb_hash(v)));
+		}
+	}
+	hval = rb_hash_end(hval);
+	return ST2FIX(hval);
+}
+
+
+} // namespace LemonGraph
+
+
+static void lemongraph_edgemap_mark(void *p)
+{
+	LemonGraph::EdgeMap *nm = (LemonGraph::EdgeMap*)p;
+	nm->mark();
+}
+
+
+static void lemongraph_edgemap_free(void *p)
+{
+	LemonGraph::EdgeMap *nm = (LemonGraph::EdgeMap*)p;
+	delete nm;
+}
+
+
+static size_t lemongraph_edgemap_size(const void* p)
+{
+	return 0;
+}
+
+
+static const rb_data_type_t lemongraph_edgemap_type = {
+	.wrap_struct_name = "LemonGraph::EdgeMap",
+	.function = {
+		.dmark = lemongraph_edgemap_mark,
+		.dfree = lemongraph_edgemap_free,
+		.dsize = lemongraph_edgemap_size,
+	},
+	.parent = NULL,
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+
+VALUE lemongraph_edgemap_alloc(VALUE klass)
+{
+	LemonGraph::EdgeMap *nm = new LemonGraph::EdgeMap();
+	return TypedData_Wrap_Struct(klass, &lemongraph_edgemap_type, nm);
+}
+
+
+static inline LemonGraph::EdgeMap& lemongraph_edgemap_rb2ref(VALUE obj) {
+	LemonGraph::EdgeMap *nm;
+	TypedData_Get_Struct(obj, LemonGraph::EdgeMap, &lemongraph_edgemap_type, nm);
+	return *nm;
+}
+
+
+/* Returns a new edge map related to _graph_.
+ *
+ * If no block is given, _default_value_ will be returned when 
+ * a value is fetched for a edge for which no value was set.
+ *
+ * If a block is given, it will be called if needed
+ * to provide values for edges for which no value was set, instead of returning _default_value_.
+ *
+ * @return [EdgeMap]
+ * @overload initialize(graph, default_value = nil)
+ *  @param graph [Graph, Digraph] the graph this edge map is to be bound to
+ *  @param default_value [Object] the default value returned for edges with no value.
+ * @overload initialize(graph)
+ *  @param graph [Graph, Digraph] the graph this edge map is to be bound to
+ *  @yieldparam edge [Graph::Edge,Digraph::Edge] the edge for which to provide a value
+ *  @yieldparam edgemap [EdgeMap] _self_
+ *  @yieldreturn [Object] the default value returned for this _edge_
+ */
+VALUE lemongraph_edgemap_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::EdgeMap& nm = lemongraph_edgemap_rb2ref(self);
+	nm.initialize(self, rbg, dflt, proc);
+	return self;
+}
+
+
+
+/* Method called by _dup_ and _clone_ methods.
+ * @return [self]
+ */
+VALUE lemongraph_edgemap_initialize_copy(VALUE self, VALUE orig)
+{
+	rb_call_super(1, &orig);
+	LemonGraph::EdgeMap& from = lemongraph_edgemap_rb2ref(orig);
+	LemonGraph::EdgeMap& to   = lemongraph_edgemap_rb2ref(self);
+	to.initialize(self, from.graph(), from.default_value(), from.default_proc());
+	for (lemon::ListGraph::EdgeIt e(lemongraph_graph_rb2ref(from.graph())); e != lemon::INVALID; ++e) {
+		const LemonGraph::RBValue& v = from[e];
+		if (v.is_valid())
+			to[e] = v;
+	}
+	return self;
+}
+
+
+/* Returns the graph this edge map is related to.
+ * @return [Graph,Digraph]
+ */
+VALUE lemongraph_edgemap_graph(VALUE self)
+{
+	LemonGraph::EdgeMap& nm = lemongraph_edgemap_rb2ref(self);
+	return nm.graph();
+}
+
+
+/* Returns the default value set for this edge map.
+ * @return [Object]
+ */
+VALUE lemongraph_edgemap_get_dflt_val(VALUE self)
+{
+	LemonGraph::EdgeMap& nm = lemongraph_edgemap_rb2ref(self);
+	return nm.default_value();
+}
+
+
+/* Sets the default value for this edge map.
+ */
+VALUE lemongraph_edgemap_set_dflt_val(VALUE self, VALUE dflt)
+{
+	LemonGraph::EdgeMap& nm = lemongraph_edgemap_rb2ref(self);
+	nm.set_default_value(dflt);
+	return self;
+}
+
+
+/* Returns the default proc set for this edge map.
+ * @return [Proc, nil]
+ */
+VALUE lemongraph_edgemap_get_dflt_proc(VALUE self)
+{
+	LemonGraph::EdgeMap& nm = lemongraph_edgemap_rb2ref(self);
+	return nm.default_proc();
+}
+
+
+/* Sets the default proc for this edge map.
+ *
+ * If set, the default proc is called when a value is fetched for a edge
+ * which was not assigned a value.
+ * The proc parameters must be the edge key and the edge 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_edgemap_set_dflt_proc(VALUE self, VALUE proc)
+{
+	LemonGraph::EdgeMap& nm = lemongraph_edgemap_rb2ref(self);
+	nm.set_default_proc(proc);
+	return self;
+}
+
+
+/* Returns the value associated with the given edge key.
+ * @param key [Graph::Edge,Digraph::Edge]
+ * @return [Object]
+ */
+VALUE lemongraph_edgemap_get(VALUE self, VALUE key)
+{
+	LemonGraph::EdgeMap& nm = lemongraph_edgemap_rb2ref(self);
+	return nm.get(key);
+}
+
+
+/* Associates the given value with the given edge key; returns value.
+ * @param key [Graph::Edge, Digraph::Edge]
+ * @param value [Object]
+ */
+VALUE lemongraph_edgemap_set(VALUE self, VALUE key, VALUE value)
+{
+	LemonGraph::EdgeMap& nm = lemongraph_edgemap_rb2ref(self);
+	nm.set(key, value);
+	return value;
+}
+
+
+/* Returns an array containing all edge keys for which a value has been set.
+ * @return [Array<Graph::Edge,Digraph::Edge>]
+ */
+VALUE lemongraph_edgemap_edges(VALUE self)
+{
+	LemonGraph::EdgeMap& nm = lemongraph_edgemap_rb2ref(self);
+	return nm.keys();
+}
+
+
+/* Returns an array containing all values set for edges.
+ * @return [Array<Object>]
+ */
+VALUE lemongraph_edgemap_values(VALUE self)
+{
+	LemonGraph::EdgeMap& nm = lemongraph_edgemap_rb2ref(self);
+	return nm.values();
+}
+
+
+/* Return the count of entries in _slef_ for which a value has been set
+ * @return [Integer]
+ */
+VALUE lemongraph_edgemap_length(VALUE self)
+{
+	LemonGraph::EdgeMap& nm = lemongraph_edgemap_rb2ref(self);
+	return nm.length();
+}
+
+
+/* Returns _true_ if there are no entries, _false_ otherwise
+ * @return [Boolean]
+ */
+VALUE lemongraph_edgemap_is_empty(VALUE self)
+{
+	LemonGraph::EdgeMap& nm = lemongraph_edgemap_rb2ref(self);
+	return nm.is_empty();
+}
+
+
+/* Calls the block, if given, once for each edge key for which a value has been set.
+ * The edges are passed as parameters to the block.
+ *
+ * Returns _self_, or, if no block is given, an Enumerator is returned.
+ * @return [self, Enumerator]
+ * @overload each_edge
+ *  @yieldparam edge [Graph::Edge,Digraph::Edge]
+ *  @return [self]
+ * @overload each_edge
+ *  @return [Enumerator]
+ */
+VALUE lemongraph_edgemap_each_edge(VALUE self)
+{
+	LemonGraph::EdgeMap& nm = lemongraph_edgemap_rb2ref(self);
+	return nm.each_edge();
+}
+
+
+/* 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_edgemap_each_value(VALUE self)
+{
+	LemonGraph::EdgeMap& nm = lemongraph_edgemap_rb2ref(self);
+	return nm.each_value();
+}
+
+
+/* Calls the block, if given, once for each edge key and value pair.
+ * The edges 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 edge [Graph::Edge,Digraph::Edge]
+ *  @yieldparam value [Object]
+ *  @return [self]
+ * @overload each_pair
+ *  @return [Enumerator]
+ * @overload each
+ *  @yieldparam edge [Graph::Edge,Digraph::Edge]
+ *  @yieldparam value [Object]
+ *  @return [self]
+ * @overload each
+ *  @return [Enumerator]
+ */
+VALUE lemongraph_edgemap_each_pair(VALUE self)
+{
+	LemonGraph::EdgeMap& nm = lemongraph_edgemap_rb2ref(self);
+	return nm.each_pair();
+}
+
+
+/* Removes all values.
+ * @return [self]
+ */
+VALUE lemongraph_edgemap_clear(VALUE self)
+{
+	LemonGraph::EdgeMap& nm = lemongraph_edgemap_rb2ref(self);
+	nm.clear();
+	return self;
+}
+
+
+/* Deletes the entry for the given edge and returns its associated value, or the default one.
+ * @param key [Graph::Edge,Digraph::Edge]
+ */
+VALUE lemongraph_edgemap_delete(VALUE self, VALUE key)
+{
+	LemonGraph::EdgeMap& nm = lemongraph_edgemap_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 edge-value pair;
+ *  deletes each entry for which the block returns a truthy value;
+ *  returns self
+ *  @yieldparam edge [Graph::Edge,Digraph::Edge]
+ *  @yieldparam value [Object]
+ *  @yieldreturn [Boolean] whether to delete or not the entry
+ *  @return [self]
+ * @overload delete_if
+ *  @return [Enumerator]
+ */
+VALUE lemongraph_edgemap_delete_if(VALUE self)
+{
+	LemonGraph::EdgeMap& nm = lemongraph_edgemap_rb2ref(self);
+	return nm.del_if();
+}
+
+
+/* Returns _true_ if a value was set for _edge_, otherwise _false_.
+ * @param edge [Graph::Edge,Digraph::Edge]
+ * @return [Boolean]
+ */
+VALUE lemongraph_edgemap_has_edge(VALUE self, VALUE edge)
+{
+	LemonGraph::EdgeMap& nm = lemongraph_edgemap_rb2ref(self);
+	return nm.has_edge(edge);
+}
+
+
+/* Returns _true_ if _value_ is a value in _self_, otherwise _false_.
+ * @return [Boolean]
+ */
+VALUE lemongraph_edgemap_has_value(VALUE self, VALUE value)
+{
+	LemonGraph::EdgeMap& nm = lemongraph_edgemap_rb2ref(self);
+	return nm.has_value(value);
+}
+
+
+/* Returns _true_ if _other_ is a EdgeMap 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_edgemap_is_equal(VALUE self, VALUE other)
+{
+	if (rb_obj_is_kind_of(other, c_EdgeMap) != Qtrue)
+		return Qfalse;
+	LemonGraph::EdgeMap& m = lemongraph_edgemap_rb2ref(self);
+	LemonGraph::EdgeMap& o = lemongraph_edgemap_rb2ref(other);
+	return o.is_equal(m) ? Qtrue : Qfalse;
+}
+
+
+/* Returns the integer hash value for _self_.
+ * @return [Integer]
+ */
+VALUE lemongraph_edgemap_hash(VALUE self)
+{
+	LemonGraph::EdgeMap& nm = lemongraph_edgemap_rb2ref(self);
+	return nm.hash();
+}
+
+