hdf5/slice.hpp

//  Copyright (c) 2012-2014 Christopher Hinz
//
//  Distributed under the Boost Software License, Version 1.0. (See accompanying
//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef ECHELON_HDF5_SLICE_HPP
#define ECHELON_HDF5_SLICE_HPP

#include <echelon/hdf5/precursor/dataspace.hpp>
#include <echelon/hdf5/precursor/dataset.hpp>
#include <echelon/hdf5/storage_layer.hpp>
#include <echelon/hdf5/container_adaption.hpp>
#include <echelon/hdf5/range.hpp>
#include <echelon/hdf5/array_slice.hpp>

#include <cassert>
#include <vector>
#include <tuple>

namespace echelon
{
namespace hdf5
{

class slice
{
public:
    slice(hdf5::precursor::dataset sliced_dataset_,
          const std::vector<totally_bound_range_t>& ranges);

    template <typename T>
    void operator<<=(const T& source)
    {
        auto current_shape = shape_adl(source);

        std::vector<hsize_t> mem_shape(begin(current_shape), end(current_shape));

        hdf5::precursor::dataspace mem_space(mem_shape);
        hdf5::precursor::dataspace file_space = selected_dataspace_;
        hdf5::precursor::type datatype = sliced_dataset_.datatype();

        write(sliced_dataset_, datatype, mem_space, file_space, source);
    }

    template <typename T>
    friend void operator<<=(T& sink, const slice& source)
    {
        auto current_shape = shape_adl(sink);
        
        std::vector<hsize_t> mem_shape(begin(current_shape), end(current_shape));

        hdf5::precursor::dataspace mem_space(mem_shape);
        hdf5::precursor::dataspace file_space = source.selected_dataspace_;
        hdf5::precursor::type datatype = source.sliced_dataset_.datatype();

        read(source.sliced_dataset_, datatype, mem_space, file_space, sink);
    }

    template <typename T>
    void operator<<=(const array_slice<T>& source)
    {
        auto current_shape = source.original_shape();

        std::vector<hsize_t> mem_shape(begin(current_shape), end(current_shape));

        hdf5::precursor::dataspace mem_space(mem_shape);
        hdf5::precursor::dataspace file_space = selected_dataspace_;
        hdf5::precursor::type datatype = sliced_dataset_.datatype();

        auto slice_shape = source.shape();
        std::vector<hsize_t> count;

        for (std::size_t i = 0; i < slice_shape.size(); ++i)
        {
            count.push_back(slice_shape[i] / source.stride()[i]);
        }

        mem_space.select_hyperslab(H5S_SELECT_SET, source.offset(), source.stride(), count);

        write(sliced_dataset_, datatype, mem_space, file_space, source);
    }

    template <typename T>
    friend void operator<<=(const array_slice<T>& sink, const slice& source)
    {
        auto current_shape = sink.original_shape();

        std::vector<hsize_t> mem_shape(begin(current_shape), end(current_shape));

        hdf5::precursor::dataspace mem_space(mem_shape);
        hdf5::precursor::dataspace file_space = source.selected_dataspace_;
        hdf5::precursor::type datatype = source.sliced_dataset_.datatype();

        auto slice_shape = sink.shape();
        std::vector<hsize_t> count;

        for (std::size_t i = 0; i < slice_shape.size(); ++i)
        {
            count.push_back(slice_shape[i] / sink.stride()[i]);
        }

        mem_space.select_hyperslab(H5S_SELECT_SET, sink.offset(), sink.stride(), count);

        read(source.sliced_dataset_, datatype, mem_space, file_space, sink);
    }

    const std::vector<hsize_t>& shape() const;

private:
    hdf5::precursor::dataset sliced_dataset_;
    hdf5::precursor::dataspace selected_dataspace_;

    std::vector<hsize_t> size_;
};
}
}

#endif