Archive.h

Go to the documentation of this file.

 
#ifndef PBAT_IO_ARCHIVE_H
#define PBAT_IO_ARCHIVE_H
 
#include "PhysicsBasedAnimationToolkitExport.h"
 
#include <filesystem>
#include <highfive/H5File.hpp>
#include <highfive/H5Group.hpp>
#include <highfive/eigen.hpp>
#include <optional>
#include <string>
#include <type_traits>
#include <variant>
 
namespace pbat::io {

class Archive
{
  public:
    PBAT_API Archive(
        std::filesystem::path const& filepath,
        HighFive::File::AccessMode flags = HighFive::File::OpenOrCreate);
    PBAT_API bool IsUsable() const;
    PBAT_API Archive GetOrCreateGroup(std::string const& path);
    PBAT_API Archive operator[](std::string const& path);
    PBAT_API Archive operator[](std::string const& path) const;
    PBAT_API bool HasGroup(std::string const& path) const;
    template <class T>
    void WriteData(std::string const& path, T const& data);
    template <class T>
    void WriteMetaData(std::string const& key, T const& value);
    template <class T>
    T ReadData(std::string const& path) const;
    template <class T>
    T ReadMetaData(std::string const& key) const;
    PBAT_API void Unlink(std::string const& path);
    PBAT_API std::optional<std::string> GetPath() const;
 
  protected:
    using Object =
        std::variant<std::monostate, HighFive::File, HighFive::Group>; 

    Archive(Object obj);
 
  private:
    Object mHdf5Object; 
};
 
template <class T>
inline void Archive::WriteData(std::string const& path, T const& data)
{
    std::visit(
        [&](auto&& arg) {
            using U = std::decay_t<decltype(arg)>;
            if constexpr (not std::is_same_v<U, std::monostate>)
            {
                if (arg.exist(path) and (arg.getObjectType(path) == HighFive::ObjectType::Dataset))
                {
                    arg.getDataSet(path).write(data);
                }
                else
                {
                    arg.createDataSet(path, data);
                }
            }
        },
        mHdf5Object);
}
 
template <class T>
inline void Archive::WriteMetaData(std::string const& key, T const& value)
{
    std::visit(
        [&](auto&& arg) {
            using U = std::decay_t<decltype(arg)>;
            if constexpr (not std::is_same_v<U, std::monostate>)
            {
                if (arg.hasAttribute(key))
                {
                    arg.getAttribute(key).write(value);
                }
                else
                {
                    arg.createAttribute(key, value);
                }
            }
        },
        mHdf5Object);
}
 
template <class T>
inline T Archive::ReadData(std::string const& path) const
{
    T data;
    std::visit(
        [&](auto&& arg) {
            using U = std::decay_t<decltype(arg)>;
            if constexpr (not std::is_same_v<U, std::monostate>)
            {
                data = arg.getDataSet(path).template read<T>();
            }
        },
        mHdf5Object);
    return std::move(data);
}
 
template <class T>
inline T Archive::ReadMetaData(std::string const& key) const
{
    T data;
    std::visit(
        [&](auto&& arg) {
            using U = std::decay_t<decltype(arg)>;
            if constexpr (not std::is_same_v<U, std::monostate>)
            {
                data = arg.getAttribute(key).template read<T>();
            }
        },
        mHdf5Object);
    return data;
}
 
} // namespace pbat::io
 
#endif // PBAT_IO_ARCHIVE_H