src/cpp-common/bt2/internal/borrowed-obj.hpp

   1 /*
   2  * Copyright 2019-2020 (c) Philippe Proulx <pproulx@efficios.com>
   3  *
   4  * SPDX-License-Identifier: MIT
   5  */
   6
   7 #ifndef BABELTRACE_CPP_COMMON_BT2_INTERNAL_BORROWED_OBJ_HPP
   8 #define BABELTRACE_CPP_COMMON_BT2_INTERNAL_BORROWED_OBJ_HPP
   9
  10 #include <functional>
  11 #include <type_traits>
  12
  13 #include "common/assert.h"
  14
  15 namespace bt2 {
  16 namespace internal {
  17
  18 template <typename ObjT, typename LibObjT, typename RefFuncsT>
  19 class SharedObj;
  20
  21 /*
  22  * An instance of this class wraps a pointer to a libbabeltrace2 object
  23  * of type `LibObjT` without managing any reference counting.
  24  *
  25  * This is an abstract base class for any libbabeltrace2 object wrapper.
  26  *
  27  * `LibObjT` is the direct libbabeltrace2 object type, for example
  28  * `bt_stream_class` or `const bt_value`.
  29  *
  30  * Methods of a derived class can call libObjPtr() to access the
  31  * libbabeltrace2 object pointer.
  32  */
  33 template <typename LibObjT>
  34 class BorrowedObj
  35 {
  36     static_assert(!std::is_pointer<LibObjT>::value, "`LibObjT` must not be a pointer");
  37
  38     /*
  39      * This makes it possible for a `BorrowedObj<const bt_something>`
  40      * instance to get assigned an instance of
  41      * `BorrowedObj<bt_something>` ("copy" constructor and "assignment"
  42      * operator).
  43      *
  44      * C++ forbids the other way around.
  45      */
  46     template <typename>
  47     friend class BorrowedObj;
  48
  49 protected:
  50     /* libbabeltrace2 object pointer */
  51     using _LibObjPtr = LibObjT *;
  52
  53     /* This complete borrowed object */
  54     using _ThisBorrowedObj = BorrowedObj<LibObjT>;
  55
  56     /*
  57      * Builds a borrowed object to wrap the libbabeltrace2 object
  58      * pointer `libObjPtr`.
  59      *
  60      * `libObjPtr` must not be `nullptr`.
  61      */
  62     explicit BorrowedObj(const _LibObjPtr libObjPtr) noexcept : _mLibObjPtr {libObjPtr}
  63     {
  64         BT_ASSERT(libObjPtr);
  65     }
  66
  67     /* Default copy operations */
  68     BorrowedObj(const BorrowedObj&) noexcept = default;
  69     BorrowedObj& operator=(const BorrowedObj&) noexcept = default;
  70
  71     /*
  72      * Generic "copy" constructor.
  73      *
  74      * This converting constructor accepts both an instance of
  75      * `_ThisBorrowedObj` and an instance (`other`) of
  76      * `BorrowedObj<ConstLibObjT>`, where `ConstLibObjT` is the `const`
  77      * version of `LibObjT`, if applicable.
  78      *
  79      * This makes it possible for a `BorrowedObj<const bt_something>`
  80      * instance to be built from an instance of
  81      * `BorrowedObj<bt_something>`. C++ forbids the other way around.
  82      */
  83     template <typename OtherLibObjT>
  84     BorrowedObj(const BorrowedObj<OtherLibObjT>& other) noexcept : BorrowedObj {other._mLibObjPtr}
  85     {
  86     }
  87
  88     /*
  89      * Generic "assignment" operator.
  90      *
  91      * This operator accepts both an instance of
  92      * `_ThisBorrowedObj` and an instance (`other`) of
  93      * `BorrowedObj<ConstLibObjT>`, where `ConstLibObjT` is the `const`
  94      * version of `LibObjT`, if applicable.
  95      *
  96      * This makes it possible for a `BorrowedObj<const bt_something>`
  97      * instance to get assigned an instance of
  98      * `BorrowedObj<bt_something>`. C++ forbids the other way around.
  99      */
 100     template <typename OtherLibObjT>
 101     _ThisBorrowedObj& operator=(const BorrowedObj<OtherLibObjT>& other) noexcept
 102     {
 103         _mLibObjPtr = other._mLibObjPtr;
 104         return *this;
 105     }
 106
 107 public:
 108     /*
 109      * Returns a hash of this object, solely based on its raw libbabeltrace2
 110      * pointer.
 111      */
 112     std::size_t hash() const noexcept
 113     {
 114         return std::hash<_LibObjPtr> {}(_mLibObjPtr);
 115     }
 116
 117     /*
 118      * Returns whether or not this object is the exact same as `other`,
 119      * solely based on the raw libbabeltrace2 pointers.
 120      */
 121     bool isSame(const _ThisBorrowedObj& other) const noexcept
 122     {
 123         return _mLibObjPtr == other._mLibObjPtr;
 124     }
 125
 126     /* Wrapped libbabeltrace2 object pointer */
 127     _LibObjPtr libObjPtr() const noexcept
 128     {
 129         return _mLibObjPtr;
 130     }
 131
 132 private:
 133     _LibObjPtr _mLibObjPtr;
 134 };
 135
 136 } /* namespace internal */
 137 } /* namespace bt2 */
 138
 139 #endif /* BABELTRACE_CPP_COMMON_BT2_INTERNAL_BORROWED_OBJ_HPP */