fishnet::graph::AdjacencyMap< N, Hash, Equal, NodeRange > Class Template Reference

Implementation of an Adjacency Map. Implements AdjacencyContainer. More...

#include <AdjacencyMap.hpp>

Public Types
using	node_type = N
using	equality_predicate = Equal
using	hash_function = Hash

Public Member Functions
void	addAdjacency (N from, N to)
void	addAdjacencies (util::forward_range_of< std::pair< N, N > > auto &&pairs)
bool	addNode (const N &node)
bool	addNode (N &&node)
bool	addNodes (util::forward_range_of< N > auto &&nodes)
void	removeNode (const N &node)
void	removeNodes (util::forward_range_of< N > auto &&nodes)
void	removeAdjacency (const N &from, const N &to)
void	removeAdjacencies (util::forward_range_of< std::pair< N, N > > auto &&adjacencies)
bool	contains (const N &node) const noexcept
bool	hasAdjacency (const N &from, const N &to) const noexcept
auto	adjacency (const N &node) const noexcept
auto	nodes () const noexcept
auto	getAdjacencyPairs () const noexcept
void	clear () noexcept

Detailed Description

template<typename N, util::HashFunction< N > Hash = std::hash<N>, util::BiPredicate< N > Equal = std::equal_to<N>, typename NodeRange = std::vector<N>>
class fishnet::graph::AdjacencyMap< N, Hash, Equal, NodeRange >

Implementation of an Adjacency Map. Implements AdjacencyContainer.

Template Parameters

N	node type
Hash	hasher type on N
Equal	comparator type on N
NodeRange	range type for adjacency list

Member Typedef Documentation

equality_predicate

template<typename N , util::HashFunction< N > Hash = std::hash<N>, util::BiPredicate< N > Equal = std::equal_to<N>, typename NodeRange = std::vector<N>>

using fishnet::graph::AdjacencyMap< N, Hash, Equal, NodeRange >::equality_predicate = Equal

hash_function

template<typename N , util::HashFunction< N > Hash = std::hash<N>, util::BiPredicate< N > Equal = std::equal_to<N>, typename NodeRange = std::vector<N>>

using fishnet::graph::AdjacencyMap< N, Hash, Equal, NodeRange >::hash_function = Hash

node_type

template<typename N , util::HashFunction< N > Hash = std::hash<N>, util::BiPredicate< N > Equal = std::equal_to<N>, typename NodeRange = std::vector<N>>

using fishnet::graph::AdjacencyMap< N, Hash, Equal, NodeRange >::node_type = N

Member Function Documentation

addAdjacencies()

template<typename N , util::HashFunction< N > Hash = std::hash<N>, util::BiPredicate< N > Equal = std::equal_to<N>, typename NodeRange = std::vector<N>>

void fishnet::graph::AdjacencyMap< N, Hash, Equal, NodeRange >::addAdjacencies ( util::forward_range_of< std::pair< N, N > > auto &&  pairs )

inline

addAdjacency()

template<typename N , util::HashFunction< N > Hash = std::hash<N>, util::BiPredicate< N > Equal = std::equal_to<N>, typename NodeRange = std::vector<N>>

void fishnet::graph::AdjacencyMap< N, Hash, Equal, NodeRange >::addAdjacency ( N  from, N  to  )

inline

addNode() [1/2]

template<typename N , util::HashFunction< N > Hash = std::hash<N>, util::BiPredicate< N > Equal = std::equal_to<N>, typename NodeRange = std::vector<N>>

bool fishnet::graph::AdjacencyMap< N, Hash, Equal, NodeRange >::addNode ( const N &  node )

inline

addNode() [2/2]

template<typename N , util::HashFunction< N > Hash = std::hash<N>, util::BiPredicate< N > Equal = std::equal_to<N>, typename NodeRange = std::vector<N>>

bool fishnet::graph::AdjacencyMap< N, Hash, Equal, NodeRange >::addNode ( N &&  node )

inline

addNodes()

template<typename N , util::HashFunction< N > Hash = std::hash<N>, util::BiPredicate< N > Equal = std::equal_to<N>, typename NodeRange = std::vector<N>>

bool fishnet::graph::AdjacencyMap< N, Hash, Equal, NodeRange >::addNodes ( util::forward_range_of< N > auto &&  nodes )

inline

adjacency()

template<typename N , util::HashFunction< N > Hash = std::hash<N>, util::BiPredicate< N > Equal = std::equal_to<N>, typename NodeRange = std::vector<N>>

auto fishnet::graph::AdjacencyMap< N, Hash, Equal, NodeRange >::adjacency ( const N &  node ) const

inlinenoexcept

clear()

template<typename N , util::HashFunction< N > Hash = std::hash<N>, util::BiPredicate< N > Equal = std::equal_to<N>, typename NodeRange = std::vector<N>>

void fishnet::graph::AdjacencyMap< N, Hash, Equal, NodeRange >::clear ( )

inlinenoexcept

contains()

template<typename N , util::HashFunction< N > Hash = std::hash<N>, util::BiPredicate< N > Equal = std::equal_to<N>, typename NodeRange = std::vector<N>>

bool fishnet::graph::AdjacencyMap< N, Hash, Equal, NodeRange >::contains ( const N &  node ) const

inlinenoexcept

getAdjacencyPairs()

template<typename N , util::HashFunction< N > Hash = std::hash<N>, util::BiPredicate< N > Equal = std::equal_to<N>, typename NodeRange = std::vector<N>>

auto fishnet::graph::AdjacencyMap< N, Hash, Equal, NodeRange >::getAdjacencyPairs ( ) const

inlinenoexcept

hasAdjacency()

template<typename N , util::HashFunction< N > Hash = std::hash<N>, util::BiPredicate< N > Equal = std::equal_to<N>, typename NodeRange = std::vector<N>>

bool fishnet::graph::AdjacencyMap< N, Hash, Equal, NodeRange >::hasAdjacency ( const N &  from, const N &  to  ) const

inlinenoexcept

nodes()

template<typename N , util::HashFunction< N > Hash = std::hash<N>, util::BiPredicate< N > Equal = std::equal_to<N>, typename NodeRange = std::vector<N>>

auto fishnet::graph::AdjacencyMap< N, Hash, Equal, NodeRange >::nodes ( ) const

inlinenoexcept

removeAdjacencies()

template<typename N , util::HashFunction< N > Hash = std::hash<N>, util::BiPredicate< N > Equal = std::equal_to<N>, typename NodeRange = std::vector<N>>

void fishnet::graph::AdjacencyMap< N, Hash, Equal, NodeRange >::removeAdjacencies ( util::forward_range_of< std::pair< N, N > > auto &&  adjacencies )

inline

removeAdjacency()

template<typename N , util::HashFunction< N > Hash = std::hash<N>, util::BiPredicate< N > Equal = std::equal_to<N>, typename NodeRange = std::vector<N>>

void fishnet::graph::AdjacencyMap< N, Hash, Equal, NodeRange >::removeAdjacency ( const N &  from, const N &  to  )

inline

removeNode()

template<typename N , util::HashFunction< N > Hash = std::hash<N>, util::BiPredicate< N > Equal = std::equal_to<N>, typename NodeRange = std::vector<N>>

void fishnet::graph::AdjacencyMap< N, Hash, Equal, NodeRange >::removeNode ( const N &  node )

inline

removeNodes()

template<typename N , util::HashFunction< N > Hash = std::hash<N>, util::BiPredicate< N > Equal = std::equal_to<N>, typename NodeRange = std::vector<N>>

void fishnet::graph::AdjacencyMap< N, Hash, Equal, NodeRange >::removeNodes ( util::forward_range_of< N > auto &&  nodes )

inline

---

The documentation for this class was generated from the following file:

• lib/graph/adjacency/include/fishnet/AdjacencyMap.hpp