src/cpp-common/bt2/integer-range-set.hpp

   1 /*
   2  * Copyright (c) 2020 Philippe Proulx <pproulx@efficios.com>
   3  *
   4  * SPDX-License-Identifier: MIT
   5  */
   6
   7 #ifndef BABELTRACE_CPP_COMMON_BT2_INTEGER_RANGE_SET_HPP
   8 #define BABELTRACE_CPP_COMMON_BT2_INTEGER_RANGE_SET_HPP
   9
  10 #include <cstdint>
  11 #include <type_traits>
  12 #include <babeltrace2/babeltrace.h>
  13
  14 #include "internal/borrowed-obj.hpp"
  15 #include "internal/utils.hpp"
  16 #include "integer-range.hpp"
  17 #include "lib-error.hpp"
  18
  19 namespace bt2 {
  20
  21 namespace internal {
  22
  23 template <typename LibObjT>
  24 struct IntegerRangeSetRefFuncs;
  25
  26 template <>
  27 struct IntegerRangeSetRefFuncs<const bt_integer_range_set_unsigned> final
  28 {
  29     static void get(const bt_integer_range_set_unsigned * const libObjPtr)
  30     {
  31         bt_integer_range_set_unsigned_get_ref(libObjPtr);
  32     }
  33
  34     static void put(const bt_integer_range_set_unsigned * const libObjPtr)
  35     {
  36         bt_integer_range_set_unsigned_get_ref(libObjPtr);
  37     }
  38 };
  39
  40 template <>
  41 struct IntegerRangeSetRefFuncs<const bt_integer_range_set_signed> final
  42 {
  43     static void get(const bt_integer_range_set_signed * const libObjPtr)
  44     {
  45         bt_integer_range_set_signed_get_ref(libObjPtr);
  46     }
  47
  48     static void put(const bt_integer_range_set_signed * const libObjPtr)
  49     {
  50         bt_integer_range_set_signed_get_ref(libObjPtr);
  51     }
  52 };
  53
  54 template <typename LibObjT>
  55 struct CommonIntegerRangeSetSpec;
  56
  57 // Functions specific to unsigned integer range sets
  58 template <>
  59 struct CommonIntegerRangeSetSpec<const bt_integer_range_set_unsigned> final
  60 {
  61     static std::uint64_t size(const bt_integer_range_set_unsigned * const libRangePtr) noexcept
  62     {
  63         return bt_integer_range_set_get_range_count(
  64             bt_integer_range_set_unsigned_as_range_set_const(libRangePtr));
  65     }
  66
  67     static const bt_integer_range_unsigned *
  68     rangeByIndex(const bt_integer_range_set_unsigned * const libRangePtr,
  69                  const std::uint64_t index) noexcept
  70     {
  71         return bt_integer_range_set_unsigned_borrow_range_by_index_const(libRangePtr, index);
  72     }
  73
  74     static bool isEqual(const bt_integer_range_set_unsigned * const libRangePtrA,
  75                         const bt_integer_range_set_unsigned * const libRangePtrB) noexcept
  76     {
  77         return static_cast<bool>(
  78             bt_integer_range_set_unsigned_is_equal(libRangePtrA, libRangePtrB));
  79     }
  80
  81     static bt_integer_range_set_add_range_status
  82     addRange(bt_integer_range_set_unsigned * const libRangePtr, const std::uint64_t lower,
  83              const std::uint64_t upper) noexcept
  84     {
  85         return bt_integer_range_set_unsigned_add_range(libRangePtr, lower, upper);
  86     }
  87
  88     static bt_integer_range_set_unsigned *create() noexcept
  89     {
  90         return bt_integer_range_set_unsigned_create();
  91     }
  92 };
  93
  94 // Functions specific to signed integer range sets
  95 template <>
  96 struct CommonIntegerRangeSetSpec<const bt_integer_range_set_signed> final
  97 {
  98     static std::uint64_t size(const bt_integer_range_set_signed * const libRangePtr) noexcept
  99     {
 100         return bt_integer_range_set_get_range_count(
 101             bt_integer_range_set_signed_as_range_set_const(libRangePtr));
 102     }
 103
 104     static const bt_integer_range_signed *
 105     rangeByIndex(const bt_integer_range_set_signed * const libRangePtr,
 106                  const std::uint64_t index) noexcept
 107     {
 108         return bt_integer_range_set_signed_borrow_range_by_index_const(libRangePtr, index);
 109     }
 110
 111     static bool isEqual(const bt_integer_range_set_signed * const libRangePtrA,
 112                         const bt_integer_range_set_signed * const libRangePtrB) noexcept
 113     {
 114         return static_cast<bool>(bt_integer_range_set_signed_is_equal(libRangePtrA, libRangePtrB));
 115     }
 116
 117     static bt_integer_range_set_add_range_status
 118     addRange(bt_integer_range_set_signed * const libRangePtr, const std::int64_t lower,
 119              const std::int64_t upper) noexcept
 120     {
 121         return bt_integer_range_set_signed_add_range(libRangePtr, lower, upper);
 122     }
 123
 124     static bt_integer_range_set_signed *create() noexcept
 125     {
 126         return bt_integer_range_set_signed_create();
 127     }
 128 };
 129
 130 } // namespace internal
 131
 132 template <typename LibObjT>
 133 class ConstVariantWithIntegerSelectorFieldClassOption;
 134
 135 template <typename LibObjT, typename RangeSetT>
 136 class CommonVariantWithIntegerSelectorFieldClass;
 137
 138 template <typename LibObjT>
 139 class CommonTraceClass;
 140
 141 template <typename LibObjT>
 142 class CommonIntegerRangeSet final : public internal::BorrowedObj<LibObjT>
 143 {
 144     // Allow operator==() to call `other._libObjPtr()`
 145     friend class CommonIntegerRangeSet<bt_integer_range_set_unsigned>;
 146     friend class CommonIntegerRangeSet<const bt_integer_range_set_unsigned>;
 147     friend class CommonIntegerRangeSet<bt_integer_range_set_signed>;
 148     friend class CommonIntegerRangeSet<const bt_integer_range_set_signed>;
 149
 150     // Allow appendOption() to call `ranges._libObjPtr()`
 151     friend class CommonVariantWithIntegerSelectorFieldClass<
 152         bt_field_class,
 153         ConstVariantWithIntegerSelectorFieldClassOption<
 154             const bt_field_class_variant_with_selector_field_integer_unsigned_option>>;
 155
 156     friend class CommonVariantWithIntegerSelectorFieldClass<
 157         bt_field_class,
 158         ConstVariantWithIntegerSelectorFieldClassOption<
 159             const bt_field_class_variant_with_selector_field_integer_signed_option>>;
 160
 161     // Allow create*FieldClass() to call `ranges._libObjPtr()`
 162     friend class CommonTraceClass<bt_trace_class>;
 163
 164 private:
 165     using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
 166     using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
 167     using _ConstLibObjT = typename std::add_const<LibObjT>::type;
 168     using _RefFuncs = internal::IntegerRangeSetRefFuncs<_ConstLibObjT>;
 169     using _Spec = internal::CommonIntegerRangeSetSpec<_ConstLibObjT>;
 170     using _ThisCommonIntegerRangeSet = CommonIntegerRangeSet<LibObjT>;
 171
 172 public:
 173     using Shared = internal::SharedObj<_ThisCommonIntegerRangeSet, LibObjT, _RefFuncs>;
 174
 175     using Range = typename std::conditional<
 176         std::is_same<_ConstLibObjT, const bt_integer_range_set_unsigned>::value,
 177         ConstUnsignedIntegerRange, ConstSignedIntegerRange>::type;
 178
 179     using Value = typename Range::Value;
 180
 181     explicit CommonIntegerRangeSet(const _LibObjPtr libObjPtr) noexcept :
 182         _ThisBorrowedObj {libObjPtr}
 183     {
 184     }
 185
 186     static Shared create()
 187     {
 188         const auto libObjPtr = _Spec::create();
 189
 190         internal::validateCreatedObjPtr(libObjPtr);
 191         return Shared {_ThisCommonIntegerRangeSet {libObjPtr}};
 192     }
 193
 194     template <typename OtherLibObjT>
 195     CommonIntegerRangeSet(const CommonIntegerRangeSet<OtherLibObjT>& rangeSet) noexcept :
 196         _ThisBorrowedObj {rangeSet}
 197     {
 198     }
 199
 200     template <typename OtherLibObjT>
 201     _ThisCommonIntegerRangeSet&
 202     operator=(const CommonIntegerRangeSet<OtherLibObjT>& rangeSet) noexcept
 203     {
 204         _ThisBorrowedObj::operator=(rangeSet);
 205         return *this;
 206     }
 207
 208     template <typename OtherLibObjT>
 209     bool operator==(const CommonIntegerRangeSet<OtherLibObjT>& other) const noexcept
 210     {
 211         return _Spec::isEqual(this->_libObjPtr(), other._libObjPtr());
 212     }
 213
 214     template <typename OtherLibObjT>
 215     bool operator!=(const CommonIntegerRangeSet<OtherLibObjT>& other) const noexcept
 216     {
 217         return !(*this == other);
 218     }
 219
 220     void addRange(const Value lower, const Value upper)
 221     {
 222         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 223
 224         const auto status = _Spec::addRange(this->_libObjPtr(), lower, upper);
 225
 226         if (status == BT_INTEGER_RANGE_SET_ADD_RANGE_STATUS_MEMORY_ERROR) {
 227             throw LibMemoryError {};
 228         }
 229     }
 230
 231     std::uint64_t size() const noexcept
 232     {
 233         return _Spec::size(this->_libObjPtr());
 234     }
 235
 236     Range operator[](const std::uint64_t index) const noexcept
 237     {
 238         return Range {_Spec::rangeByIndex(this->_libObjPtr(), index)};
 239     }
 240
 241     Shared shared() const noexcept
 242     {
 243         return Shared {*this};
 244     }
 245 };
 246
 247 using UnsignedIntegerRangeSet = CommonIntegerRangeSet<bt_integer_range_set_unsigned>;
 248 using ConstUnsignedIntegerRangeSet = CommonIntegerRangeSet<const bt_integer_range_set_unsigned>;
 249 using SignedIntegerRangeSet = CommonIntegerRangeSet<bt_integer_range_set_signed>;
 250 using ConstSignedIntegerRangeSet = CommonIntegerRangeSet<const bt_integer_range_set_signed>;
 251
 252 } // namespace bt2
 253
 254 #endif // BABELTRACE_CPP_COMMON_BT2_INTEGER_RANGE_SET_HPP