H++with_cache_image/H5Object.hpp

#ifndef __H5_OBJECT_HPP
#define __H5_OBJECT_HPP
 
#include <memcore/RefPtr.hpp>
#include <hdf5.h>
#include <vector>
 
class   H5Object : public MemCore::ReferenceBase<H5Object>
{
static  bool    H5LibraryIsActive;
 
protected:
        hid_t   hid;
 
protected:
        H5Object();
        H5Object(const H5Object&) = delete;
 
        H5Object&operator=(const H5Object&) = delete;
 
        virtual ~H5Object();
 
        H5Object(hid_t ID);
 
public:
        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
        {       
                CaptureErrors();
        };
        
        hid_t   getHid() const
        {
                return hid;
        }
 
        hid_t   getHidClone() const
        {
                H5Iinc_ref( hid );
                return hid;
        }
 
        bool    isValid() const
        {
                return hid>0;
        }
        
static  bool    isActive()
        {
                return H5LibraryIsActive;
        }
 
static  void    CloseLibrary();
        
        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); 
        }
 
#if     0
        template <class name_t>
        bool    Awrite(const  name_t&AttributeName, const int*data, size_t Elements) const
        {
                return Awrite( AttributeName, H5T_NATIVE_INT, data, Elements);
        }
 
        template <class name_t>
        bool    Awrite(const  name_t&AttributeName, const unsigned int*data, size_t Elements) const
        {
                return Awrite( AttributeName, H5T_NATIVE_UINT, data, Elements);
        }
 
        template <class name_t>
        bool    Awrite(const  name_t&AttributeName, const long*data, size_t Elements) const
        {
                return Awrite( AttributeName, H5T_NATIVE_LONG, data, Elements);
        }
 
        template <class name_t>
        bool    Awrite(const  name_t&AttributeName, const unsigned long*data, size_t Elements) const
        {
                return Awrite( AttributeName, H5T_NATIVE_ULONG, data, Elements);
        }
#endif
 
        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.begin(), 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);
        }
};
 
 
 
 
 
#endif  // __H5_OBJECT_HPP