[lttng-tools.git] / src / common / make-unique-wrapper.hpp

/*
 * Copyright (C) 2022 Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 */

#ifndef LTTNG_MAKE_UNIQUE_WRAPPER_H
#define LTTNG_MAKE_UNIQUE_WRAPPER_H

#include <common/macros.hpp>

#include <memory>

namespace lttng {

/*
 * make_unique_wrapper is intended to facilitate the use of std::unique_ptr
 * to wrap C-style APIs that don't provide RAII resource management facilities.
 *
 * Usage example:
 *
 *    // API
 *    struct my_c_struct {
 *            // ...
 *    };
 *
 *    struct my_c_struct *create_my_c_struct(void);
 *    void destroy_my_c_struct(struct my_c_struct *value);
 *
 *    // Creating a unique_ptr to my_c_struct.
 *    auto safe_c_struct =
 *            lttng::make_unique_wrapper<my_c_struct, destroy_my_c_struct>(
 *                    create_my_c_struct());
 *
 * Note that this facility is intended for use in the scope of a function.
 * If you need to return this unique_ptr instance, you should consider writting
 * a proper, idiomatic, wrapper.
 */

namespace details {
template <typename WrappedType, void (*DeleterFunction)(WrappedType *)>
struct create_unique_class {
	struct deleter {
		void operator()(WrappedType *instance) const
		{
			DeleterFunction(instance);
		}
	};

	std::unique_ptr<WrappedType, deleter> operator()(WrappedType *instance) const
	{
		return std::unique_ptr<WrappedType, deleter>(instance);
	}
};
} /* namespace details */

/*
 * 'free' is a utility function for use with make_unique_wrapper. It makes it easier to
 * wrap raw pointers that have to be deleted with `free`. Using libc's 'free' as
 * a make_unique_wrapper template argument will result in an error as 'WrappedType *' will
 * not match free's 'void *' argument.
 */
template <class Type>
void free(Type *ptr)
{
	std::free(ptr);
}

template <typename WrappedType, void (*DeleterFunc)(WrappedType *)>
std::unique_ptr<WrappedType,
		typename details::create_unique_class<WrappedType, DeleterFunc>::deleter>
make_unique_wrapper(WrappedType *instance)
{
	const details::create_unique_class<WrappedType, DeleterFunc> unique_deleter;

	return unique_deleter(instance);
}

} /* namespace lttng */

#endif /* LTTNG_MAKE_UNIQUE_WRAPPER_H */
Commit	Line	Data
8802d23b JG	1	/*
	2	* Copyright (C) 2022 Jérémie Galarneau <jeremie.galarneau@efficios.com>
	3	*
	4	* SPDX-License-Identifier: LGPL-2.1-only
	5	*
	6	*/
	7
	8	#ifndef LTTNG_MAKE_UNIQUE_WRAPPER_H
	9	#define LTTNG_MAKE_UNIQUE_WRAPPER_H
	10
	11	#include <common/macros.hpp>
	12
	13	#include <memory>
	14
	15	namespace lttng {
	16
	17	/*
	18	* make_unique_wrapper is intended to facilitate the use of std::unique_ptr
	19	* to wrap C-style APIs that don't provide RAII resource management facilities.
	20	*
	21	* Usage example:
	22	*
	23	* // API
	24	* struct my_c_struct {
	25	* // ...
	26	* };
	27	*
	28	* struct my_c_struct *create_my_c_struct(void);
	29	* void destroy_my_c_struct(struct my_c_struct *value);
	30	*
	31	* // Creating a unique_ptr to my_c_struct.
	32	* auto safe_c_struct =
	33	* lttng::make_unique_wrapper<my_c_struct, destroy_my_c_struct>(
	34	* create_my_c_struct());
	35	*
	36	* Note that this facility is intended for use in the scope of a function.
	37	* If you need to return this unique_ptr instance, you should consider writting
	38	* a proper, idiomatic, wrapper.
	39	*/
	40
28f23191	41	namespace details {
8802d23b JG	42	template <typename WrappedType, void (DeleterFunction)(WrappedType )>
	43	struct create_unique_class {
	44	struct deleter {
	45	void operator()(WrappedType *instance) const
	46	{
	47	DeleterFunction(instance);
	48	}
	49	};
	50
	51	std::unique_ptr<WrappedType, deleter> operator()(WrappedType *instance) const
	52	{
	53	return std::unique_ptr<WrappedType, deleter>(instance);
	54	}
	55	};
	56	} /* namespace details */
	57
	58	/*
	59	* 'free' is a utility function for use with make_unique_wrapper. It makes it easier to
	60	* wrap raw pointers that have to be deleted with `free`. Using libc's 'free' as
	61	* a make_unique_wrapper template argument will result in an error as 'WrappedType *' will
	62	* not match free's 'void *' argument.
	63	*/
	64	template <class Type>
	65	void free(Type *ptr)
	66	{
	67	std::free(ptr);
	68	}
	69
	70	template <typename WrappedType, void (DeleterFunc)(WrappedType )>
28f23191 JG	71	std::unique_ptr<WrappedType,
28f23191 JG	72	typename details::create_unique_class<WrappedType, DeleterFunc>::deleter>
8802d23b JG	73	make_unique_wrapper(WrappedType *instance)
	74	{
	75	const details::create_unique_class<WrappedType, DeleterFunc> unique_deleter;
	76
	77	return unique_deleter(instance);
	78	}
	79
	80	} /* namespace lttng */
	81
	82	#endif /* LTTNG_MAKE_UNIQUE_WRAPPER_H */