hdf5.h

Go to the documentation of this file.

 
 
#ifndef THEORETICA_IO_HDF5_H
#define THEORETICA_IO_HDF5_H
 
#include <hdf5.h>
 
#include <string>
#include <vector>
#include <unordered_map>
#include <stdexcept>
#include <cstring>
#include <sstream>
#include <algorithm>
 
#include "./error.h"
#include "../core/constants.h"
#include "../algebra/vec.h"
#include "../algebra/mat.h"
 
 
namespace theoretica {
namespace io {
 
 
    // Data structures and representations
 
    enum class HDF5NodeType {
        
        UNKNOWN,
 
        GROUP,
 
        DATASET
    };
 
 
    struct hdf5_node {
 
        std::string name;
 
        std::string path;
 
        HDF5NodeType type;
        
        std::vector<size_t> dimensions;
 
        std::vector<std::string> attributes;
 
        std::unordered_map<std::string, hdf5_node> children;
 
 
        inline bool is_group() const noexcept {
            return type == HDF5NodeType::GROUP;
        }
 
 
        inline bool is_dataset() const noexcept {
            return type == HDF5NodeType::DATASET;
        }
 
 
        inline hdf5_node& operator[](const std::string& child_name) {
            return children[child_name];
        }
 
 
        inline const hdf5_node& operator[](const std::string& child_name) const {
            return children.at(child_name);
        }
    };
 
 
    struct hdf5_handle {
 
        hid_t id;
        
 
        hdf5_handle(hid_t id = H5I_INVALID_HID) : id(id) {}
        
 
        ~hdf5_handle() {
 
            if (id == H5I_INVALID_HID || !H5Iis_valid(id)) return;
            switch (H5Iget_type(id)) {
                case H5I_FILE:          H5Fclose(id); break;
                case H5I_GROUP:         H5Gclose(id); break;
                case H5I_DATASET:       H5Dclose(id); break;
                case H5I_DATATYPE:      H5Tclose(id); break;
                case H5I_DATASPACE:     H5Sclose(id); break;
                case H5I_ATTR:          H5Aclose(id); break;
                case H5I_GENPROP_LST:   H5Pclose(id); break;
                default:                H5Idec_ref(id); break;
            }
        }
        
 
        hdf5_handle(const hdf5_handle&) = delete;
        hdf5_handle& operator=(const hdf5_handle&) = delete;
        
 
        hdf5_handle(hdf5_handle&& other) noexcept : id(other.id) {
            other.id = H5I_INVALID_HID;
        }
 
 
        hdf5_handle& operator=(hdf5_handle&& other) noexcept {
 
            if (this != &other) {
                
                if (id >= 0 && H5Iis_valid(id))
                    H5Idec_ref(id);
                
                id = other.id;
                other.id = H5I_INVALID_HID;
            }
 
            return *this;
        }
 
 
        operator hid_t() const {
            return id;
        }
    };
 
 
    namespace _internal {
 
        template<typename Type>
        inline hid_t hdf5_type() {
            TH_IO_ERROR("io::_internal::hdf5_type", "hdf5_type<Type>", IoError::FormatError);
            return H5I_INVALID_HID;
        }
 
        template<> inline hid_t hdf5_type<double>() { return H5T_NATIVE_DOUBLE; }
        template<> inline hid_t hdf5_type<float>()  { return H5T_NATIVE_FLOAT; }
        template<> inline hid_t hdf5_type<int>()    { return H5T_NATIVE_INT; }
        template<> inline hid_t hdf5_type<long>()   { return H5T_NATIVE_LONG; }
        template<> inline hid_t hdf5_type<unsigned int>() { return H5T_NATIVE_UINT; }
 
 
        inline void suppress_errors() {
            H5Eset_auto(H5E_DEFAULT, nullptr, nullptr);
        }
 
 
        inline void remove_link(const hdf5_handle& id, const std::string& path) {
 
            suppress_errors();
            if (H5Lexists(id, path.c_str(), H5P_DEFAULT) > 0) {
                H5Ldelete(id, path.c_str(), H5P_DEFAULT);
            }
        }
 
 
        // Attributes
 
        // Count attributes callback for H5Aiterate2
        static herr_t attribute_callback(hid_t id, const char* attr_name, const H5A_info_t* info_ptr, void* op_data) {
 
            auto* attrs = (std::vector<std::string>*) op_data;
            attrs->emplace_back(attr_name);
            return 0;
        }
 
 
        // Load all attributes for a given object into a vector of strings
        inline void load_attributes(hid_t obj_id, std::vector<std::string>& attributes) {
            H5Aiterate2(obj_id, H5_INDEX_CRT_ORDER, H5_ITER_INC, NULL, attribute_callback, &attributes);
        }
 
 
        // Read and write attributes of various types, with error handling
        template<typename Type>
        inline void read_attribute(hid_t attr_id, Type& value) {
 
            if (H5Aread(attr_id, hdf5_type<Type>(), &value) < 0) {
                TH_IO_ERROR("io::read_attribute", "attribute_id", IoError::FormatError);
                value = Type();
            }
        }
 
 
        // Read a string attribute
        inline void read_attribute(hid_t attr_id, std::string& value) {
 
            hdf5_handle type_id = H5Aget_type(attr_id);
            if (H5Tget_class(type_id) != H5T_STRING) {
                TH_IO_ERROR("io::read_attribute", "attribute_id", IoError::FormatError);
                value = std::string();
                return;
            }
            
            const int is_varstring = H5Tis_variable_str(type_id);
            if (is_varstring > 0) {
 
                char* buf = nullptr;
                hdf5_handle mem_type = H5Tcopy(H5T_C_S1);
                H5Tset_size(mem_type, H5T_VARIABLE);
 
                if (H5Aread(attr_id, mem_type, &buf) < 0) {
                    TH_IO_ERROR("io::read_attribute", "attribute_id", IoError::ReadError);
                    value = std::string();
                    return;
                }
                
                value = buf ? std::string(buf) : std::string();
                if (buf)
                    H5free_memory(buf);
 
            } else if (is_varstring == 0) {
 
                const size_t size = H5Tget_size(type_id);
                std::vector<char> buf (size + 1, '\0');
 
                hdf5_handle mem_type = H5Tcopy(H5T_C_S1);
                H5Tset_size(mem_type, size);
                if (H5Aread(attr_id, mem_type, buf.data()) < 0) {
                    TH_IO_ERROR("io::read_attribute", "attribute_id", IoError::ReadError);
                    value = std::string();
                    return;
                }
                
                value = std::string(buf.data());
 
            } else {
                TH_IO_ERROR("io::read_attribute", "attribute_id", IoError::FormatError);
                value = std::string();
                return;
            }
        }
 
 
        // Write an attribute of a generic type, creating it if it doesn't exist
        template<typename Type>
        inline void write_attribute(hid_t obj_id, const std::string& name, const Type& value) {
 
            hdf5_handle space_id = H5Screate(H5S_SCALAR);
            hdf5_handle attr_id = H5Acreate2(obj_id, name.c_str(), hdf5_type<Type>(), space_id, H5P_DEFAULT, H5P_DEFAULT);
 
            if (attr_id < 0) {
                TH_IO_ERROR("io::write_attribute", "attribute_id", IoError::WriteError);
                return;
            }
 
            if (H5Awrite(attr_id, hdf5_type<Type>(), &value) < 0)
                TH_IO_ERROR("io::write_attribute", "attribute_id", IoError::WriteError);
        }
 
 
        // Write a string attribute
        inline void write_attribute(hid_t obj_id, const std::string& name, const std::string& value) {
 
            hdf5_handle space_id = H5Screate(H5S_SCALAR);
            hdf5_handle type_id = H5Tcopy(H5T_C_S1);
            H5Tset_size(type_id, value.empty() ? 1 : value.length());
            H5Tset_strpad(type_id, H5T_STR_NULLTERM);
            
            hdf5_handle attr_id = H5Acreate2(obj_id, name.c_str(), type_id, space_id, H5P_DEFAULT, H5P_DEFAULT);
            if (attr_id < 0) {
                TH_IO_ERROR("io::write_attribute", "attribute_id", IoError::WriteError);
                return;
            }
 
            if (H5Awrite(attr_id, type_id, value.c_str()) < 0) {
                TH_IO_ERROR("io::write_attribute", "attribute_id", IoError::WriteError);
            }
        }
 
 
        // Write a C-style string attribute
        inline void write_attribute(hid_t obj_id, const std::string& name, const char* str) {
            write_attribute(obj_id, name, std::string(str));
        }
 
        
        // Recursively iterates over group members to build the hdf5_node tree structure
        inline herr_t iter_callback(hid_t id, const char* name, const H5L_info_t* info, void* opdata) {
 
            hdf5_node* parent = (hdf5_node*) opdata;
            hdf5_node child;
            child.name = name;
 
            // Build full child path
            if (parent->path == "/")
                child.path = "/" + std::string(name);
            else
                child.path = parent->path + "/" + std::string(name);
 
            // Open object by absolute child path from current location
            hdf5_handle obj_id = H5Oopen(id, name, H5P_DEFAULT);
            if (obj_id < 0) {
                child.type = HDF5NodeType::UNKNOWN;
                parent->children.emplace(child.name, std::move(child));
                return 0;
            }
 
            const H5I_type_t obj_type = H5Iget_type(obj_id);
            if (obj_type == H5I_GROUP) {
 
                child.type = HDF5NodeType::GROUP;
 
                // Read group attributes
                load_attributes(obj_id, child.attributes);
 
                // Recursion by opening the group and iterating inside it
                hdf5_handle gid = H5Gopen2(id, name, H5P_DEFAULT);
                if (gid >= 0)
                    H5Literate(gid, H5_INDEX_NAME, H5_ITER_INC, NULL, iter_callback, &child);
 
            } else if (obj_type == H5I_DATASET) {
 
                child.type = HDF5NodeType::DATASET;
 
                // Dataset shape
                hdf5_handle space_id = H5Dget_space(obj_id);
                const int ndims = H5Sget_simple_extent_ndims(space_id);
                if (ndims > 0) {
                    std::vector<hsize_t> dims (static_cast<size_t>(ndims));
                    H5Sget_simple_extent_dims(space_id, dims.data(), NULL);
                    child.dimensions = dims;
                }
 
                // Dataset attributes
                load_attributes(obj_id, child.attributes);
 
            } else {
 
                child.type = HDF5NodeType::UNKNOWN;
                load_attributes(obj_id, child.attributes);
            }
 
            parent->children.emplace(child.name, std::move(child));
            return 0;
        }
 
 
        // Helper function to recursively build a formatted
        // tree string representation of the HDF5 structure
        inline void build_tree(
            std::ostringstream& oss, const hdf5_node& node,
            const std::string& prefix, bool is_last, bool is_root) {
 
            // Current node line
            if (is_root)
                oss << (node.name.empty() ? "/" : node.name);
            else
                oss << prefix << (is_last ? "└── " : "├── ") << node.name;
 
 
            // Print dataset
            if (node.is_dataset()) {
 
                oss << " [";
                for (size_t i = 0; i < node.dimensions.size(); ++i) {
                    oss << node.dimensions[i];
                    if (i + 1 < node.dimensions.size())
                        oss << ", ";
                }
                oss << "]";
            }
 
 
            // Show attribute count
            if (!node.attributes.empty()) {
                oss << " (@" << node.attributes.size() << " attrs)";
            }
            oss << "\n";
 
 
            if (node.children.empty())
                return;
 
            // Print group children recursively
            size_t i = 0;
            const std::string child_prefix = is_root ? "" : (prefix + (is_last ? "    " : "│   "));
            for (auto& pair : node.children) {
 
                const bool is_last_child = (node.children.size() == i + 1);
                build_tree(
                    oss,
                    pair.second,
                    child_prefix,
                    is_last_child,
                    false
                );
 
                i++;
            }
        }
    }
 
 
    // Output formatting
 
    inline std::string to_string(const hdf5_node& node) {
        std::ostringstream oss;
        _internal::build_tree(oss, node, "", true, true);
        return oss.str();
    }
 
 
    inline std::ostream& operator<<(std::ostream& os, const hdf5_node& node) {
        return os << to_string(node);
    }
 
 
    // Public API using handles, for continued operations on an open file or group
 
    inline hdf5_handle hdf5_open(const std::string& filename, bool write = false) {
 
        _internal::suppress_errors();
        hid_t file_id;
 
        // Open the file with write permissions,
        // creating it if it doesn't exist.
        if (write) {
 
            file_id = H5Fopen(filename.c_str(), H5F_ACC_RDWR, H5P_DEFAULT);
 
            if (file_id < 0) {
 
                file_id = H5Fcreate(filename.c_str(), H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
 
                if (file_id < 0) {
                    TH_IO_ERROR("io::hdf5_open", filename, IoError::WriteError);
                    return H5I_INVALID_HID;
                }
            }
 
        } else {
 
            // Open with read-only access.
            file_id = H5Fopen(filename.c_str(), H5F_ACC_RDONLY, H5P_DEFAULT);
 
            if (file_id < 0) {
                TH_IO_ERROR("io::hdf5_open", filename, IoError::FileNotFound);
                return H5I_INVALID_HID;
            }
        }
 
        return hdf5_handle(file_id);
    }
 
 
    inline bool hdf5_is_valid(const hdf5_handle& handle) {
        return H5Iis_valid(handle.id);
    }
 
 
    inline hdf5_node hdf5_load(const hdf5_handle& id) {
 
        _internal::suppress_errors();
 
        hdf5_node root;
        root.name = "/";
        root.path = "/";
        root.type = HDF5NodeType::GROUP;
        root.dimensions.clear();
        root.attributes.clear();
        root.children.clear();
 
        _internal::load_attributes(id, root.attributes);
        H5Literate(id, H5_INDEX_NAME, H5_ITER_INC, NULL, _internal::iter_callback, &root);
 
        return root;
    }
 
 
    inline void hdf5_create_group(const hdf5_handle& id, const std::string& path) {
 
        _internal::suppress_errors();
 
        // Already exists, do nothing
        if (H5Lexists(id, path.c_str(), H5P_DEFAULT) > 0)
            return;
 
        hid_t gid = H5Gcreate2(id, path.c_str(), H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
        if (gid < 0) {
            TH_IO_ERROR("io::hdf5_create_group", path, IoError::WriteError);
            return;
        }
 
        hdf5_handle h_group(gid);
    }
 
 
    inline void hdf5_delete_group(const hdf5_handle& id, const std::string& path) {
 
        _internal::suppress_errors();
 
        // Do nothing if it doesn't exist
        if (H5Lexists(id, path.c_str(), H5P_DEFAULT) <= 0)
            return;
 
        if (H5Ldelete(id, path.c_str(), H5P_DEFAULT) < 0) {
            TH_IO_ERROR("io::hdf5_delete_group", path, IoError::WriteError);
        }
    }
 
 
    // Metadata handling
 
    template<typename Type>
    inline Type hdf5_read_attribute(const hdf5_handle& id, const std::string& path, const std::string& attr_name) {
 
        _internal::suppress_errors();
 
        hid_t obj_id = H5Oopen(id, path.c_str(), H5P_DEFAULT);
        if (obj_id < 0) {
            TH_IO_ERROR("io::read_attribute", path, IoError::FileNotFound);
            return Type();
        }
 
        hdf5_handle h_obj (obj_id);
        hid_t attr_id = H5Aopen(obj_id, attr_name.c_str(), H5P_DEFAULT);
        if (attr_id < 0) {
            TH_IO_ERROR("io::read_attribute", path + "@" + attr_name, IoError::FileNotFound);
            return Type();
        }
        hdf5_handle h_attr (attr_id);
        
        Type value;
        _internal::read_attribute(attr_id, value);
        return value;
    }
 
 
    inline void hdf5_delete_attribute(const hdf5_handle& id, const std::string& path, const std::string& attr_name) {
 
        _internal::suppress_errors();
 
        hid_t obj_id = H5Oopen(id, path.c_str(), H5P_DEFAULT);
        if (obj_id < 0) {
            TH_IO_ERROR("io::delete_attribute", path, IoError::FileNotFound);
            return;
        }
 
        hdf5_handle h_obj (obj_id);
 
        if (H5Aexists(obj_id, attr_name.c_str()) > 0) {
            if (H5Adelete(obj_id, attr_name.c_str()) < 0) {
                TH_IO_ERROR("io::delete_attribute", path + "@" + attr_name, IoError::WriteError);
            }
        }
    }
 
 
    template<typename Type>
    inline void hdf5_write_attribute(const hdf5_handle& id, const std::string& path, const std::string& attr_name, const Type& value) {
 
        _internal::suppress_errors();
        hid_t obj_id = H5Oopen(id, path.c_str(), H5P_DEFAULT);
        if (obj_id < 0) {
            TH_IO_ERROR("io::write_attribute", path, IoError::FileNotFound);
            return;
        }
 
        hdf5_handle h_obj (obj_id);
        if (H5Aexists(obj_id, attr_name.c_str()) > 0)
            H5Adelete(obj_id, attr_name.c_str());
 
        _internal::write_attribute(obj_id, attr_name, value);
    }
 
 
    // Dataset IO for vectors and matrices
 
 
    template<typename Vector = vec<real>>
    inline Vector& hdf5_read_vec(const hdf5_handle& id, const std::string& path, Vector& v) {
 
        using Type = vector_element_t<Vector>;
        
        _internal::suppress_errors();
        hid_t data_id = H5Dopen2(id, path.c_str(), H5P_DEFAULT);
        if (data_id < 0) {
            TH_IO_ERROR("io::hdf5_read_vec", path, IoError::FileNotFound);
            return algebra::vec_error(v);
        }
        hdf5_handle h_dset (data_id);
        
        hdf5_handle h_space = H5Dget_space(data_id);
 
        // Dataset must be 1D to read into a vector
        if (H5Sget_simple_extent_ndims(h_space) != 1) {
            TH_IO_ERROR("io::hdf5_read_vec", path, IoError::FormatError);
            return algebra::vec_error(v);
        }
        
        hsize_t dims[1];
        H5Sget_simple_extent_dims(h_space, dims, NULL);
        
        v.resize(dims[0], nan());
        if (v.size() != dims[0]) {
            TH_IO_ERROR("io::hdf5_read_vec", path, IoError::FormatError);
            return algebra::vec_error(v);
        }
 
        if (H5Dread(data_id, _internal::hdf5_type<Type>(), H5S_ALL, H5S_ALL, H5P_DEFAULT, v.data()) < 0) {
            TH_IO_ERROR("io::hdf5_read_vec", path, IoError::ReadError);
            return algebra::vec_error(v);
        }
 
        return v;
    }
 
 
    template<typename Vector = vec<real>>
    inline Vector hdf5_read_vec(const hdf5_handle& id, const std::string& path) {
        Vector v;
        return hdf5_read_vec(id, path, v);
    }
 
 
    template<typename Vector>
    inline void hdf5_write_vec(const hdf5_handle& id, const std::string& path, const Vector& v) {
 
        using Type = vector_element_t<Vector>;
        _internal::remove_link(id, path);
        
        hsize_t dims[1] = { (hsize_t) v.size() };
        hdf5_handle h_space = H5Screate_simple(1, dims, NULL);
        
        hid_t data_id = H5Dcreate2(id, path.c_str(), _internal::hdf5_type<Type>(), h_space, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
        if (data_id < 0) {
            TH_IO_ERROR("io::hdf5_write_vec", path, IoError::WriteError);
            return;
        }
        hdf5_handle h_dset(data_id);
        
        if (H5Dwrite(data_id, _internal::hdf5_type<Type>(), H5S_ALL, H5S_ALL, H5P_DEFAULT, v.data()) < 0) {
            TH_IO_ERROR("io::hdf5_write_vec", path, IoError::WriteError);
        }
    }
 
 
    inline void hdf5_delete_dataset(const hdf5_handle& id, const std::string& path) {
 
        _internal::suppress_errors();
 
        if (H5Lexists(id, path.c_str(), H5P_DEFAULT) > 0) {
            if (H5Ldelete(id, path.c_str(), H5P_DEFAULT) < 0) {
                TH_IO_ERROR("io::hdf5_delete_dataset", path, IoError::WriteError);
            }
        }
    }
 
 
    template<typename Matrix = mat<real>>
    inline Matrix hdf5_read_mat(const hdf5_handle& id, const std::string& path, Matrix& m) {
 
        using Type = matrix_element_t<Matrix>;
        _internal::suppress_errors();
 
        hid_t data_id = H5Dopen2(id, path.c_str(), H5P_DEFAULT);
        if (data_id < 0) {
            TH_IO_ERROR("io::hdf5_read_mat", path, IoError::FileNotFound);
            return algebra::mat_error(m);
        }
        hdf5_handle h_dset(data_id);
        
        hdf5_handle h_space = H5Dget_space(data_id);
        if (H5Sget_simple_extent_ndims(h_space) != 2) {
            TH_IO_ERROR("io::hdf5_read_mat", path, IoError::FormatError);
            return algebra::mat_error(m);
        }
        
        hsize_t dims[2];
        H5Sget_simple_extent_dims(h_space, dims, NULL);
        
        m.resize(dims[0], dims[1]);
        if (m.rows() != dims[0] || m.cols() != dims[1]) {
            TH_IO_ERROR("io::hdf5_read_mat", path, IoError::FormatError);
            return algebra::mat_error(m);
        }
 
        if (H5Dread(data_id, _internal::hdf5_type<Type>(), H5S_ALL, H5S_ALL, H5P_DEFAULT, m.data()) < 0) {
            TH_IO_ERROR("io::hdf5_read_mat", path, IoError::ReadError);
            return algebra::mat_error(m);
        }
 
        return m;
    }
 
 
    template<typename Matrix = mat<real>>
    inline Matrix hdf5_read_mat(const hdf5_handle& id, const std::string& path) {
        Matrix m;
        return hdf5_read_mat(id, path, m);
    }
 
 
    template<typename Matrix>
    inline void hdf5_write_mat(const hdf5_handle& id, const std::string& path, const Matrix& m) {
 
        using Type = matrix_element_t<Matrix>;
        _internal::remove_link(id, path);
        
        hsize_t dims[2] = { hsize_t(m.rows()), hsize_t(m.cols()) };
        hdf5_handle h_space = H5Screate_simple(2, dims, NULL);
        
        hid_t data_id = H5Dcreate2(id, path.c_str(), _internal::hdf5_type<Type>(), h_space, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
        if (data_id < 0) {
            TH_IO_ERROR("io::hdf5_write_mat", "dataset_path", IoError::FormatError);
            return;
        }
        
        hdf5_handle h_dset (data_id);
        if (H5Dwrite(data_id, _internal::hdf5_type<Type>(), H5S_ALL, H5S_ALL, H5P_DEFAULT, m.data()) < 0) {
            TH_IO_ERROR("io::hdf5_write_mat", "dataset_path", IoError::WriteError);
        }
    }
 
 
    class hdf5_file {
    private:
        
        std::string m_filename;
 
        hdf5_handle m_file_id; 
 
        hdf5_node m_root;
 
    public:
 
        explicit hdf5_file(const std::string& filename, bool write = false) : m_filename(filename) {
            m_file_id = hdf5_open(m_filename, write);
            
            if (hdf5_is_valid(m_file_id))
                refresh();
        }
 
 
        void refresh() {
 
            // Always rebuild from scratch
            m_root = hdf5_node{};
            m_root.name = "/";
            m_root.path = "/";
            m_root.type = HDF5NodeType::GROUP;
            m_root.dimensions.clear();
            m_root.attributes.clear();
            m_root.children.clear();
 
            // Rebuild root from open file handle
            m_root = hdf5_load(m_file_id);
 
            // Keep root name as filename
            m_root.name = m_filename;
        }
 
 
        void close() {
 
            H5Fclose(m_file_id);
            m_file_id = H5I_INVALID_HID;
 
            // Clear cached structure
            m_root = hdf5_node();
        }
 
 
        const std::string& filename() const {
            return m_filename;
        }
 
 
        const hdf5_node& root() const {
            return m_root;
        }
 
 
        hid_t id() const {
            return m_file_id;
        }
 
 
        hdf5_node& operator[](const std::string& child_name) {
            return m_root[child_name];
        }
 
 
        const hdf5_node& operator[](const std::string& child_name) const {
            return m_root[child_name];
        }
 
 
        inline void create_group(const std::string& path) {
            hdf5_create_group(m_file_id, path);
        }
 
 
        inline void create_group(const hdf5_node& parent, const std::string& child_name) {
 
            const std::string path = (parent.path == "/")
                ? ("/" + child_name)
                : (parent.path + "/" + child_name);
 
            hdf5_create_group(m_file_id, path);
        }
 
 
        inline void delete_group(const std::string& path) {
            hdf5_delete_group(m_file_id, path);
        }
 
 
        inline void delete_group(const hdf5_node& node) {
            hdf5_delete_group(m_file_id, node.path);
        }
 
 
        // Vector operations
 
        template<typename Vector = vec<real>>
        Vector read_vec(const std::string& path) const {
            return hdf5_read_vec<Vector>(m_file_id, path);
        }
 
 
        template<typename Vector = vec<real>>
        Vector read_vec(const hdf5_node& node) const {
            return hdf5_read_vec<Vector>(m_file_id, node.path);
        }
 
 
        template<typename Vector>
        void write_vec(const std::string& path, const Vector& v) {
            hdf5_write_vec(m_file_id, path, v);
        }
 
        template<typename Vector>
        void write_vec(const hdf5_node& node, const Vector& v) {
            hdf5_write_vec(m_file_id, node.path, v);
        }
 
 
        // Matrix operations
        
        template<typename Matrix = mat<real>>
        Matrix read_mat(const std::string& path) const {
            return hdf5_read_mat<Matrix>(m_file_id, path);
        }
        
 
        template<typename Matrix = mat<real>>
        Matrix read_mat(const hdf5_node& node) const {
            return hdf5_read_mat<Matrix>(m_file_id, node.path);
        }
        
 
        template<typename Matrix>
        void write_mat(const std::string& path, const Matrix& m) {
            hdf5_write_mat(m_file_id, path, m);
        }
        
 
        template<typename Matrix>
        void write_mat(const hdf5_node& node, const Matrix& m) {
            hdf5_write_mat(m_file_id, node.path, m);
        }
 
 
        void delete_dataset(const std::string& path) {
            hdf5_delete_dataset(m_file_id, path);
        }
 
 
        void delete_dataset(const hdf5_node& node) {
            hdf5_delete_dataset(m_file_id, node.path);
        }
 
 
        // Metadata operations
        
        template<typename Type>
        Type read_attribute(const std::string& path, const std::string& attr_name) const {
            return hdf5_read_attribute<Type>(m_file_id, path, attr_name);
        }
        
 
        template<typename Type>
        Type read_attribute(const hdf5_node& node, const std::string& attr_name) const {
            return hdf5_read_attribute<Type>(m_file_id, node.path, attr_name);
        }
        
 
        template<typename Type>
        void write_attribute(const std::string& path, const std::string& attr_name, const Type& value) {
            hdf5_write_attribute<Type>(m_file_id, path, attr_name, value);
        }
        
 
        template<typename Type>
        void write_attribute(const hdf5_node& node, const std::string& attr_name, const Type& value) {
            hdf5_write_attribute<Type>(m_file_id, node.path, attr_name, value);
        }
 
 
        void delete_attribute(const std::string& path, const std::string& attr_name) {
            hdf5_delete_attribute(m_file_id, path, attr_name);
        }
 
 
        void delete_attribute(const hdf5_node& node, const std::string& attr_name) {
            hdf5_delete_attribute(m_file_id, node.path, attr_name);
        }
 
 
        inline std::string to_string() const {
            return io::to_string(m_root);
        }
 
 
        inline friend std::ostream& operator<<(std::ostream& os, const hdf5_file& file) {
            return os << file.to_string();
        }
    };
 
}}
 
#endif