hdf5/file.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_FILE_HPP
#define ECHELON_HDF5_FILE_HPP

#include <echelon/hdf5/group.hpp>
#include <echelon/hdf5/link.hpp>
#include <echelon/hdf5/precursor/file.hpp>

#include <string>
#include <memory>

namespace echelon
{
namespace hdf5
{
class file
{
public:
    using native_handle_type = hdf5::precursor::file;

    enum class create_mode
    {
        truncate, 
        exclusive 
    };

    enum class open_mode
    {
        read_only, 
        read_write 
    };

    // file interface

    file() = default;
    
    file(const std::string& path, create_mode mode);

    file(const std::string& path, open_mode mode);

    explicit file(native_handle_type file_wrapper_);

    // group interface

    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 = {});

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

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

    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 root_group_.require_dataset<T>(name, 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 root_group_.require_scalar_dataset<T>(name);
    }

    template <typename T>
    scalar_dataset require_scalar_dataset(const std::string& name, const T& value)
    {
        return root_group_.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;

    // general interface

    const native_handle_type& native_handle() const;

    explicit operator bool() const;
private:
    hdf5::precursor::file file_wrapper_;
    group root_group_;

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

group mount(const file& mounted_file, const group& mount_point);

group mount(const file& mounted_file, const file& mount_point);

void unmount(const group& mount_point);
}
}

#endif