#include <tpl_euclidian_graph.H>

Inheritance diagram for Aleph::Euclidian_Graph< __Euclidian_Node, __Euclidian_Arc >:

Collaboration diagram for Aleph::Euclidian_Graph< __Euclidian_Node, __Euclidian_Arc >:

Public Types
typedef __Euclidian_Node	Node

typedef __Euclidian_Arc	Arc

typedef List_Graph< Node, Arc >	Graph

typedef Node::Node_Type	Node_Type

typedef Arc::Arc_Type	Arc_Type

Public Types inherited from Aleph::List_Graph< __Euclidian_Node, __Euclidian_Arc >
using	GT = List_Graph

using	Node = __Euclidian_Node
	The graph type.

using	Arc = __Euclidian_Arc
	The node class type.

using	Node_Type = typename Node::Node_Type
	The arc class type.

using	Arc_Type = typename Arc::Arc_Type
	The type of data stored in the arc.

using	CommonBase = GraphCommon< List_Graph< __Euclidian_Node, __Euclidian_Arc >, __Euclidian_Node, __Euclidian_Arc >

Public Types inherited from GraphCommon< GT, Node, Arc >
using	Node_Type = typename Node::Node_Type

using	Arc_Type = typename Arc::Arc_Type

using	ArcPair = std::tuple< Arc , Node >
	Pair of arc and node (topologically related)

Public Member Functions
	Euclidian_Graph ()

	Euclidian_Graph (const Euclidian_Graph< Node, Arc > &euclidian_graph)

Node *	insert_node (Node *node) noexcept override
	Insertion of a node already allocated.

Node *	insert_node (const Node_Type &info)

Node *	insert_node (const Point &position)

Node *	insert_node (const Node_Type &info, const Point &position)

Geom_Number	get_distance (Arc *arc)

Euclidian_Graph< Node, Arc > &	operator= (Euclidian_Graph< Node, Arc > &eg)

virtual	~Euclidian_Graph ()

Node *	search_node (const Point &)

Public Member Functions inherited from Aleph::List_Graph< __Euclidian_Node, __Euclidian_Arc >
Dlink &	get_node_dlink () noexcept
	Return a reference to the internal node Dlink for sorting.

Dlink &	get_arc_dlink () noexcept
	Return a reference to the internal arc Dlink for sorting.

Node *	insert_node (const Node_Type &node_info)
	Allocate a new node, set by copy its data content and insert it into the graph.

Node *	insert_node (Node_Type &&node_info=Node_Type())
	Allocate a new node, set by moving its data content and insert it into the graph.

virtual void	remove_node (Node *node) noexcept
	Remove a node from the graph and free its memory.

Node *	get_first_node () const
	Return any node in the graph.

Arc *	get_first_arc (Node *node) const
	Return any arc adjacent to a node.

Arc *	get_first_arc () const
	Return any arc in the graph.

Arc *	insert_arc (Node src, Node tgt, const Arc_Type &arc_info)
	Create and insert a new arc linking two nodes and copying data.

Arc *	insert_arc (Node src, Node tgt, Arc_Type &&arc_info=Arc_Type())
	Create and insert a new arc linking two nodes and moving the received data.

virtual void	remove_arc (Arc *arc) noexcept
	Remove an arc from the graph and free it.

virtual void	disconnect_arc (Arc *arc) noexcept
	Disconnect an arc from graph.

virtual Arc *	connect_arc (Arc *arc) noexcept
	Connect a previously disconnected arc to the graph.

	List_Graph (const List_Graph &g)
	Copy constructor.

	List_Graph (List_Graph &&g) noexcept
	Move constructor.

	List_Graph ()=default
	Construct an empty graph.

List_Graph &	operator= (const List_Graph &g)
	Copy assignment.

List_Graph &	operator= (List_Graph &&g) noexcept
	Move assignment.

virtual	~List_Graph ()
	Destructor: all the nodes and arcs and removed and freed.

void	swap (List_Graph &g) noexcept
	Swap in constant time `this` with `g`

Public Member Functions inherited from GraphCommon< GT, Node, Arc >
void *&	get_cookie () noexcept
	Return a modifiable reference to graph's cookie.

void *	get_cookie () const noexcept
	Return a constant reference to graph's cookie.

bool	is_digraph () const noexcept
	Return true if the graph `this` is directed.

void	set_digraph (bool val)
	Temporal indication for preventing to other algorithms that an graph must be treated as a directed graph.

constexpr size_t	get_num_nodes () const noexcept
	Return the total of nodes of graph.

constexpr size_t	vsize () const noexcept

Node *	get_node () const
	Return any node in the graph.

Node *	get_arc () const
	Return any arc in the graph.

Node *	get_arc (Node *p)
	Return any arc adjacent to a node.

Node *	get_src_node (Arc *arc) const noexcept
	Return the source node of `arc` (only for directed graphs)

Node *	get_tgt_node (Arc *arc) const noexcept
	Return the target node of `arc` (only for directed graphs)

Node *	get_connected_node (Arc arc, Node node) const noexcept
	Return the adjacent node to `node` through `arc`.

constexpr size_t	get_num_arcs () const noexcept

size_t	get_num_arcs (Node *node) const noexcept
	Return the total of arcs of a node.

size_t	degree (Node *p) const noexcept
	Return the total of arcs (or degree) of a node.

size_t	esize () const noexcept
	Return the total of arcs of graph.

Bit_Fields &	get_control_bits (Node *node) const noexcept
	Return a reference to control fields of `node`

void	reset_bit (Node *node, int bit) const noexcept
	Reset the `bit` of `node` (to zero)

void	reset_bits (Node *node) const noexcept
	Reset all the control bits of `node`

int	get_bit (Node *node, int bit) const noexcept
	Get the control `bit` of `node`

void	set_bit (Node *node, int bit, int value) const noexcept
	Set the control `bit` of `node` to `value`

Bit_Fields &	get_control_bits (Arc *arc) const noexcept
	Return a reference to the control bits of `arc`

void	reset_bit (Arc *arc, int bit) const noexcept
	Reset the `bit` of `arc` to zero.

void	reset_bits (Arc *arc) const noexcept
	Reset all the control bits of `arc`

int	get_bit (Arc *arc, int bit) const noexcept
	Get the control `bit` of `arc`

void	set_bit (Arc *arc, int bit, int value) const noexcept
	Set the control `bit` of `arc` to `value`

void *&	get_cookie (Node *node) const noexcept
	Get a modifiable reference to the cookie pointer of `node`

void *&	get_cookie (Arc *arc) const noexcept
	Get a modifiable reference to the cookie pointer of `arc`

long &	get_counter (Node *node) const noexcept
	Get a modifiable reference to the counter of `node`

void	reset_counter (Node *node) const noexcept
	Reset the `node` counter to zero.

void	reset_node_counters () const noexcept
	Reset all the node counters of graph to zero.

void	reset_node (Node *p) const noexcept
	Reset all the control attributes of node `p`.

long &	get_counter (Arc *arc) const noexcept
	Get a modifiable reference to the counter of `arc`

void	reset_counter (Arc *arc) const noexcept
	Reset the `acr` counter to zero.

void	reset_arc_counters () const noexcept
	Reset all the arc counters of graph to zero.

void	reset_arc (Arc *arc) const noexcept
	Reset all the control attributes of `arc`.

void	reset_nodes () const
	Reset all the nodes of graph (the control bits, the state, the counter and the cookie)

void	reset_arcs () const
	Reset all the arcs of graph (the control bits, the state, the counter and the cookie)

void	reset_bit_nodes (int bit) const noexcept
	Reset `bit` to zero for all the nodes of graph.

void	reset_bit_arcs (int bit) const noexcept
	Reset `bit` to zero for all the arcs of graph.

void	reset_bit_nodes () const noexcept
	Reset all the bits for all the nodes of graph.

void	reset_bit_arcs () const noexcept
	Reset all the bits for all the arcs of graph.

void	reset_counter_nodes () const noexcept
	Reset all the counters to zero for all the nodes of graph.

void	reset_counter_arcs () const noexcept
	Reset all the counters to zero for all the arcs of graph.

void	reset_cookie_nodes () const noexcept
	Reset all the cookies to `nullptr for all the nodes of graph.

void	reset_cookie_arcs () const noexcept
	Reset all the cookies to `nullptr for all the arcs of graph.

Node *	insert_node (const Node_Type &node_info)
	Allocate a new node, set by copy its data content and insert it into the graph.

Node *	insert_node (Node_Type &&node_info=Node_Type())
	Allocate a new node, set by moving its data content and insert it into the graph.

template<typename... Args>
Node *	emplace_node (Args &&... args)
	Insert a new node in the graph by constructing it in-place with the given args.

Arc *	insert_arc (Node src, Node tgt, const Arc_Type &arc_info)
	Create and insert a new arc linking two nodes and copying data.

Arc *	insert_arc (Node src, Node tgt, Arc_Type &&arc_info=Arc_Type())
	Create and insert a new arc linking two nodes and moving the received data.

template<typename... Args>
Arc *	emplace_arc (Node src, Node tgt, Args &&... args)
	Insert a new arc in the graph by constructing its associated data in-place with the given args.

template<class Operation >
bool	traverse_nodes (Operation &op) const
	Conditioned traversal of all the nodes of a graph.

template<class Operation >
bool	traverse_nodes (Operation &&op=Operation()) const
	Overload of `traverse_nodes(Operation&)` that accepts rvalues.

template<class Operation >
bool	traverse_arcs (Operation &op) const
	Conditioned traversal of all the arcs of a graph.

template<class Operation >
bool	traverse_arcs (Operation &&op=Operation()) const
	Overload of `traverse_arcs(Operation&)` that accepts rvalues.

template<class Operation >
bool	traverse_arcs (Node *p, Operation &op) const
	Conditioned traversal of all the adjacent arcs of a node.

template<class Operation >
bool	traverse_arcs (Node *p, Operation &&op=Operation()) const
	Overload of `traverse_arcs(Node*, Operation&)` that accepts rvalues.

template<class Operation >
void	for_each_node (Operation &operation) const
	Unconditionally traverse all the nodes of graph and on each one perform an operation.

template<class Operation >
void	for_each_node (Operation &&operation=Operation()) const
	Overload of `for_each_node(Operation&)` that accepts rvalues.

template<class Operation >
void	for_each_arc (Operation &op) const
	Unconditionally traverse all the arcs of graph and on each one perform an operation.

template<class Operation >
void	for_each_arc (Operation &&operation=Operation()) const
	Overload of `for_each_arc(Operation&)` that accepts rvalues.

template<class Operation >
void	for_each_arc (Node *p, Operation &op) const
	Unconditionally traverse all the arcs adjacnt to a node and on each one perform an operation.

template<class Operation >
void	for_each_arc (Node *p, Operation &&op=Operation()) const
	Overload of `for_each_arc(Node*, Operation&)` that accepts rvalues.

template<class Operation >
bool	all_nodes (Operation &op) const
	Check if all the nodes of graph satisfy an boolean condition.

template<class Operation >
bool	all_nodes (Operation &&op=Operation()) const
	Overload of `all_nodes(Operation&)` that accepts rvalues.

template<class Operation >
bool	all_arcs (Operation &op) const
	Check if all the arcs of graph satisfy a boolean condition.

template<class Operation >
bool	all_arcs (Operation &&op=Operation()) const
	Overload of `all_arcs(Operation&)` that accepts rvalues.

template<class Operation >
bool	all_arcs (Node *p, Operation &op) const
	Check if all the arcs adjacent to a node satisfy an boolean condition.

template<class Operation >
bool	all_arcs (Node *p, Operation &&op=Operation()) const
	Overload of `all_arcs(Node*, Operation&)` that accepts rvalues.

template<typename T = Node_Type>
auto	nodes_map (std::function< T(Node *)> op) const
	Map the nodes of a graph to a specific range.

template<typename T = Arc_Type>
auto	arcs_map (std::function< T(Arc *)> operation) const
	Map the arcs of a graph to a specific range.

template<typename T = Arc_Type>
auto	arcs_map (Node p, std::function< T(Arc )> operation) const
	Map the adjacent arcs of a node to a specific range.

template<typename T = Node_Type>
T	foldl_nodes (const T &init, std::function< T(const T &, Node *)> op) const
	Folding of nodes on a graph.

template<typename T = Arc_Type>
T	foldl_arcs (const T &init, std::function< T(const T &, Arc *)> op) const
	Folding of arcs on a graph.

template<typename T = Arc_Type>
T	foldl_arcs (Node p, const T &init, std::function< T(const T &, Arc )> op) const
	Folding of arcs of a node.

template<class Op >
auto	filter_nodes (Op &op) const
	Filter the nodes satisfying a condition.

template<class Op >
auto	filter_nodes (Op &&op) const
	Overload of `filter_nodes(Op&)` that accepts rvalues.

template<class Op >
auto	filter_arcs (Op &op) const
	Filter the arcs of graph satisfying a condition.

template<class Op >
auto	filter_arcs (Op &&op) const
	Overload of `filter_arcs(Op&)` that accepts rvalues.

template<class Op >
auto	filter_arcs (Node *p, Op &op) const
	Filter the arcs adjacent to a node satisfying a condition.

template<class Op >
auto	filter_arcs (Node *p, Op &&op) const
	Overload of `filter_arcs(Node*, Op&)` that accepts rvalues.

template<class Operation >
bool	exists_node (Operation &op) const
	Determine if exists at least a node satisfying a condition.

template<class Operation >
bool	exists_node (Operation &&op=Operation()) const
	Overload of `exists_node(Operation&)` that accepts rvalues.

template<class Operation >
bool	exists_arc (Operation &op) const
	Determine if exists at least a arc satisfying a condition.

template<class Operation >
bool	exists_arc (Operation &&op=Operation()) const
	Overload of `exists_arc(Operation&)` that accepts rvalues.

template<class Operation >
bool	exists_arc (Node *p, Operation &op) const
	Determine if exists at least a arc adjacent to a node satisfying a condition.

template<class Operation >
bool	exists_arc (Node *p, Operation &&op=Operation()) const
	Overload of `exists_arc(Node*, Operation&)` that accepts rvalues.

template<class Operation >
bool	none_node (Operation &op) const
	Determine if no node satisfies a condition.

template<class Operation >
bool	none_node (Operation &&op) const
	Overload of `none_node(Operation&)` that accepts rvalues.

template<class Operation >
bool	none_arc (Operation &op) const
	Determine if no arc satisfies a condition.

template<class Operation >
bool	none_arc (Operation &&op) const
	Overload of `none_arc(Operation&)` that accepts rvalues.

template<class Operation >
bool	none_arc (Node *p, Operation &op) const
	Determine if no arc adjacent to a node satisfies a condition.

template<class Operation >
bool	none_arc (Node *p, Operation &&op) const
	Overload of `none_arc(Node*, Operation&)` that accepts rvalues.

template<class Operation = std::function<bool(Node*)>>
size_t	count_nodes (Operation op=[](Node *) { return true;}) const
	Count the nodes satisfying a condition.

template<class Operation = std::function<bool(Arc*)>>
size_t	count_arcs (Operation op=[](Arc *) { return true;}) const
	Count the arcs satisfying a condition.

template<class Operation = std::function<bool(Arc*)>>
size_t	count_arcs (Node p, Operation op=[](Arc ) { return true;}) const
	Count arcs adjacent to a node satisfying a condition.

template<typename T = double, class Extract >
T	sum_arcs (Node *p, Extract extract) const
	Sum values derived from arcs adjacent to a node.

template<typename T = double>
T	sum_arcs (Node *p) const
	Overload of `sum_arcs(Node*, Extract)` using the arc info as extractor.

template<class Compare = std::function<bool(Arc, Arc)>>
Arc *	min_arc (Node p, Compare cmp=[](Arc a, Arc *b) { return a->get_info()< b->get_info();}) const
	Find the minimum arc adjacent to a node.

template<class Compare = std::function<bool(Arc, Arc)>>
Arc *	max_arc (Node p, Compare cmp=[](Arc a, Arc *b) { return a->get_info()< b->get_info();}) const
	Find the maximum arc adjacent to a node.

template<class Compare = std::function<bool(Arc, Arc)>>
Arc *	min_arc (Compare cmp=[](Arc a, Arc b) { return a->get_info()< b->get_info();}) const
	Find the minimum arc in the entire graph.

template<class Compare = std::function<bool(Arc, Arc)>>
Arc *	max_arc (Compare cmp=[](Arc a, Arc b) { return a->get_info()< b->get_info();}) const
	Find the maximum arc in the entire graph.

template<class Operation >
std::pair< DynList< Node * >, DynList< Node * > >	partition_nodes (Operation op) const
	Partition nodes into two groups based on a predicate.

template<class Operation >
std::pair< DynList< Arc * >, DynList< Arc * > >	partition_arcs (Operation op) const
	Partition arcs into two groups based on a predicate.

DynList< Node * >	adjacent_nodes (Node *p) const
	Get all adjacent nodes (neighbors) of a node.

template<class Op >
Node *	search_node (Op &op) const
	Linear search of a node.

template<class Op >
Node *	search_node (Op &&op) const
	Overload of `search_node(Op&)` that accepts rvalues.

Node *	find_node (const Node_Type &info) const noexcept
	Find a node mathing a content.

template<class Op >
Arc *	search_arc (Op &op) const
	Linear search of an arc.

template<class Op >
Arc *	search_arc (Op &&op) const
	Overload of `search_arc(Op&)` that accepts rvalues.

Arc *	find_arc (const Arc_Type &info) const noexcept
	Find an arc mathing a content.

template<class Operation >
Arc *	search_arc (Node *p, Operation &op) const
	Linear search of an arc.

template<class Operation >
Arc *	search_arc (Node *p, Operation &&op=Operation()) const
	Overload of `search_arc(Node*, Operation&)` that accepts rvalues.

Arc *	search_arc (Node src, Node tgt) const noexcept
	Search an arc linking two nodes.

template<template< typename > class Container = Aleph::DynList>
Container< Node * >	nodes () const
	Return a container with all the nodes of the graph.

template<template< typename > class Container = Aleph::DynList>
Container< Arc * >	arcs () const
	Return a container with all the arcs of the graph.

template<template< typename > class Container = Aleph::DynList>
Container< Arc * >	arcs (Node *p) const
	Return a container with all the arcs adjacent to a node.

auto	get_node_it () const noexcept
	Obtains an iterator to the nodes of graph.

auto	get_arc_it () const noexcept
	Obtains an iterator to the arc of graph.

auto	get_arc_it (Node *p) const noexcept
	Obtains an iterator to the adjacent arcs of a node.

In_Iterator	get_in_it (Node *p) const noexcept
	Return an input iterator on the incoming arcs to `p`

Out_Iterator	get_out_it (Node *p) const noexcept
	Return an output iterator on the incoming nodes to `p`

Arc *	search_directed_arc (Node src, Node tgt) const noexcept
	Search a directed arc linking two nodes.

DynList< Node * >	in_nodes (Node *p) const
	Return a list with the incoming nodes to `p`

DynList< Node * >	out_nodes (Node *p) const
	Return a list with the outcoming nodes to `p`

DynList< Arc * >	out_arcs (Node *p) const
	Return a list with the outcoming arcs to p`.

DynList< Arc * >	in_arcs (Node *p) const
	Return a list with the incoming arcs to p`.

auto	in_pairs (Node *p) const
	Return a list of pair incoming arcs and nodes.

auto	out_pairs (Node *p) const
	Return a list of pair outcoming arcs and nodes.

size_t	in_degree (Node *p) const noexcept
	Compute the input degree of a node.

size_t	out_degree (Node *p) const noexcept
	Compute the output degree of a node.

template<class Itor , class Operation >
bool	traverse_arcs (Node *p, Operation &op) const
	Traverse of arcs of a node according to specific arcs iterator.

template<class Itor , class Operation >
void	for_each_arc (Node *p, Operation &op) const
	Perform `op` on each arc of node `p`

template<class Op >
bool	traverse_in_arcs (Node *p, Op &op) const
	Traverse the incoming arcs of node `p` executing the conditioned `operation`

template<class Op >
bool	traverse_in_arcs (Node *p, Op &&op=Op()) const
	Overload of `traverse_in_arcs(Node*, Op&)` that accepts rvalues.

template<class Op >
void	for_each_in_arc (Node *p, Op &op) const
	Perform `op` on each incoming arc of node `p`

template<class Op >
void	for_each_in_arc (Node *p, Op &&op=Op()) const
	Overload of `for_each_in_arc(Node*, Op&)` that accepts rvalues.

template<class Op >
bool	all_in_arcs (Node *p, Op &op) const
	Return `true` if `op` is true for all the incoming arcs to node `p`

template<class Op >
bool	all_in_arcs (Node *p, Op &&op=Op()) const
	Overload of `all_in_arcs(Node*, Op&)` that accepts rvalues.

template<class Op >
bool	exists_in_arc (Node *p, Op &op) const
	Return true if it exists a incoming arc to `p` returning `true` for `op`

template<class Op >
bool	exists_in_arc (Node *p, Op &&op=Op()) const
	Overload of `exists_in_arc(Node*, Op&)` that accepts rvalues.

template<class Op >
auto	search_in_arc (Node *p, Op &op) const
	Search an incoming arc to a node satisfaying a condition.

template<class Op >
auto	search_in_arc (Node *p, Op &&op=Op()) const
	Overload of `search_in_arc(Node*, Op&)` that accepts rvalues.

template<typename T >
auto	in_arcs_map (Node p, std::function< T(Arc )> op) const
	Return a list of incoming arcs of a node mapped to items of type given by transformation `op`.

template<typename T = Arc_Type>
T	foldl_in_arcs (Node p, const T &init, std::function< T(const T &, Arc )> op) const
	Fold the incoming arcs of a node.

template<class Op >
DynList< Arc * >	filter_in_arcs (Node *p, Op &op) const
	Filter the incoming arcs of a node.

template<class Op >
auto	filter_in_arcs (Node *p, Op &&op=Op()) const
	Overload of `filter_in_arcs(Node*, Op&)` that accepts rvalues.

template<class Op >
bool	traverse_out_arcs (Node *p, Op &op) const
	Traverse the outcoming arcs of node `p` executing the conditioned `operation`

template<class Op >
bool	traverse_out_arcs (Node *p, Op &&op=Op()) const
	Overload of `traverse_out_arcs(Node*, Op&)` that accepts rvalues.

template<class Op >
void	for_each_out_arc (Node *p, Op &op) const
	Perform `op` on each outcoming arc of node `p`

template<class Op >
void	for_each_out_arc (Node *p, Op &&op=Op()) const
	Overload of `for_each_out_arc(Node*, Op&)` that accepts rvalues.

template<class Op >
bool	all_out_arcs (Node *p, Op &op) const
	Return `true` if `op` is true for all the outcoming arcs to node `p`

template<class Op >
bool	all_out_arcs (Node *p, Op &&op=Op()) const
	Overload of `all_out_arcs(Node*, Op&)` that accepts rvalues.

template<class Op >
bool	exists_out_arc (Node *p, Op &op) const
	Return true if it exists a outcoming arc to `p` returning `true` for `op`

template<class Op >
bool	exists_out_arc (Node *p, Op &&op=Op()) const
	Overload of `exists_out_arc(Node*, Op&)` that accepts rvalues.

template<class Op >
auto	search_out_arc (Node *p, Op &op) const
	Search an outcoming arc to a node satisfaying a condition.

template<class Op >
auto	search_out_arc (Node *p, Op &&op=Op()) const
	Overload of `search_out_arc(Node*, Op&)` that accepts rvalues.

template<typename T = Arc_Type>
auto	out_arcs_map (Node p, std::function< T(Arc )> op) const
	Return a list of outcoming arcs of a node mapped to items of type given by transformation `op`.

template<typename T = Arc_Type>
T	foldl_out_arcs (Node p, const T &init, std::function< T(const T &, Arc )> op) const
	Fold-left over outcoming arcs of a node.

template<class Op >
DynList< Arc * >	filter_out_arcs (Node *p, Op &op) const
	Filter the outcoming arcs of a node.

template<class Op >
auto	filter_out_arcs (Node *p, Op &&op=Op()) const
	Overload of `filter_out_arcs(Node*, Op&)` that accepts rvalues.

template<class Compare > requires (has_node_dlink_v<GT>)
void	sort_nodes (Compare &cmp) noexcept

template<class Compare > requires (has_node_dlink_v<GT>)
void	sort_nodes (Compare &&cmp=Compare()) noexcept

template<class Compare > requires (has_arc_dlink_v<GT>)
void	sort_arcs (Compare &cmp) noexcept
	Sort all the arcs of the graph according to a specific criteria.

template<class Compare > requires (has_arc_dlink_v<GT>)
void	sort_arcs (Compare &&cmp=Compare()) noexcept

Additional Inherited Members
Static Public Member Functions inherited from GraphCommon< GT, Node, Arc >
template<class N1 , class N2 = N1>
static void	map_nodes (N1 p, N2 q) noexcept
	Map the nodes through their cookies.

template<class A1 , class A2 = A1>
static void	map_arcs (A1 p, A2 q) noexcept
	Map the arcs through their cookies.

Static Public Attributes inherited from GraphCommon< GT, Node, Arc >
template<class U >
static constexpr bool	has_node_dlink_v
	Sort all the nodes of the graph according to a specific criteria.

template<class U >
static constexpr bool	has_arc_dlink_v

Protected Member Functions inherited from GraphCommon< GT, Node, Arc >
void	init () noexcept

void	common_swap (GT &g) noexcept

template<class Predicate >
DynList< Arc * >	collect_arcs_if (Predicate pred) const
	Collect all arcs matching a predicate.

template<class Predicate >
void	remove_arcs_if (Predicate pred)
	Remove all arcs matching a predicate.

Protected Attributes inherited from GraphCommon< GT, Node, Arc >
void *	cookie = nullptr

size_t	num_nodes = 0

size_t	num_arcs = 0

bool	digraph = false

Detailed Description

template<class __Euclidian_Node, class __Euclidian_Arc>
class Aleph::Euclidian_Graph< __Euclidian_Node, __Euclidian_Arc >

Definition at line 180 of file tpl_euclidian_graph.H.

Member Typedef Documentation

◆ Arc

template<class __Euclidian_Node , class __Euclidian_Arc >

typedef __Euclidian_Arc Aleph::Euclidian_Graph< __Euclidian_Node, __Euclidian_Arc >::Arc

Definition at line 185 of file tpl_euclidian_graph.H.

◆ Arc_Type

template<class __Euclidian_Node , class __Euclidian_Arc >

typedef Arc::Arc_Type Aleph::Euclidian_Graph< __Euclidian_Node, __Euclidian_Arc >::Arc_Type

Definition at line 191 of file tpl_euclidian_graph.H.

◆ Graph

template<class __Euclidian_Node , class __Euclidian_Arc >

typedef List_Graph<Node, Arc> Aleph::Euclidian_Graph< __Euclidian_Node, __Euclidian_Arc >::Graph

Definition at line 187 of file tpl_euclidian_graph.H.

◆ Node

template<class __Euclidian_Node , class __Euclidian_Arc >

typedef __Euclidian_Node Aleph::Euclidian_Graph< __Euclidian_Node, __Euclidian_Arc >::Node

Definition at line 183 of file tpl_euclidian_graph.H.

◆ Node_Type

template<class __Euclidian_Node , class __Euclidian_Arc >

typedef Node::Node_Type Aleph::Euclidian_Graph< __Euclidian_Node, __Euclidian_Arc >::Node_Type

Definition at line 189 of file tpl_euclidian_graph.H.

Constructor & Destructor Documentation

◆ Euclidian_Graph() [1/2]

template<class __Euclidian_Node , class __Euclidian_Arc >

Aleph::Euclidian_Graph< __Euclidian_Node, __Euclidian_Arc >::Euclidian_Graph ( )

inline

Definition at line 193 of file tpl_euclidian_graph.H.

◆ Euclidian_Graph() [2/2]

template<class __Euclidian_Node , class __Euclidian_Arc >

Aleph::Euclidian_Graph< __Euclidian_Node, __Euclidian_Arc >::Euclidian_Graph ( const Euclidian_Graph< Node, Arc > & euclidian_graph )

inline

Definition at line 198 of file tpl_euclidian_graph.H.

References Aleph::copy_graph(), and Aleph::maps().

◆ ~Euclidian_Graph()

template<class __Euclidian_Node , class __Euclidian_Arc >

virtual Aleph::Euclidian_Graph< __Euclidian_Node, __Euclidian_Arc >::~Euclidian_Graph ( )

inlinevirtual

Definition at line 241 of file tpl_euclidian_graph.H.

References Aleph::clear_graph().

Member Function Documentation

◆ get_distance()

template<class __Euclidian_Node , class __Euclidian_Arc >

Geom_Number Aleph::Euclidian_Graph< __Euclidian_Node, __Euclidian_Arc >::get_distance ( Arc * arc )

inline

Definition at line 226 of file tpl_euclidian_graph.H.

References GraphCommon< GT, Node, Arc >::get_src_node(), GraphCommon< GT, Node, Arc >::get_tgt_node(), and Aleph::maps().

Referenced by TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

◆ insert_node() [1/4]

template<class __Euclidian_Node , class __Euclidian_Arc >

Node * Aleph::Euclidian_Graph< __Euclidian_Node, __Euclidian_Arc >::insert_node ( const Node_Type & info )

inline

Definition at line 211 of file tpl_euclidian_graph.H.

References Aleph::Euclidian_Graph< __Euclidian_Node, __Euclidian_Arc >::insert_node(), and Aleph::maps().

◆ insert_node() [2/4]

template<class __Euclidian_Node , class __Euclidian_Arc >

Node * Aleph::Euclidian_Graph< __Euclidian_Node, __Euclidian_Arc >::insert_node	(	const Node_Type &	info,
		const Point &	position
	)

inline

Definition at line 221 of file tpl_euclidian_graph.H.

References Aleph::Euclidian_Graph< __Euclidian_Node, __Euclidian_Arc >::insert_node(), and Aleph::maps().

◆ insert_node() [3/4]

template<class __Euclidian_Node , class __Euclidian_Arc >

Node * Aleph::Euclidian_Graph< __Euclidian_Node, __Euclidian_Arc >::insert_node ( const Point & position )

inline

Definition at line 216 of file tpl_euclidian_graph.H.

References Aleph::Euclidian_Graph< __Euclidian_Node, __Euclidian_Arc >::insert_node().

◆ insert_node() [4/4]

template<class __Euclidian_Node , class __Euclidian_Arc >

Node * Aleph::Euclidian_Graph< __Euclidian_Node, __Euclidian_Arc >::insert_node ( Node * node )

inlineoverridevirtualnoexcept

Insertion of a node already allocated.

This method takes a pointer to a node already allocated and inserts it in the graph.

The node allocation and its life in memory are the user's responsibility. At this regard, take into account that the graph destructor and remove_method() will assume that the nodes were allocated with new operator, and consequently it will call to delete for deallocating. So, it is very dangerous to use nodes whose memory does not come from new.

Note: Since that it is programmer responsibility to allocate memory for the node, and in addition, the graph destructor and the remove_noe() will call delete operator, it is preferable and highly recommended to use any other overloaded version of insert_node() which automatically allocates the node's memory. In fact, those overloaded methods invoke this version.

Parameters

[in] node a pointer to an already allocated node.