concepts.hpp

// Copyright 2021 Arnaud Becheler    <abechele@umich.edu>
 
 
#pragma once
 
#include "directionality.hpp"
 
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/adjacency_matrix.hpp>
 
#include <concepts>
#include <ranges>
 
namespace quetzal::geography
{
 
namespace detail
{
template <typename T, typename... U>
concept is_any_of = (std::same_as<T, U> || ...);
 
template<typename T>
struct edge_construction
{
    template<typename Graph, typename Grid>
    requires 
    std::same_as<T, typename Graph::edge_property> and 
    std::default_initializable<T> and 
    ( ! std::constructible_from<T, typename Graph::vertex_descriptor, typename Graph::vertex_descriptor, Grid> )
    static inline constexpr void delegate(Graph::vertex_descriptor s, Graph::vertex_descriptor t, Graph& graph, Grid const& grid)
    {
        graph.add_edge(s, t, T{});
    }
 
    template<typename Graph, typename Grid>
    requires std::same_as<T, typename Graph::edge_property> and 
    std::constructible_from<T, typename Graph::vertex_descriptor, typename Graph::vertex_descriptor, Grid>
    static inline constexpr void delegate(Graph::vertex_descriptor s, Graph::vertex_descriptor t, Graph& graph, Grid const& grid)
    {
        graph.add_edge(s, t, T(s,t, grid));
    }
 
};
 
template<>
struct edge_construction<boost::no_property>
{
    static inline constexpr void delegate(auto s, auto t, auto& graph, [[maybe_unused]] auto const& grid)
    {
        graph.add_edge(s, t);
    }
};
 
}
 
template <typename T>
concept directional = detail::is_any_of<T, isotropy, anisotropy>;
 
static_assert ( directional<isotropy> );
static_assert ( directional<anisotropy> );
 
using no_property = boost::no_property;
 
struct sparse 
{
  template<directional Directed, class VertexProperty, class EdgeProperty>
  using rebind = boost::adjacency_list<boost::setS, boost::vecS, Directed, VertexProperty, EdgeProperty>;
};
 
struct dense 
{
  template<class Directed, class VertexProperty, class EdgeProperty>
  using rebind = boost::adjacency_matrix<Directed, VertexProperty, EdgeProperty, no_property, std::allocator<bool>>;
};
 
template<typename T>
concept connectedness = detail::is_any_of<T, sparse, dense>;
 
static_assert ( connectedness<dense> );
static_assert ( connectedness<sparse> );
 
template <typename T>
concept two_dimensional = requires(T a) {
                              requires std::convertible_to<decltype(a.width()), int>;
                              requires std::convertible_to<decltype(a.height()), int>;
                          };
 
template <typename T, class G, class S>
concept bounding = two_dimensional<S> and requires(T t, typename G::vertex_descriptor s, G &graph, S const &grid) {
                                              {
                                                  t(s, graph, grid)
                                                  } -> std::same_as<void>;
                                          };
} // namespace quetzal::geography