Utopia::DataIO::TaskFactory< Model, typetag > Class Template Reference

Functor for building a writetask from arguments. More...

#include <factory.hh>

Public Member Functions
template<class SourceGetter , class Getter , class Group_attribute = Nothing, class Dataset_attribute = Nothing>
std::pair< std::string, std::shared_ptr< Default::DefaultWriteTask< Model > > >	operator() (std::string name, std::string basegroup_path, DatasetDescriptor dataset_descriptor, SourceGetter &&get_source, Getter &&getter, Group_attribute &&group_attribute=Nothing{}, Dataset_attribute &&dataset_attribute=Nothing{})
	Basic factory function producing Default::DefaultWriteTask<Model> intstances, for writing out data. It is inteded to make the setup of a WriteTask simpler for common cases.
std::pair< std::string, std::shared_ptr< Default::DefaultWriteTask< Model > > >	operator() (std::string name, Default::DefaultBaseGroupBuilder group_builder, Default::DefaultDataWriter< Model > writer, Default::DefaultBuilder< Model > dataset_builder, Default::DefaultAttributeWriterGroup< Model > group_attr, Default::DefaultAttributeWriterDataset< Model > dset_attr)
	Thin wrapper around the writetask constructor which allows to construct a writetask via the factory by providing all the functions the latter employs by hand. This is intended for cases where the other operator() is too restrictive.

Private Member Functions
template<class Func , class AttributeHandle >
Func	_make_attribute_writer (AttributeHandle &&attr)
	Function which produces functions for writing attributes to a dataset or group, and which are used by a writer task to write attributes to the dataset and basegroup it creates.
Default::DefaultBuilder< Model >	_make_dataset_builder (DatasetDescriptor dataset_descriptor)
	Function producing a dataset builder function of type Default::DefaultBuilder<Model>, which is responsible for creating new HDF5 datasets on request.
template<class SourceGetter , class Getter >
Default::DefaultDataWriter< Model >	_adapt_graph_writer (SourceGetter &&get_source, Getter &&getter)
	Function which adapts getter functions for the correct graph accessor type, i.e., vertex_descriptor etc.

Static Private Attributes
static std::unordered_map< std::string, std::function< std::string(std::string, Model &) > >	_modifiers
	Initialization of the modifier map.

Detailed Description

template<class Model, TypeTag typetag = TypeTag::plain>
class Utopia::DataIO::TaskFactory< Model, typetag >

Functor for building a writetask from arguments.

Template Parameters

Model	Model type.
TypeTag::plain	Typetag, indicates what type of data source is used, has only to be changed when using graphs.

Member Function Documentation

_adapt_graph_writer()

template<class Model , TypeTag typetag = TypeTag::plain>

template<class SourceGetter , class Getter >

Default::DefaultDataWriter< Model > Utopia::DataIO::TaskFactory< Model, typetag >::_adapt_graph_writer ( SourceGetter &&  get_source, Getter &&  getter  )

inlineprivate

Function which adapts getter functions for the correct graph accessor type, i.e., vertex_descriptor etc.

Template Parameters

SourceGetter	automatically determined
Getter	automatically determined

Parameters

get_source	Function which extracts the source to get data from from its superior structure, e.g., extracting a vertex list from a graph
getter	Function which extracts the data to write from the source, e.g., from the vertex

Returns

Default::DefaultDataWriter< Model >

    {
        Default::DefaultDataWriter< Model > writer;
 
        using GraphType = std::decay_t<
            std::invoke_result_t< std::decay_t< SourceGetter >, Model& > >;
 
        if constexpr (typetag == TypeTag::vertex_property)
        {
            writer = [&getter, &get_source](
                         std::shared_ptr< HDFDataset >& dataset,
                         Model&                                     m) -> void {
                // Collect some information on the graph
                auto& graph = get_source(m);
 
                // Make vertex iterators
                typename GraphType::vertex_iterator v, v_end;
                boost::tie(v, v_end) = boost::vertices(graph);
 
                dataset->write(v, v_end, [&getter, &graph](auto&& vd) {
                    return getter(graph[vd]);
                });
            };
        }
        else if constexpr (typetag == TypeTag::edge_property)
        {
            writer = [&getter, &get_source](
                         std::shared_ptr< HDFDataset >& dataset,
                         Model&                                     m) -> void {
                auto& graph = get_source(m);
 
                // Make edge iterators
                typename GraphType::edge_iterator v, v_end;
                boost::tie(v, v_end) = boost::edges(graph);
 
                dataset->write(v, v_end, [&getter, &graph](auto&& vd) {
                    return getter(graph[vd]);
                });
            };
        }
        else if constexpr (typetag == TypeTag::vertex_descriptor and
                           not std::is_same_v< std::decay_t< Getter >,
                                               std::function< void() > >)
        {
 
            writer = [&getter, &get_source](
                         std::shared_ptr< HDFDataset >& dataset,
                         Model&                                     m) -> void {
                auto& graph = get_source(m);
 
                // Make edge iterators
                typename GraphType::vertex_iterator v, v_end;
                boost::tie(v, v_end) = boost::vertices(graph);
                dataset->write(v, v_end, [&getter, &graph](auto&& vd) {
                    return getter(graph, vd);
                });
            };
        }
        else if constexpr (typetag == TypeTag::edge_descriptor and
                           not std::is_same_v< std::decay_t< Getter >,
                                               std::function< void() > >)
        {
            writer = [&getter, &get_source](
                         std::shared_ptr< HDFDataset >& dataset,
                         Model&                                     m) -> void {
                auto& graph = get_source(m);
 
                // Make edge iterators
                typename GraphType::edge_iterator v, v_end;
                boost::tie(v, v_end) = boost::edges(graph);
 
                dataset->write(v, v_end, [&getter, &graph](auto&& vd) {
                    return getter(graph, vd);
                });
            };
        }
        // for writing pure graphs
 
        // vertex
        else if constexpr (std::is_same_v< std::decay_t< Getter >,
                                           std::function< void() > > and
                           typetag == TypeTag::vertex_descriptor)
        {
            writer = [&get_source](
                         std::shared_ptr< HDFDataset >& dataset,
                         Model&                                     m) -> void {
                auto& graph = get_source(m);
 
                auto [v, v_end] = boost::vertices(graph);
                dataset->write(v, v_end, [&](auto&& vd) {
                    return boost::get(boost::vertex_index_t(), graph, vd);
                });
            };
        }
        // edges
        else if constexpr (std::is_same_v< std::decay_t< Getter >,
                                           std::function< void() > > and
                           typetag == TypeTag::edge_descriptor)
        {
            writer =
                [get_source](std::shared_ptr< HDFDataset >& dataset,
                             Model& m) -> void {
                auto& graph = get_source(m);
 
                auto [e, e_end] = boost::edges(graph);
 
                dataset->write(e, e_end, [&](auto&& ed) {
                    return boost::get(boost::vertex_index_t(),
                                      graph,
                                      boost::source(ed, graph));
                });
 
                dataset->write(e, e_end, [&](auto&& ed) {
                    return boost::get(boost::vertex_index_t(),
                                      graph,
                                      boost::target(ed, graph));
                });
            };
        }
        else
        {
            // user fucked up
            throw std::invalid_argument("Unknown ObjectType.");
        }
 
        return writer;
    }

_make_attribute_writer()

template<class Model , TypeTag typetag = TypeTag::plain>

template<class Func , class AttributeHandle >

Func Utopia::DataIO::TaskFactory< Model, typetag >::_make_attribute_writer ( AttributeHandle &&  attr )

inlineprivate

Function which produces functions for writing attributes to a dataset or group, and which are used by a writer task to write attributes to the dataset and basegroup it creates.

Template Parameters

Func	Function type to produce
Attribute	automatically determined

Parameters

attr	Either 'Nothing' if no attributes shall be written, or a tuple/pair (name, attribute_data) or a function convertible to type Func which takes care of writing dataset attributes, and receives a reference to a model as argument

Returns

Func Function which writes attributes as constructed from arguments.

    {
        using AttrType = std::decay_t< AttributeHandle >;
        Func writer{};
 
        if constexpr (std::is_same_v< AttrType, Nothing >)
        {
            // do nothing here, because nothing shall be done ;)
        }
        else if constexpr (Utopia::Utils::has_static_size_v< AttrType >)
        {
 
            using std::get;
            using Nametype =
                std::decay_t< std::tuple_element_t< 0, AttrType > >;
 
            // if the first thing held by the Dataset_attribute tuplelike is
            // not convertible to stirng, and hence cannot be used to name
            // the thing, error is thrown.
            static_assert(
                Utils::is_string_v< Nametype >,
                "Error, first entry of Dataset_attribute must be a string "
                "naming the attribute");
 
            // check if the $ indicating string interpolation like behavior
            // is found. If yes, invoke path modifier, else leave as is
            std::string name = get< 0 >(attr);
            auto        pos  = name.find('$'); // find indicator
 
            if (pos != std::string::npos)
            {
                auto        path_builder = _modifiers[name.substr(pos + 1)];
                std::string new_path     = name.substr(0, pos);
 
                writer = [attr, path_builder, new_path](auto&& hdfobject,
                                                        auto&& m) -> void {
                    hdfobject->add_attribute(path_builder(new_path, m),
                                             get< 1 >(attr));
                };
            }
            else
            {
                writer = [attr](auto&& hdfobject, auto &&) -> void {
                    hdfobject->add_attribute(get< 0 >(attr),
                                             get< 1 >(attr));
                };
            }
        }
        else
        {
            static_assert(
                Utils::is_callable_v< AttrType >,
                "Error, if the given attribute argument is not a tuple/pair "
                "and not 'Nothing', it has to be a function");
 
            writer = attr;
        }
 
        return writer;
    }

_make_dataset_builder()

template<class Model , TypeTag typetag = TypeTag::plain>

Default::DefaultBuilder< Model > Utopia::DataIO::TaskFactory< Model, typetag >::_make_dataset_builder ( DatasetDescriptor  dataset_descriptor )

inlineprivate

Function producing a dataset builder function of type Default::DefaultBuilder<Model>, which is responsible for creating new HDF5 datasets on request.

Parameters

dataset_descriptor

Describes dataset properties.

Returns

auto Builder object

    {
        Default::DefaultBuilder< Model > dataset_builder;
 
        auto pos = dataset_descriptor.path.find('$'); // find indicator
 
        // $ indicates that string interpolation shall be used
        if (pos != std::string::npos)
        {
            // get the path builder corresponding to the flag extracted after
            // indicator
            auto path_builder =
                _modifiers[dataset_descriptor.path.substr(pos + 1)];
 
            std::string new_path = dataset_descriptor.path.substr(0, pos);
            // put the latter into the dataset builder
            dataset_builder =
                [dataset_descriptor, path_builder, new_path](
                    auto&& group,
                    auto&& model) -> std::shared_ptr< HDFDataset > {
                return group->open_dataset(
                    path_builder(new_path, model),
                    dataset_descriptor.dataset_capacity,
                    dataset_descriptor.dataset_chunksize,
                    dataset_descriptor.dataset_compression);
            };
        }
        else // no string to interpolate something
        {
 
            dataset_builder =
                [dataset_descriptor](
                    std::shared_ptr< HDFGroup >& group,
                    Model&) -> std::shared_ptr< HDFDataset > {
 
                return group->open_dataset(
                    dataset_descriptor.path,
                    dataset_descriptor.dataset_capacity,
                    dataset_descriptor.dataset_chunksize,
                    dataset_descriptor.dataset_compression);
            };
        }
        return dataset_builder;
    }

operator()() [1/2]

template<class Model , TypeTag typetag = TypeTag::plain>

std::pair< std::string, std::shared_ptr< Default::DefaultWriteTask< Model > > > Utopia::DataIO::TaskFactory< Model, typetag >::operator() ( std::string  name, Default::DefaultBaseGroupBuilder  group_builder, Default::DefaultDataWriter< Model >  writer, Default::DefaultBuilder< Model >  dataset_builder, Default::DefaultAttributeWriterGroup< Model >  group_attr, Default::DefaultAttributeWriterDataset< Model >  dset_attr  )

inline

Thin wrapper around the writetask constructor which allows to construct a writetask via the factory by providing all the functions the latter employs by hand. This is intended for cases where the other operator() is too restrictive.

Parameters

name	Name of the task to be build
group_builder	Function to build a HDFGroup to store datasets in
writer	Function which writes out data
dataset_builder	Function to build Datasets
group_attr	Function writing attributes to the task's base group
dset_attr	Function writing attrbutes to the task's currently active dataset

Returns

std::pair<std::string, Default::DefaultWriteTask<Model>>

    {
        return std::make_pair(
            name,
            std::make_shared< Default::DefaultWriteTask< Model > >(
                group_builder, writer, dataset_builder, group_attr, dset_attr));
    }

operator()() [2/2]

template<class Model , TypeTag typetag = TypeTag::plain>

template<class SourceGetter , class Getter , class Group_attribute = Nothing, class Dataset_attribute = Nothing>

std::pair< std::string, std::shared_ptr< Default::DefaultWriteTask< Model > > > Utopia::DataIO::TaskFactory< Model, typetag >::operator() ( std::string  name, std::string  basegroup_path, DatasetDescriptor  dataset_descriptor, SourceGetter &&  get_source, Getter &&  getter, Group_attribute &&  group_attribute = Nothing{}, Dataset_attribute &&  dataset_attribute = Nothing{}  )

inline

Basic factory function producing Default::DefaultWriteTask<Model> intstances, for writing out data. It is inteded to make the setup of a WriteTask simpler for common cases.

Template Parameters

Model	The model class the task refers to. The model is the ultimate source of data in utopia context, hence has to be given.
SourceGetter	A container type, in this context something which has an iterator, automatically determined.
Getter	Unary function type getting SourceGetter::value_type as argument and returning data to be written, automatically determined.
Group_attribute	Either callable of type Default::GroupAttributeWriter or a tuplelike object.
Dataset_attribute	Either callable of type Default::DatasetAttributeWriter or a tuplelike object.

Parameters

name	String naming this task, to be used with config.
basegroup_path	Path in the HDF5 file to the base_group this task stores its produced datasets in.
get_source	Function which returns a container or graph holding the data to use for write
getter	Unary function getting a SourceGetter::value_type argument and returning data to be written.
dataset_descriptor	DatasetDescriptor instance which gives the properties constructed datasets should have, at the very least its path in the basegroup.
group_attribute	Either a callable of type DefaultGroupAttributeWriter or a tuplelike object containing [attribute_name, attribute_data]. Usually, the latter is a descriptive string. The last possiblity is to give 'Nothing', which means that the Attribute should be ignored
dataset_attribute	Either a callable of type DefaultGroupAttributeWriter or some a tuplelike object containing [attribute_name, attribute_data]. Usually, the latter is a descriptive string. The last possiblity is to give 'Nothing', which means that the Attribute should be ignored

Returns

std::pair<std::string, Default::DefaultWriteTask<Model>> pair containing a name and a writetask, to be used with the datamanager.

                                                       {},
        Dataset_attribute&& dataset_attribute = Nothing{})
    {
        // return type of get_source when used with model
        using Container =
            std::decay_t< decltype(get_source(std::declval< Model& >())) >;
 
        // asserts that the SourceGetter-type is really a container type.
        static_assert(
            Utils::is_container_v< std::decay_t< Container > > or
                Utils::is_graph_v< std::decay_t< Container > >,
            "Error, the argument 'get_source' must return a container "
            "type or graph, i.e., "
            "a type with an iterator");
 
        // make basegroup builder and attribute builders
 
        Default::DefaultBuilder< Model > dataset_builder =
            _make_dataset_builder(dataset_descriptor);
 
        auto group_attribute_writer = _make_attribute_writer<
            Default::DefaultAttributeWriterGroup< Model > >(
            std::forward< Group_attribute >(group_attribute));
 
        auto dataset_attribute_writer = _make_attribute_writer<
            Default::DefaultAttributeWriterDataset< Model > >(
            std::forward< Dataset_attribute >(dataset_attribute));
 
        Default::DefaultDataWriter< Model > datawriter;
 
        // assert that the given template argument combination is valid:
        // A graph cannot be written with TypeTag::plain
 
        static_assert(not(Utils::is_graph_v< std::decay_t< Container > > and
                          (typetag == TypeTag::plain)),
                      "Error in WriteTask factory:, a graph cannot be written "
                      "with TypeTag::plain, see documentation of TypeTag enum");
 
        if constexpr (Utils::is_graph_v< std::decay_t< Container > > and
                      (typetag != TypeTag::plain))
        {
            datawriter =
                _adapt_graph_writer(std::forward< SourceGetter >(get_source),
                                    std::forward< Getter >(getter));
        }
        else
        {
 
            datawriter = [getter, get_source](
                             std::shared_ptr< HDFDataset >& dataset,
                             Model& m) -> void {
                dataset->write(
                    get_source(m).begin(), get_source(m).end(), getter);
            };
        }
 
        // build a defaultwriteTask
        return std::make_pair(
            name,
            std::make_shared< Default::DefaultWriteTask< Model > >(
                // builds the basegroup to write datasets in
                Default::DefaultBaseGroupBuilder(
                    [basegroup_path](std::shared_ptr< HDFGroup > parent) {
                        return parent->open_group(basegroup_path);
                    }),
                // writes out data
                datawriter,
                // builds datasets as needed
                dataset_builder,
                // writes attributes to base group
                group_attribute_writer,
                // writes attributes to dataset
                dataset_attribute_writer));
    }

---

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

• include/utopia/data_io/data_manager/factory.hh