Utopia::DataIO::GraphUtilsHelper Namespace Reference

Enumerations
enum class	EntityKind { vertex , edge }
	Kinds of Entities to get properties from. More...

Functions
template<typename Graph >
std::pair< std::shared_ptr< HDFDataset >, std::shared_ptr< HDFDataset > >	setup_graph_containers (const Graph &g, const std::shared_ptr< HDFGroup > &grp)
template<typename First , typename Second , typename... Tail>
constexpr std::tuple< Tail... >	tuple_tail (const std::tuple< First, Second, Tail... > &t)
	Builds new tuple containing all elements but the first two.
template<typename CoordT >
auto	coords_container ()
template<EntityKind entity_kind, typename Graph , typename NWGroup , typename ItPair >
auto	generate_write_function (const Graph &g, NWGroup &&nw_grp, std::string label, ItPair &&it_pair, std::size_t num_entities)

Enumeration Type Documentation

EntityKind

enum class Utopia::DataIO::GraphUtilsHelper::EntityKind

strong

Kinds of Entities to get properties from.

Enumerator
vertex
edge

                      {
    vertex,
    edge
};

Function Documentation

coords_container()

template<typename CoordT >

auto Utopia::DataIO::GraphUtilsHelper::coords_container

(

)

Creates empty vector with element-type CoordT. If CoordT is string-like std::string is enforced

{
    if constexpr (Utils::is_string_v<CoordT>) {
        return std::vector<std::string>{};
    }
    else {
        return std::vector<CoordT>{};
    } 
}

generate_write_function()

template<EntityKind entity_kind, typename Graph , typename NWGroup , typename ItPair >

auto Utopia::DataIO::GraphUtilsHelper::generate_write_function	(	const Graph &	g,
		NWGroup &&	nw_grp,
		std::string	label,
		ItPair &&	it_pair,
		std::size_t	num_entities
	)

This function generates a write function for graph entity properties.

The generated lambda function can then be called on each write specification in the adaptor tuple. It writes the specified data to a new dataset and adds attributes, fire-and-forget. Depending on the shape of the write specifications 1d or 2d datasets are written, see Utopia::DataIO::save_graph_entity_properties for more detail. Only relying on the given iterator pair, this function allows to handle vertex and edge iterations equivalently.

Template Parameters

EntityKind	The kind of entity to get the data from. This can be either vertices or edges.
Graph
NWGroup
ItPair

Parameters

g	The graph from which to save vertex or edge properties.
nw_grp	The HDFGroup the data should be written to.
label	The name of the dataset to which the adaptors write data.
it_pair	The iterator pair used to access the desired entities.
num_entities	The number of entities of kind 'EntityKind' in graph g.

Returns

auto The generated write function

{
    static_assert(entity_kind == EntityKind::vertex or
                  entity_kind == EntityKind::edge,
                  "Error, 'entity_kind' has to be either 'vertex' or 'edge'");
 
    return
        [&g,
         nw_grp{std::forward<NWGroup>(nw_grp)},
         label{std::move(label)},
         it_pair{std::forward<ItPair>(it_pair)},
         num_entities{std::move(num_entities)}] (auto&& write_spec)
        // By-reference captures are used where possible to avoid additional
        // copies. Note that this is not possible for label and num_entities.
        {
 
        std::string prop_prefix;
 
        if constexpr (entity_kind == EntityKind::vertex) {
            prop_prefix = "vertex";
        }
        else {
            prop_prefix = "edge";
        }
 
        const auto grp =
            nw_grp->open_group(std::get<0>(write_spec));
 
        // ... 1D case if second element of write_spec is a callable object
        //     such that the write specifications are of the form
        //     write_spec = (std::string name_adaptor, lambda adaptor)
        if constexpr (Utils::is_callable_v<std::tuple_element_t<1, 
                                    std::decay_t<decltype(write_spec)>>>)
        {
            const auto dset = grp->open_dataset(label, { num_entities });
 
            dset->write(it_pair.first, it_pair.second,
                [&](auto&& desc) {
                    return std::get<1>(write_spec)(desc, g);
                }
            );
 
            dset->add_attribute("dim_name__0", prop_prefix + "_idx");
            dset->add_attribute("coords_mode__"s + prop_prefix + "_idx",
                                "trivial");
        }
 
        // ... 2D case otherwise
        //     write_spec = (adaptor_name, dim0_name,
        //                        (coord1, adaptor1),
        //                        (coord2, adaptor2), ...)
        else {
 
            static_assert(Utils::is_string_v<std::tuple_element_t<1,
                                    std::decay_t<decltype(write_spec)>>>,
                          "Error, the name of dimension 0 has to be s string");
 
            // Extract the adaptor pairs (coord, adaptor) from write_spec tuple
            const auto adaptor_pairs = tuple_tail(write_spec);
            // FIXME This cannot be calculated at compile time since
            //       hana::for_each uses non-constexpr access.
 
            // Get number of adaptors
            constexpr auto num_adaptors = std::tuple_size_v<std::decay_t<
                                                    decltype(adaptor_pairs)>>;
 
            // Open a 2D dataset
            const auto dset = grp->open_dataset(label,
                                                {num_adaptors, num_entities});
 
            // Deduce coordinate container type from adaptor_pairs
            using WriteSpecT = std::decay_t<decltype(write_spec)>;
            using FirstTupElementT = std::tuple_element_t<2, WriteSpecT>;
            using CoordT = std::tuple_element_t<0, FirstTupElementT>;
 
            // Create the (empty) coordinates container
            auto coords = coords_container<CoordT>();
 
            // Create the lambda that saves the data to the captured
            // fire-and-forget dataset and stores the coordinate value
            auto apply_adaptor = [&](auto&& adaptor_pair){
                // adaptor_pair = (coordinate, adaptor_function)
                dset->write(it_pair.first, it_pair.second,
                    [&](auto&& desc) {
                        return std::get<1>(adaptor_pair)(desc, g);
                    }
                );
 
                static_assert(
                    // assert matching coordinate types
                    std::is_same_v<
                            std::tuple_element_t<0,
                                    std::decay_t<decltype(adaptor_pair)>>,
                            CoordT>,
                    "Error, coordinate types do not match! Check that all "
                    "coordinates are of the same type");
 
                coords.push_back(std::get<0>(adaptor_pair));
            };
 
            boost::hana::for_each(adaptor_pairs, apply_adaptor);
 
            // Extract the 0th dimension name from the write spec
            const std::string dim0_name = std::get<1>(write_spec);
 
            // Set attributes
            dset->add_attribute("dim_name__0", dim0_name);
            dset->add_attribute("coords_mode__"s + dim0_name, "values");
            dset->add_attribute("coords__"s + dim0_name, coords);
 
            dset->add_attribute("dim_name__1", prop_prefix + "_idx");
            dset->add_attribute("coords_mode__"s + prop_prefix + "_idx",
                                "trivial");
        }
    };
}

setup_graph_containers()

template<typename Graph >

std::pair< std::shared_ptr< HDFDataset >, std::shared_ptr< HDFDataset > > Utopia::DataIO::GraphUtilsHelper::setup_graph_containers	(	const Graph &	g,
		const std::shared_ptr< HDFGroup > &	grp
	)

This function opens the vertex and edge datasets for a single graph and adds attributes.

Via the attributes the size of the graph is stored and the trivial coordinates (i.e. vertex idx and edge idx) are added.

Template Parameters

Graph

Parameters

g	The graph to save
grp	The HDFGroup the graph should be stored in

Returns

std::pair<std::shared_ptr<HDFDataset<HDFGroup>>, std::shared_ptr<HDFDataset<HDFGroup>>> Pair containing [vertex dataset, edge dataset]

{
    // Collect some information on the graph
    const auto num_vertices = boost::num_vertices(g);
    const auto num_edges    = boost::num_edges(g);
 
    // Get a logger to use here (Note: needs to have been setup beforehand)
    spdlog::get("data_io")->info("Saving graph with {} vertices and {} edges "
                                 "...", num_vertices, num_edges);
 
    // Initialize datasets to store vertices and edges in
    auto dset_vertices = grp->open_dataset("_vertices", { num_vertices });
    auto dset_edges = grp->open_dataset("_edges", { 2, num_edges });
    // NOTE Need shape to be {2, num_edges} because `write` writes line by line.
 
    // Set attributes
    dset_vertices->add_attribute("dim_name__0", "vertex_idx");
    dset_vertices->add_attribute("coords_mode__vertex_idx", "trivial");
 
    dset_edges->add_attribute("dim_name__0", "label");
    dset_edges->add_attribute("coords_mode__label", "values");
    dset_edges->add_attribute("coords__label",
                              std::vector<std::string>{"source", "target"});
    dset_edges->add_attribute("dim_name__1", "edge_idx");
    dset_edges->add_attribute("coords_mode__edge_idx", "trivial");
 
    return std::make_pair(dset_vertices, dset_edges);
}

tuple_tail()

template<typename First , typename Second , typename... Tail>

constexpr std::tuple< Tail... > Utopia::DataIO::GraphUtilsHelper::tuple_tail ( const std::tuple< First, Second, Tail... > &  t )

constexpr

Builds new tuple containing all elements but the first two.

{
    return std::apply([](auto, auto, auto... tail) {
        return std::make_tuple(tail...);}, t);
}