concepts.h

Go to the documentation of this file.

#ifndef GRAPHLIB_INTERNAL_CONCEPTS_H
#define GRAPHLIB_INTERNAL_CONCEPTS_H
 
#include <concepts>
#include <iostream>
#include <iterator>
#include <type_traits>

 
namespace GraphLib::Internal {
 
//
// ID, data and weight type constraints
//
 
// first, a helper concept:

template <typename T>
concept is_printable = requires(T a, std::ostream& os) {
    { os << a } -> std::same_as<std::ostream&>;
};
 
// with that, the fundamental types we use in our graphs:

template <typename T>
concept valid_data_type = true; // TODO: any restrictions needed here?

template <typename T>
concept valid_id_type = std::totally_ordered<T> && std::is_default_constructible_v<T> && is_printable<T> &&
                        std::is_unsigned_v<T> && std::incrementable<T>;

template <typename T>
concept valid_weight_type = std::totally_ordered<T> && std::is_default_constructible_v<T> && is_printable<T> &&
                            std::numeric_limits<T>::has_infinity == true;
 
//
// Graph type constraints
//
 
// forward-declare the two edge types with their constraints:
 
template <valid_id_type I>
struct Edge;
 
template <valid_id_type I, valid_weight_type W>
struct WeightedEdge;

template <typename E, typename I>
concept valid_edge_type = std::is_aggregate_v<E> && requires { typename E::id_type; } && std::derived_from<E, Edge<I>>;

template <typename E, typename I>
concept valid_weighted_edge_type = std::is_aggregate_v<E> && requires {
    typename E::id_type;
    typename E::weight_type;
} && std::derived_from<E, WeightedEdge<I, typename E::weight_type>>;
 
// forward-declare the five abstract graph types with their type constraints:
 
template <valid_data_type D, valid_id_type I, valid_edge_type<I> E>
class Graph;
 
template <valid_data_type D, valid_id_type I, valid_edge_type<I> E>
class DirectedGraph;
 
template <valid_data_type D, valid_id_type I, valid_edge_type<I> E>
class UndirectedGraph;
 
template <valid_data_type D, valid_id_type I, valid_weighted_edge_type<I> E>
class WeightedGraph;
 
template <valid_data_type D, valid_id_type I, valid_edge_type<I> E>
class UnweightedGraph;

template <typename G>
concept has_graph_types = requires {
    typename G::data_type;
    typename G::id_type;
    typename G::edge_type;
};

template <typename G>
concept valid_graph_type =
    has_graph_types<G> &&
    std::derived_from<G, Graph<typename G::data_type, typename G::id_type, typename G::edge_type>>;
 
// finally, the concepts to constrain a type G to descend from the first level of our inheritance:

template <typename G>
concept valid_directed_graph_type =
    has_graph_types<G> &&
    std::derived_from<G, DirectedGraph<typename G::data_type, typename G::id_type, typename G::edge_type>>;

template <typename G>
concept valid_undirected_graph_type =
    has_graph_types<G> &&
    std::derived_from<G, UndirectedGraph<typename G::data_type, typename G::id_type, typename G::edge_type>>;

template <typename G>
concept valid_weighted_graph_type =
    has_graph_types<G> &&
    std::derived_from<G, WeightedGraph<typename G::data_type, typename G::id_type, typename G::edge_type>>;

template <typename G>
concept valid_unweighted_graph_type =
    has_graph_types<G> &&
    std::derived_from<G, UnweightedGraph<typename G::data_type, typename G::id_type, typename G::edge_type>>;

template <typename G>
concept valid_unweighted_directed_graph_type = valid_unweighted_graph_type<G> && valid_directed_graph_type<G>;

template <typename G>
concept valid_unweighted_undirected_graph_type = valid_unweighted_graph_type<G> && valid_undirected_graph_type<G>;

template <typename G>
concept valid_weighted_directed_graph_type = valid_weighted_graph_type<G> && valid_directed_graph_type<G>;

template <typename G>
concept valid_weighted_undirected_graph_type = valid_weighted_graph_type<G> && valid_undirected_graph_type<G>;
 
} // namespace GraphLib::Internal
 
#endif