write_task.hh

Go to the documentation of this file.

#ifndef UTOPIA_DATAIO_DATA_MANAGER_WRITE_TASK_HH
#define UTOPIA_DATAIO_DATA_MANAGER_WRITE_TASK_HH
 
// metaprogramming
#include "../../core/metaprogramming.hh"
#include "../../core/type_traits.hh"
 
// for hdf5 support
#include "../hdfdataset.hh"
#include "../hdfgroup.hh"
 
namespace Utopia
{
namespace DataIO
{
 
template < class BGB, class DW, class DB, class AWG, class AWD >
struct WriteTask final // inheriting from this thing is useless, hence can be final
{
    using BasegroupBuilder       = BGB;
    using Writer                 = DW;
    using Builder                = DB;
    using AttributeWriterGroup   = AWG;
    using AttributeWriterDataset = AWD;
 
    BasegroupBuilder build_basegroup;
 
    std::shared_ptr< HDFGroup > base_group;
 
    std::shared_ptr< HDFDataset> active_dataset;
 
    Writer write_data;
 
    Builder build_dataset;
 
    AttributeWriterDataset write_attribute_active_dataset;
 
    AttributeWriterGroup write_attribute_basegroup;
 
    std::string
    get_active_path()
    {
        if (active_dataset != nullptr)
        {
            return active_dataset->get_path();
        }
        else
        {
            return "";
        }
    }
 
    std::string
    get_base_path()
    {
        if (base_group != nullptr)
        {
            return base_group->get_path();
        }
        else
        {
            return "";
        }
    }
 
    void
    swap(WriteTask& other)
    {
        if (this == &other)
        {
            return;
        }
        else
        {
            using std::swap;
            swap(build_basegroup, other.build_basegroup);
            swap(base_group, other.base_group);
            swap(active_dataset, other.active_dataset);
            swap(write_data, other.write_data);
            swap(build_dataset, other.build_dataset);
            swap(write_attribute_active_dataset,
                 other.write_attribute_active_dataset);
            swap(write_attribute_basegroup, other.write_attribute_basegroup);
        }
    }
 
    template < typename Basegroupbuilder,
               typename Writertype,
               typename Buildertype,
               typename AWritertypeG,
               typename AWritertypeD >
    WriteTask(Basegroupbuilder&& bgb,
              Writertype&&       w,
              Buildertype&&      b,
              AWritertypeG&&     ag,
              AWritertypeD&&     ad) :
        build_basegroup(bgb),
        base_group(nullptr), active_dataset(nullptr), write_data(w),
        build_dataset(b), write_attribute_active_dataset(ad),
        write_attribute_basegroup(ag)
    {
    }
 
    WriteTask() = default;
 
    WriteTask(const WriteTask& other) = default;
 
    WriteTask(WriteTask&& other) = default;
 
    WriteTask&
    operator=(const WriteTask& other) = default;
 
    WriteTask&
    operator=(WriteTask&& other) = default;
 
    ~WriteTask() = default;
};
 
template < class BGB, class DW, class DB, class AWG, class AWD >
void
swap(WriteTask< BGB, DW, DB, AWG, AWD >& lhs,
     WriteTask< BGB, DW, DB, AWG, AWD >& rhs)
{
    lhs.swap(rhs);
}
 
// Deduction guide for WriteTask
template < typename Basegroupbuilder,
           typename Writertype,
           typename Buildertype,
           typename AWritertypeG,
           typename AWritertypeD >
WriteTask(Basegroupbuilder&& bgb,
          Writertype&&       w,
          Buildertype&&      b,
          AWritertypeG&&     ad,
          AWritertypeD&&     ag)
    ->WriteTask< std::decay_t< Basegroupbuilder >,
                 std::decay_t< Writertype >,
                 std::decay_t< Buildertype >,
                 std::decay_t< AWritertypeG >,
                 std::decay_t< AWritertypeD > >;
 
} // namespace DataIO
} // namespace Utopia
 
#endif