hdf5/dataset.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_DATASET_HPP
#define ECHELON_HDF5_DATASET_HPP

#include <echelon/hdf5/object.hpp>

#include <echelon/hdf5/type.hpp>
#include <echelon/hdf5/type_factory.hpp>
#include <echelon/hdf5/object_reference.hpp>

#include <echelon/hdf5/slice.hpp>
#include <echelon/hdf5/range.hpp>
#include <echelon/hdf5/container_adaption.hpp>
#include <echelon/hdf5/array_slice.hpp>

#include <echelon/hdf5/attribute_repository.hpp>
#include <echelon/hdf5/dataset_dimensions.hpp>
#include <echelon/hdf5/storage_layer.hpp>

#include <echelon/hdf5/precursor/dataset.hpp>
#include <echelon/hdf5/precursor/dataspace.hpp>
#include <echelon/hdf5/precursor/property_list.hpp>

#include <echelon/utility/macros.hpp>

#include <vector>
#include <tuple>
#include <string>
#include <type_traits>
#include <cassert>
#include <iterator>
#include <exception>
#include <utility>

namespace echelon
{
namespace hdf5
{

class invalid_layout_exception : public std::exception
{
public:
    explicit invalid_layout_exception(std::string what_) : what_{std::move(what_)}
    {
    }

    const char* what() const noexcept override
    {
        return what_.c_str();
    }

private:
    std::string what_;
};

class dataset
{
public:
    using native_handle_type = hdf5::precursor::dataset;

    dataset() = default;
    
    dataset(const object& parent, const std::string& name, const type& datatype,
            const std::vector<hsize_t>& shape, const std::vector<hsize_t>& max_dims, int comp_level,
            bool auto_chunking, bool shuffle_filter, const std::vector<hsize_t> chunk_shape);

    explicit dataset(native_handle_type native_handle_);

    template <typename T>
    friend void operator<<=(dataset& sink, const T& source)
    {
        using std::begin;
        using std::end;

        const 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 = sink.dataset_handle_.get_space();
        hdf5::precursor::type datatype = sink.dataset_handle_.datatype();

        write(sink.dataset_handle_, datatype, mem_space, file_space, source);
    }

    template <typename T>
    friend void operator<<=(T& sink, const dataset& source)
    {
        using std::begin;
        using std::end;

        const 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.dataset_handle_.get_space();
        hdf5::precursor::type datatype = source.dataset_handle_.datatype();

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

    template <typename T>
    friend void operator<<=(dataset& sink, const array_slice<T>& source)
    {
        using std::begin;
        using std::end;

        const 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 = sink.dataset_handle_.get_space();
        hdf5::precursor::type datatype = sink.dataset_handle_.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(sink.dataset_handle_, datatype, mem_space, file_space, source);
    }

    template <typename T>
    friend void operator<<=(const array_slice<T>& sink, const dataset& source)
    {
        using std::begin;
        using std::end;

        const 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.dataset_handle_.get_space();
        hdf5::precursor::type datatype = source.dataset_handle_.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.dataset_handle_, datatype, mem_space, file_space, sink);
    }
    
    template <typename Container>
    void extend_along(std::size_t dimension_index, const Container& container) const
    {
        using std::begin;
        using std::end;
      
        auto extent = shape();
        auto new_extent = extent;
        auto container_shape = shape_adl(container);

        for (std::size_t i = 0; i < extent.size(); ++i)
        {
            if (i != dimension_index && container_shape[i] != extent[i])
                throw invalid_layout_exception(
                    "extent of non-extended dimension differs between container and dataset");
        }

        new_extent[dimension_index] += container_shape[dimension_index];

        dataset_handle_.set_extent(new_extent);

        // FIXME: extend slicing and refactor this code
        std::vector<hsize_t> mem_shape(begin(container_shape), end(container_shape));

        hdf5::precursor::dataspace mem_space(mem_shape);
        hdf5::precursor::dataspace file_space = dataset_handle_.get_space();
        hdf5::precursor::type datatype = dataset_handle_.datatype();

        std::vector<hsize_t> offset(rank());
        offset[dimension_index] = extent[dimension_index];

        file_space.select_hyperslab(H5S_SELECT_SET, offset, mem_shape);

        write(dataset_handle_, datatype, mem_space, file_space, container);
    }

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

    std::size_t rank() const;

    type datatype() const;

    template <typename... Args>
    slice operator()(Args... args) const
    {
        std::vector<hsize_t> current_shape = shape();

        std::vector<totally_bound_range_t> boundaries;

        detail::calculate_slice_boundaries<0, Args...>::eval(current_shape, boundaries, args...);

        return slice(dataset_handle_, boundaries);
    }

    object_reference ref() const;

    const native_handle_type& native_handle() const;
    
    explicit operator bool() const;
private:
    hdf5::precursor::dataset dataset_handle_;

public:
    attribute_repository<dataset> attributes() const;

    dataset_dimensions dimensions() const;
};
}
}

#endif