cpp-common/bt2: `bt2::internal::BorrowedObj` -> `bt2::BorrowedObj`

[babeltrace.git] / src / cpp-common / bt2 / internal / borrowed-obj.hpp

diff --git a/src/cpp-common/bt2/internal/borrowed-obj.hpp b/src/cpp-common/bt2/internal/borrowed-obj.hpp
deleted file mode 100644 (file)
index 5d3ab64..0000000
--- a/src/cpp-common/bt2/internal/borrowed-obj.hpp
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
- * Copyright 2019-2020 (c) Philippe Proulx <pproulx@efficios.com>
- *
- * SPDX-License-Identifier: MIT
- */
-
-#ifndef BABELTRACE_CPP_COMMON_BT2_INTERNAL_BORROWED_OBJ_HPP
-#define BABELTRACE_CPP_COMMON_BT2_INTERNAL_BORROWED_OBJ_HPP
-
-#include <functional>
-#include <type_traits>
-
-#include "common/assert.h"
-
-namespace bt2 {
-namespace internal {
-
-/*
- * An instance of this class wraps a pointer to a libbabeltrace2 object
- * of type `LibObjT` without managing any reference counting.
- *
- * This is an abstract base class for any libbabeltrace2 object wrapper.
- *
- * `LibObjT` is the direct libbabeltrace2 object type, for example
- * `bt_stream_class` or `const bt_value`.
- *
- * Methods of a derived class can call libObjPtr() to access the
- * libbabeltrace2 object pointer.
- */
-template <typename LibObjT>
-class BorrowedObj
-{
-    static_assert(!std::is_pointer<LibObjT>::value, "`LibObjT` must not be a pointer");
-
-    /*
-     * This makes it possible for a `BorrowedObj<const bt_something>`
-     * instance to get assigned an instance of
-     * `BorrowedObj<bt_something>` ("copy" constructor and "assignment"
-     * operator).
-     *
-     * C++ forbids the other way around.
-     */
-    template <typename>
-    friend class BorrowedObj;
-
-private:
-    /*
-     * Provides `val` which indicates whether or not you can assign this
-     * object from a borrowed object of type `OtherLibObjT`.
-     */
-    template <typename OtherLibObjT>
-    struct _AssignableFromConst final
-    {
-        /*
-         * If `LibObjT` is const (for example, `const bt_value`), then
-         * you may always assign from its non-const equivalent (for
-         * example, `bt_value`). In C (correct):
-         *
-         *     bt_value * const meow = bt_value_bool_create_init(BT_TRUE);
-         *     const bt_value * const mix = meow;
-         *
-         * If `LibObjT` is non-const, then you may not assign from its
-         * const equivalent. In C (not correct):
-         *
-         *     const bt_value * const meow =
-         *         bt_value_array_borrow_element_by_index_const(some_val, 17);
-         *     bt_value * const mix = meow;
-         */
-        static constexpr bool val =
-            std::is_const<LibObjT>::value || !std::is_const<OtherLibObjT>::value;
-    };
-
-protected:
-    /* libbabeltrace2 object pointer */
-    using _LibObjPtr = LibObjT *;
-
-    /* This complete borrowed object */
-    using _ThisBorrowedObj = BorrowedObj<LibObjT>;
-
-    /*
-     * Builds a borrowed object to wrap the libbabeltrace2 object
-     * pointer `libObjPtr`.
-     *
-     * `libObjPtr` must not be `nullptr`.
-     */
-    explicit BorrowedObj(const _LibObjPtr libObjPtr) noexcept : _mLibObjPtr {libObjPtr}
-    {
-        BT_ASSERT(libObjPtr);
-    }
-
-    /* Default copy operations */
-    BorrowedObj(const BorrowedObj&) noexcept = default;
-    BorrowedObj& operator=(const BorrowedObj&) noexcept = default;
-
-    /*
-     * Generic "copy" constructor.
-     *
-     * This converting constructor accepts both an instance of
-     * `_ThisBorrowedObj` and an instance (`other`) of
-     * `BorrowedObj<ConstLibObjT>`, where `ConstLibObjT` is the `const`
-     * version of `LibObjT`, if applicable.
-     *
-     * This makes it possible for a `BorrowedObj<const bt_something>`
-     * instance to be built from an instance of
-     * `BorrowedObj<bt_something>`. C++ forbids the other way around.
-     */
-    template <typename OtherLibObjT>
-    BorrowedObj(const BorrowedObj<OtherLibObjT>& other) noexcept : BorrowedObj {other._mLibObjPtr}
-    {
-        static_assert(_AssignableFromConst<OtherLibObjT>::val,
-                      "Don't assign a non-const wrapper from a const wrapper.");
-    }
-
-    /*
-     * Generic "assignment" operator.
-     *
-     * This operator accepts both an instance of
-     * `_ThisBorrowedObj` and an instance (`other`) of
-     * `BorrowedObj<ConstLibObjT>`, where `ConstLibObjT` is the `const`
-     * version of `LibObjT`, if applicable.
-     *
-     * This makes it possible for a `BorrowedObj<const bt_something>`
-     * instance to get assigned an instance of
-     * `BorrowedObj<bt_something>`. C++ forbids the other way around,
-     * therefore we use `_EnableIfAssignableT` to show a more relevant
-     * context in the compiler error message.
-     */
-    template <typename OtherLibObjT>
-    _ThisBorrowedObj& operator=(const BorrowedObj<OtherLibObjT>& other) noexcept
-    {
-        static_assert(_AssignableFromConst<OtherLibObjT>::val,
-                      "Don't assign a non-const wrapper from a const wrapper.");
-
-        _mLibObjPtr = other._mLibObjPtr;
-        return *this;
-    }
-
-public:
-    /*
-     * Returns a hash of this object, solely based on its raw libbabeltrace2
-     * pointer.
-     */
-    std::size_t hash() const noexcept
-    {
-        return std::hash<_LibObjPtr> {}(_mLibObjPtr);
-    }
-
-    /*
-     * Returns whether or not this object is the exact same as `other`,
-     * solely based on the raw libbabeltrace2 pointers.
-     */
-    bool isSame(const _ThisBorrowedObj& other) const noexcept
-    {
-        return _mLibObjPtr == other._mLibObjPtr;
-    }
-
-    /* Wrapped libbabeltrace2 object pointer */
-    _LibObjPtr libObjPtr() const noexcept
-    {
-        return _mLibObjPtr;
-    }
-
-private:
-    _LibObjPtr _mLibObjPtr;
-};
-
-} /* namespace internal */
-} /* namespace bt2 */
-
-#endif /* BABELTRACE_CPP_COMMON_BT2_INTERNAL_BORROWED_OBJ_HPP */