hdf5/group.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_GROUP_HPP
#define ECHELON_HDF5_GROUP_HPP

#include <echelon/hdf5/object.hpp>
#include <echelon/hdf5/type.hpp>
#include <echelon/hdf5/type_factory.hpp>
#include <echelon/hdf5/precursor/group.hpp>
#include <echelon/hdf5/attribute_repository.hpp>
#include <echelon/hdf5/dataset.hpp>
#include <echelon/hdf5/scalar_dataset.hpp>
#include <echelon/hdf5/object_reference.hpp>
#include <echelon/hdf5/utility.hpp>
#include <echelon/hdf5/link.hpp>

#include <echelon/hdf5/broken_contract_exception.hpp>

#include <echelon/hdf5/precursor/dataspace.hpp> // for unlimited

#include <string>
#include <vector>
#include <map>
#include <memory>
#include <exception>
#include <functional>

namespace echelon
{
namespace hdf5
{
class file;

using precursor::unlimited;

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

    ~non_existing_member_exception() noexcept
    {
    }

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

private:
    std::string what_;
};

class dataset_options
{
public:
    dataset_options& auto_chunking(bool value)
    {
        auto_chunking_ = value;

        return *this;
    }

    dataset_options& compression_level(int value)
    {
        compression_level_ = value;

        return *this;
    }

    dataset_options& shuffle_filter(bool value)
    {
        shuffle_filter_ = value;

        return *this;
    }

    dataset_options& chunk_shape(std::vector<hsize_t> value)
    {
        chunk_shape_ = std::move(value);

        return *this;
    }

    bool auto_chunking() const
    {
        return auto_chunking_;
    }

    int compression_level() const
    {
        return compression_level_;
    }

    bool shuffle_filter() const
    {
        return shuffle_filter_;
    }

    const std::vector<hsize_t>& chunk_shape() const
    {
        return chunk_shape_;
    }

private:
    bool auto_chunking_ = false;
    bool shuffle_filter_ = false;
    int compression_level_ = -1;
    std::vector<hsize_t> chunk_shape_ = {};
};

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

    friend class file;

    group() = default;
    
    explicit group(native_handle_type group_wrapper_);

    group create_group(const std::string& name);

    dataset create_dataset(const std::string& name, const type& datatype,
                           const std::vector<hsize_t>& dims, const dataset_options& options = {});

    dataset create_dataset(const std::string& name, const type& datatype,
                           const std::vector<hsize_t>& dims, const std::vector<hsize_t>& max_dims,
                           const dataset_options& options = {});
    
    template <typename T>
    dataset create_dataset(const std::string& name, const std::vector<hsize_t>& dims,
                           const dataset_options& options = {})
    {
        return create_dataset(name, get_hdf5_type<T>(), dims, options);
    }

    template <typename T>
    dataset create_dataset(const std::string& name, const std::vector<hsize_t>& dims,
                           const std::vector<hsize_t>& max_dims,const dataset_options& options = {})
    {
        return create_dataset(name, get_hdf5_type<T>(), dims, max_dims, options);
    }
    
    scalar_dataset create_scalar_dataset(const std::string& name, const type& datatype);

    template <typename T>
    scalar_dataset create_scalar_dataset(const std::string& name)
    {
        return create_scalar_dataset(name, get_hdf5_type<T>());
    }

    template <typename T>
    scalar_dataset create_scalar_dataset(const std::string& name, const T& value)
    {
        scalar_dataset ds = create_scalar_dataset<T>(name);

        ds <<= value;

        return ds;
    }

    object operator[](const std::string& name) const;

    void remove(const std::string& name) const;

    group require_group(const std::string& name);

    dataset require_dataset(const std::string& name, const type& datatype,
                            const std::vector<hsize_t>& dims, const dataset_options& options = {});

    template <typename T>
    dataset require_dataset(const std::string& name, const std::vector<hsize_t>& dims,
                            const dataset_options& options = {})
    {
        return require_dataset(name, get_hdf5_type<T>(), dims, options);
    }

    scalar_dataset require_scalar_dataset(const std::string& name, const type& datatype);

    template <typename T>
    scalar_dataset require_scalar_dataset(const std::string& name)
    {
        return require_scalar_dataset(name, get_hdf5_type<T>());
    }

    template <typename T>
    scalar_dataset require_scalar_dataset(const std::string& name, const T& value)
    {
        type datatype = get_hdf5_type<T>();

        if (exists(*this, name) &&
            get_object_type_by_name(*this, name) == object_type::scalar_dataset)
        {
            scalar_dataset ds(hdf5::precursor::dataset(native_handle().id(), name,
                                                       hdf5::precursor::default_property_list));

            if (ds.datatype() != datatype)
                throw broken_contract_exception("The required datatype doesn't "
                                                "match the datatype of the dataset.");

            return ds;
        }
        else
        {
            scalar_dataset ds = create_scalar_dataset(name, datatype);

            ds <<= value;

            return ds;
        }
    }

    void iterate_links(const std::function<void(const link&)>& op) const;

    void visit_links(const std::function<void(const link&)>& visitor) const;

    void visit_objects(const std::function<void(const object&)>& visitor) const;

    object_reference ref() const;

    const native_handle_type& native_handle() const;

    explicit operator bool() const;
private:
    friend class constructor_access;
    friend class object;

    enum class creation_mode
    {
        open,
        create
    };

    explicit group(const file& loc, const std::string& name = "/");
    group(const object& parent, const std::string& name, creation_mode mode);

    dataset create_dataset(const std::string& name, const type& datatype,
                           const std::vector<hsize_t>& dims, const std::vector<hsize_t>& max_dims,
                           int comp_level, bool auto_chunking, bool shuffle_filter,
                           const std::vector<hsize_t> chunk_shape);

    hdf5::precursor::group group_wrapper_;

public:
    attribute_repository<group> attributes() const;
};
}
}

#endif