H++/H5Object.hpp

#ifndef __H5_OBJECT_HPP
#define __H5_OBJECT_HPP
 
#include <memcore/RefPtr.hpp>
#include <hdf5.h>
#include <hdf5init.hpp>
 
#include <vector>
#include <filesystem>
 
class   H5LinkAccess;
 
class   H5Identifier : public MemCore::ReferenceBase<H5Identifier>, HDF5User
{
protected:
        hid_t   hid = 0;
 
        H5Identifier(hid_t id);
        H5Identifier(const H5Identifier&) = delete;
        H5Identifier&operator=(const H5Identifier&) = delete;
 
        virtual ~H5Identifier();
 
public:
        template <class T>
        using   refptr = MemCore::RefPtr<T>;
 
static  consteval hid_t invalid_id()
        {
                return  H5I_INVALID_HID;
        }
 
 
        void    inc_ref() const
        {
                H5Iinc_ref(hid);
        }
 
        void    dec_ref() const
        {
                H5Idec_ref(hid);
        }
 
 
        struct  Silence
        {
                H5E_auto2_t     func;
                void            *client_data;
 
                Silence(const Silence&) = delete;
                void operator=(const Silence&) = delete;
 
                Silence()
                {
                        H5Eget_auto2( H5E_DEFAULT, &func, &client_data );
                        H5Eset_auto2( H5E_DEFAULT, 0,0);
                }
 
                ~Silence()
                {
                        H5Eset_auto2( H5E_DEFAULT, func, client_data);
                }
        };
 
        template <class Lambda>
static  auto Silentio(const Lambda&L) -> decltype( L() )
        {
        Silence BeSilent;
                return L();
        }
 
 
        struct  CaptureErrors : std::string, Silence
        {
                std::vector< H5E_error2_t > ErrorStack;
 
                CaptureErrors();
        };
 
        hid_t   getHid() const
        {
                return hid;
        }
 
        hid_t   getHidClone() const
        {
                H5Iinc_ref( hid );
                return hid;
        }
 
        hid_t   clone() const
        {
                inc_ref();
                return hid;
        }
 
        bool    isValid() const
        {
                return hid>0;
        }
 
static  bool    isActive()
        {
                return  HDF5Init::isActive();
        }
};
 
class   H5Object : public H5Identifier
{
protected:
        H5Object();
        H5Object(const H5Object&) = delete;
 
        H5Object&operator=(const H5Object&) = delete;
 
        virtual ~H5Object();
 
        H5Object(hid_t ID);
 
public:
 
        H5Object(hid_t parent_id, const char*name, hid_t link_access_properties = H5P_DEFAULT);
 
        H5Object(const refptr<H5Object>&parent, const char*name, hid_t link_access_properties = H5P_DEFAULT)
        : H5Object( parent?parent->hid : 0, name, link_access_properties)
        {}
 
        H5Object(hid_t parent_id, const char*name, const H5LinkAccess&link_access_properties);
 
        H5Object(const refptr<H5Object>&parent, const char*name, const H5LinkAccess&link_access_properties);
 
 
        bool    Awrite(const char*AttributeName, hid_t file_type_id,
                       hid_t mem_type_id,
                       const void*data,
                       size_t Elements) const;
 
        bool    Awrite(const std::string&AttributeName, hid_t file_type_id,
                       hid_t mem_type_id,
                       const void*data,
                       size_t Elements) const
        {
                return Awrite(AttributeName.c_str(), file_type_id,
                              mem_type_id, data, Elements);
        }
 
        template <class name_t>
        bool    Awrite(const name_t&AttributeName, hid_t type_id, const void*data, size_t Elements) const
        {
                return Awrite(AttributeName, type_id, type_id, data, Elements);
        }
 
 
        template <class name_t>
        bool    Awrite(const  name_t&AttributeName, const int16_t*data, size_t Elements) const
        {
                return Awrite( AttributeName, H5T_NATIVE_INT16, data, Elements);
        }
 
        template <class name_t>
        bool    Awrite(const  name_t&AttributeName, const int32_t*data, size_t Elements) const
        {
                return Awrite( AttributeName, H5T_NATIVE_INT32, data, Elements);
        }
 
        template <class name_t>
        bool    Awrite(const  name_t&AttributeName, const int64_t*data, size_t Elements) const
        {
                return Awrite( AttributeName, H5T_NATIVE_INT64, data, Elements);
        }
 
 
        template <class name_t>
        bool    Awrite(const  name_t&AttributeName, const uint16_t*data, size_t Elements) const
        {
                return Awrite( AttributeName, H5T_NATIVE_UINT16, data, Elements);
        }
 
        template <class name_t>
        bool    Awrite(const  name_t&AttributeName, const uint32_t*data, size_t Elements) const
        {
                return Awrite( AttributeName, H5T_NATIVE_UINT32, data, Elements);
        }
 
        template <class name_t>
        bool    Awrite(const  name_t&AttributeName, const uint64_t*data, size_t Elements) const
        {
                return Awrite( AttributeName, H5T_NATIVE_UINT64, data, Elements);
        }
 
        template <class name_t>
        bool    Awrite(const name_t&AttributeName, const double*data, size_t Elements = 1) const
        {
                return Awrite( AttributeName, H5T_NATIVE_DOUBLE, data, Elements);
        }
 
        template <class name_t, class value_type>
        bool    Awrite(const name_t&AttributeName, const value_type&value) const
        {
                return Awrite( AttributeName, &value, 1);
        }
 
 
        template <class T>
        bool    Awrite(const std::string&AttributeName, const std::vector<T>&data) const
        {
                return Awrite( AttributeName, data.data(), data.size());
        }
 
        bool    Awrite(const char*AttributeName, const std::string&data) const;
        bool    Awrite(const std::string&AttributeName, const std::string&data) const
        {
                return Awrite(AttributeName.c_str(), data);
        }
 
 
static  std::string     getFilename(hid_t hid);
 
        std::string     getFilename() const
        {
                if (!isValid() )
                        return {};
 
                return  getFilename( hid );
        }
 
        std::string     get_filename() const
        {
                return  getFilename();
        }
 
static  std::filesystem::path   getFilePath(hid_t hid)
        {
                return  getFilename(hid);
        }
 
        std::filesystem::path   getFilePath() const
        {
                return  getFilePath(hid);
        }
 
static  std::string     get_name(hid_t hid);
 
        std::string     get_name() const
        {
                if (!isValid() )
                        return {};
 
                return  get_name( hid );
        }
 
        std::string     get_object_path() const
        {
                return get_name();
        }
 
        std::string     get_object_path_within_file() const
        {
                return get_name();
        }
 
        std::string     get_path() const
        {
                return get_name();
        }
 
        herr_t                  get_info(H5O_info2_t&object_info, unsigned info_fields) const;
        time_t                  get_modification_time() const;
        hsize_t                 num_attribs() const;
 
        H5O_type_t              get_type() const;
        refptr<H5Object>        get_typed_object() const;
 
 
        time_t                  get_age() const
        {
                return  get_modification_time();
        }
};
 
#endif  // __H5_OBJECT_HPP