# Add the specified node to the graph assuming that its local ID is already set.
	#
	# SEE: `create_node`
	# SEE: `register`
	redef fun add(node) is abstract

	redef fun add(e) do seq.add(e)

	redef fun add(e)
	do
		seq.add(e)
		# Reset the cache to give the new element a chance!
		peek_cached = false
	end

	redef fun add(e)
	do
		#assert assert_best else print "try to add {e}"
		#var ol = length
		var ei = items.length + 1
		while ei > 1 do
			var pi = ei/2
			var p = items[pi-1]
			if comparator.compare(p, e) <= 0 then break

			# bubble-up
			items[ei-1] = p

			# next
			ei = pi
		end
		items[ei-1] = e
		#assert length == ol + 1
		#assert assert_best else print "added {e}"
	end

	# A synonym of `push`
	redef fun add(e) do push(e)

	# Add a new element in the structure.
	# Initially it is in its own disjoint subset
	#
	# ENSURE: `has(e)`
	redef fun add(e) do
		if nodes.has_key(e) then return
		var ne = new DisjointSetNode
		nodes[e] = ne
		number_of_subsets += 1
	end

	# Add `item` to the tree, create children if `item_limit` is reached
	redef fun add(item) do if self.is_leaf then self.data.add(item) else add_to_children(item)

	redef fun add(node) do
		var id = node[id_property]
		assert id isa Int else
			sys.stderr.write "The local ID must be an `Int`.\n"
		end
		assert id >= 0 else
			sys.stderr.write "The local ID must be greater or equal to 0. Got {id}.\n"
		end
		# Pad with nulls.
		nodes.enlarge(id)
		var delta = id - nodes.length
		while delta > 0 do
			nodes.add null
			delta -= 1
		end
		nodes[id] = node
		length += 1
	end

	redef fun add(e) do if not _array.has(e) then _array.add(e)

	redef fun add(value: Int)
	do
		assert full: _length < (_capacity-1)
		var l = _length
		_values[l] = value
		_keys[value] = l
		_length = l + 1
	end

	redef fun add(item) do self[length] = item

	redef fun add(item)
	do
		if _capacity == 0 then enlarge(17) # 17 because magic in `store`
		var i = index_at(item)
		var c = node_at_idx(i, item)
		if c != null then
			c._key = item
		else
			store(i,new HashSetNode[E](item))
		end
	end

	redef fun add(c)
	do
		target.add(c)
	end

	redef fun add(e)
	do
		mutex.lock
		real_collection.add e
		mutex.unlock
	end

	redef fun add(e)
	do
		if contexts_items.has(e.context) then return
		map_sprite e
		super
	end

	redef fun add(item)
	do
		var l = _length
		if _capacity <= l then
			enlarge(l + 1)
		end
		_length = l + 1
		_items.as(not null)[l] = item
	end

	redef fun add(e)
	do
		mutex.lock
		super
		mutex.unlock
	end

	#     var b = new Bytes.empty
	#     b.add 101
	#     assert b.to_s == "e"
	redef fun add(c) do
		if persisted then regen
		if length >= capacity then
			enlarge(length)
		end
		items[length] = c
		length += 1
	end

	redef fun add(e)
	do
		super
		var config = virtual_host.server_config
		if config != null then register_and_listen(e, config)
	end

	redef fun add(e)
	do
		super

		e.server_config = config
	end

	redef fun add(e)
	do
		super
		for i in e.interfaces do e.interfaces.register_and_listen(i, config)
	end

	redef fun add(e)
	do
		mutex.lock
		real_collection.add e
		mutex.unlock
	end