HDF5 Functions and Smart Destructors - std::unique_ptr() - c++

Question

Many HDF5 functions are initialized as follows
hid_t handler = DoSomething(someHandler);
And one has to manually free the memory reserved by such an operation using something like:
freeme(handler);
So it's the same nightmare/problems that come along by using malloc and/or the new operator.
I want to create something like unique_ptr to handle this at destruction. The problem, however, that every different function has a different freeing function.
For example:
hid_t attribType = H5Aget_type(attribHandler);
must be freed with
H5Tclose(attribType);
But this function
attribHandler = H5Aopen(obj_id,"name",H5P_DEFAULT);
Must be freed with
H5Aclose(attribHandler);
So I need to write a class that can take hid_t as template parameter (that's easy), and also can take the freeing function as some kind of parameter, and call it on destruction.
What's the best way to achieve this?
Update
It was suggested to me to use std::unique_ptr with a custom deleter, but this doesn't work because std::unique_ptr expects a pointer.
std::unique_ptr<hid_t,std::function<herr_t(hid_t)>> attribType(H5Aget_type(attribHandler), [](hid_t f) { return H5Tclose(f); });
This creates a compile error due to the second parameter, the lambda function. The error says (g++ 4.9):
error: invalid conversion from ‘hid_t {aka int}’ to ‘std::unique_ptr<int, std::function<int(int)> >::pointer {aka int*}’ [-fpermissive]
std::unique_ptr<hid_t,std::function<herr_t(hid_t)>> attribType(H5Aget_type(attribHandler), [](hid_t f) { return H5Tclose(f); });
^
The error happens because std::unique_ptr expects hold a pointer to hid_t, not an hid_t object.
Is there a way around this? I think I can write my own class that does this now (I can use std::function to answer my first question), but would be great if I could use std::unique_ptr.

Answer 1

Something along these lines perhaps:
struct MyDeleter {
typedef hid_t pointer;
typedef void (*FreeFunc)(hid_t);
FreeFunc free_func_;
MyDeleter(FreeFunc free_func) : free_func_(free_func) {}
void operator()(hid_t f) const { free_func_(f); }
};
std::unique_ptr<hid_t, MyDeleter> p(
H5Aget_type(attribHandler),
MyDeleter(H5Tclose));

Answer 2

You may use something like:
template <typename Factory, Factory factory,
typename Deleter, Deleter deleter>
class SmartHandleH5;
template <typename Ret, typename ... Ts, Ret (*factory)(Ts...),
void (*deleter)(Ret)>
class SmartHandleH5<Ret (*)(Ts...), factory, void (*)(Ret), deleter>
{
public:
template <typename ... Us>
SmartHandle(Us&&... args) : handler(factory(std::forward<Us>(args)...)) {}
// Not copyable
SmartHandle(const SmartHandle&) = delete;
SmartHandle& operator =(const SmartHandle&) = delete;
// Not movable
SmartHandle(SmartHandle&&) = delete;
SmartHandle& operator =(SmartHandle&&) = delete;
// To avoid strange case with our template constructor
SmartHandle(SmartHandle&) = delete;
SmartHandle(const SmartHandle&&) = delete;
~SmartHandle() { deleter(handler); }
const T& get() const { return handler; }
T& get() { return handler; }
private:
Ret handler;
};
And then use the mapping factory/destructor once:
using SmartHandlerGetType = SmartHandlerH5<decltype(&H5Aget_type), H5Aget_type,
delctype(H5Tclose), H5Tclose>;
using SmartHandlerOpen = SmartHandlerH5<decltype(&H5Aopen), H5Aopen,
delctype(H5Aclose), H5Aclose>;
and use it:
SmartHandlerGetType attribType(attribHandler);
SmartHandlerOpen attribHandler(obj_id, "name", H5P_DEFAULT);
In addition, you might want to add an extra layer to hide completely hid_t
template <typename SmartHandle>
class HidHandle : private SmartHandle
{
public:
using SmartHandle::SmartHandle;
void foo() { someFunctionUsingHid(get()); }
};
and
using HidHandleGetType = HidHandle<SmartHandlerGetType>;
using HidHandleOpen = HidHandle<SmartHandlerOpen>;

Answer 3

I created my own handler class... it turned out it's not that difficult:
template <typename T, typename Deleter>
class SmartHandle
{
public:
typedef T value_type;
typedef Deleter deleter_function;
private:
T _value;
Deleter _deleter;
public:
SmartHandle(T value, Deleter deleter);
~SmartHandle();
T get();
};
template <typename T, typename Deleter>
SmartHandle<T,Deleter>::SmartHandle(T value, Deleter deleter)
{
this->_value = value;
this->_deleter = deleter;
}
template <typename T, typename Deleter>
T SmartHandle<T,Deleter>::get()
{
return _value;
}
template <typename T, typename Deleter>
SmartHandle<T,Deleter>::~SmartHandle()
{
_deleter(_value);
}
To use it:
SmartHandle<hid_t,std::function<herr_t(hid_t)>> attribType(H5Aget_type(attribHandler.get()), [](hid_t f) { return H5Tclose(f); });
Here attribHandler also uses a SmartHandle, which is why there's a .get() there.