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_GROUP_HPP
#define ECHELON_GROUP_HPP

#include <echelon/object.hpp>
#include <echelon/type.hpp>
#include <echelon/attribute_repository.hpp>
#include <echelon/dataset.hpp>
#include <echelon/scalar_dataset.hpp>
#include <echelon/object_reference.hpp>
#include <echelon/link.hpp>

#include <echelon/hdf5/group.hpp>
#include <echelon/hdf5/type_factory.hpp>

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

namespace echelon
{

class file;

using hdf5::unlimited;

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;
    int compression_level_ = -1;
    bool shuffle_filter_ = false;
    std::vector<hsize_t> chunk_shape_ = {};
};

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

    friend class file;
    
    group() = default;

    explicit group(native_handle_type native_handle_);

    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_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 = dataset_options());
    
    template <typename T>
    dataset create_dataset(const std::string& name, const std::vector<hsize_t>& dims,
                           const dataset_options& options = dataset_options())
    {
        return create_dataset(name, type(hdf5::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 = dataset_options())
    {
        return create_dataset(name, type(hdf5::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, type(hdf5::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 = dataset_options());

    template <typename T>
    dataset require_dataset(const std::string& name, const std::vector<hsize_t>& dims,
                            const dataset_options& options = dataset_options())
    {
        return require_dataset(name, type(hdf5::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, type(hdf5::get_hdf5_type<T>()));
    }

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

    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;

    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 = "/");

    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::group group_handle_;

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

#endif