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_FILE_HPP
#define ECHELON_FILE_HPP

#include <echelon/group.hpp>
#include <echelon/link.hpp>
#include <echelon/attribute_repository.hpp>

#include <echelon/hdf5/file.hpp>

#include <string>
#include <memory>

namespace echelon
{

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

    file() = default;
    
    enum class create_mode
    {
        truncate, 
        exclusive 
    };

    enum class open_mode
    {
        read_only, 
        read_write 
    };

    // file interface

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

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

    explicit file(native_handle_type native_handle_);

    // 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 = 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 root_group_.create_dataset<T>(name, 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 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 = 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 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

    native_handle_type native_handle() const;

    explicit operator bool() const;
private:
    hdf5::file file_handle_;
    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