H5IdWrapper.hpp

#ifndef H5ID_WRAPPER_HPP
#define H5ID_WRAPPER_HPP

#include "splash/core/splashMacros.hpp"

#include <hdf5.h>


namespace splash
{
    namespace policies
    {
        template<typename T>
        struct NoCopy
        {
            static T copy(const T&)
            {
                // Make it depend on template parameter
                SPLASH_UNUSED static char copyNotAllowed[sizeof(T) ? -1 : 0];
            }

            static bool release(const T&)
            {
                return true;
            }
        };

        template<typename T>
        struct RefCounted
        {
            RefCounted(): refCt_(new unsigned)
            {
                *refCt_ = 1;
            }

            T copy(const T& obj)
            {
                ++*refCt_;
                return obj;
            }

            bool release(const T&)
            {
                if(!--*refCt_)
                {
                    delete refCt_;
                    refCt_ = NULL;
                    return true;
                }
                return false;
            }

            friend void swap(RefCounted& lhs, RefCounted& rhs)
            {
                std::swap(lhs.refCt_, rhs.refCt_);
            }
        private:
            unsigned* refCt_;
        };
    }

    template<H5_DLL herr_t (*T_CloseMethod)(hid_t), template<class> class T_DestructionPolicy>
    struct H5IdWrapper: public T_DestructionPolicy<hid_t>
    {
        typedef T_DestructionPolicy<hid_t> DestructionPolicy;

        H5IdWrapper(): id_(-1){}
        explicit H5IdWrapper(hid_t id): id_(id){}
        H5IdWrapper(const H5IdWrapper& rhs): DestructionPolicy(rhs)
        {
            id_ = DestructionPolicy::copy(rhs.id_);
        }

        H5IdWrapper& operator=(const H5IdWrapper& rhs)
        {
            H5IdWrapper tmp(rhs);
            swap(*this, tmp);
            return *this;
        }

        ~H5IdWrapper()
        {
            if(DestructionPolicy::release(id_))
            {
                if(id_ >= 0)
                    T_CloseMethod(id_);
            }
        }

        void close()
        {
            reset(-1);
        }

        void reset(hid_t id)
        {
            H5IdWrapper tmp(id);
            swap(*this, tmp);
        }

        hid_t release()
        {
            hid_t id = id_;
            id_ = -1;
            return id;
        }

        operator hid_t() const { return id_; }
        operator bool() const { return id_ >= 0; }

        friend void swap(H5IdWrapper& lhs, H5IdWrapper& rhs)
        {
            std::swap(lhs.id_, rhs.id_);
            std::swap(static_cast<DestructionPolicy&>(lhs), static_cast<DestructionPolicy&>(rhs));
        }

    private:
        hid_t id_;
    };

    typedef H5IdWrapper<H5Aclose, policies::NoCopy> H5AttributeId;
    typedef H5IdWrapper<H5Aclose, policies::RefCounted> H5AttributeIdRefCt;
    typedef H5IdWrapper<H5Sclose, policies::NoCopy> H5DataspaceId;
    typedef H5IdWrapper<H5Sclose, policies::RefCounted> H5DataspaceIdRefCt;
    typedef H5IdWrapper<H5Tclose, policies::NoCopy> H5TypeId;
    typedef H5IdWrapper<H5Tclose, policies::RefCounted> H5TypeIdRefCt;
    typedef H5IdWrapper<H5Oclose, policies::NoCopy> H5ObjectId;
    typedef H5IdWrapper<H5Oclose, policies::RefCounted> H5ObjectIdRefCt;

    template<H5_DLL herr_t (*T_CloseMethod)(hid_t), template<class> class T_DestructionPolicy>
    inline bool operator==(const H5IdWrapper<T_CloseMethod, T_DestructionPolicy>& lhs, const H5IdWrapper<T_CloseMethod, T_DestructionPolicy>& rhs)
    {
        return static_cast<hid_t>(lhs) == static_cast<hid_t>(rhs);
    }
    template<H5_DLL herr_t (*T_CloseMethod)(hid_t), template<class> class T_DestructionPolicy>
    inline bool operator!=(const H5IdWrapper<T_CloseMethod, T_DestructionPolicy>& lhs, const H5IdWrapper<T_CloseMethod, T_DestructionPolicy>& rhs)
    {
        return !(lhs == rhs);
    }
}

#endif /* H5ID_WRAPPER_HPP */