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 CommonIntegerRangeSet final : public internal::BorrowedObj<LibObjT>
 140 {
 141     // Allow operator==() to call `other._libObjPtr()`
 142     friend class CommonIntegerRangeSet<bt_integer_range_set_unsigned>;
 143     friend class CommonIntegerRangeSet<const bt_integer_range_set_unsigned>;
 144     friend class CommonIntegerRangeSet<bt_integer_range_set_signed>;
 145     friend class CommonIntegerRangeSet<const bt_integer_range_set_signed>;
 146
 147     // Allow appendOption() to call `ranges._libObjPtr()`
 148     friend class CommonVariantWithIntegerSelectorFieldClass<
 149         bt_field_class,
 150         ConstVariantWithIntegerSelectorFieldClassOption<
 151             const bt_field_class_variant_with_selector_field_integer_unsigned_option>>;
 152
 153     friend class CommonVariantWithIntegerSelectorFieldClass<
 154         bt_field_class,
 155         ConstVariantWithIntegerSelectorFieldClassOption<
 156             const bt_field_class_variant_with_selector_field_integer_signed_option>>;
 157
 158 private:
 159     using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
 160     using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
 161     using _ConstLibObjT = typename std::add_const<LibObjT>::type;
 162     using _RefFuncs = internal::IntegerRangeSetRefFuncs<_ConstLibObjT>;
 163     using _Spec = internal::CommonIntegerRangeSetSpec<_ConstLibObjT>;
 164     using _ThisCommonIntegerRangeSet = CommonIntegerRangeSet<LibObjT>;
 165
 166 public:
 167     using Shared = internal::SharedObj<_ThisCommonIntegerRangeSet, LibObjT, _RefFuncs>;
 168
 169     using Range = typename std::conditional<
 170         std::is_same<_ConstLibObjT, const bt_integer_range_set_unsigned>::value,
 171         ConstUnsignedIntegerRange, ConstSignedIntegerRange>::type;
 172
 173     using Value = typename Range::Value;
 174
 175     explicit CommonIntegerRangeSet(const _LibObjPtr libObjPtr) noexcept :
 176         _ThisBorrowedObj {libObjPtr}
 177     {
 178     }
 179
 180     static Shared create()
 181     {
 182         const auto libObjPtr = _Spec::create();
 183
 184         internal::validateCreatedObjPtr(libObjPtr);
 185         return Shared {_ThisCommonIntegerRangeSet {libObjPtr}};
 186     }
 187
 188     template <typename OtherLibObjT>
 189     CommonIntegerRangeSet(const CommonIntegerRangeSet<OtherLibObjT>& rangeSet) noexcept :
 190         _ThisBorrowedObj {rangeSet}
 191     {
 192     }
 193
 194     template <typename OtherLibObjT>
 195     _ThisCommonIntegerRangeSet&
 196     operator=(const CommonIntegerRangeSet<OtherLibObjT>& rangeSet) noexcept
 197     {
 198         _ThisBorrowedObj::operator=(rangeSet);
 199         return *this;
 200     }
 201
 202     template <typename OtherLibObjT>
 203     bool operator==(const CommonIntegerRangeSet<OtherLibObjT>& other) const noexcept
 204     {
 205         return _Spec::isEqual(this->_libObjPtr(), other._libObjPtr());
 206     }
 207
 208     template <typename OtherLibObjT>
 209     bool operator!=(const CommonIntegerRangeSet<OtherLibObjT>& other) const noexcept
 210     {
 211         return !(*this == other);
 212     }
 213
 214     void addRange(const Value lower, const Value upper)
 215     {
 216         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 217
 218         const auto status = _Spec::addRange(this->_libObjPtr(), lower, upper);
 219
 220         if (status == BT_INTEGER_RANGE_SET_ADD_RANGE_STATUS_MEMORY_ERROR) {
 221             throw LibMemoryError {};
 222         }
 223     }
 224
 225     std::uint64_t size() const noexcept
 226     {
 227         return _Spec::size(this->_libObjPtr());
 228     }
 229
 230     Range operator[](const std::uint64_t index) const noexcept
 231     {
 232         return Range {_Spec::rangeByIndex(this->_libObjPtr(), index)};
 233     }
 234
 235     Shared shared() const noexcept
 236     {
 237         return Shared {*this};
 238     }
 239 };
 240
 241 using UnsignedIntegerRangeSet = CommonIntegerRangeSet<bt_integer_range_set_unsigned>;
 242 using ConstUnsignedIntegerRangeSet = CommonIntegerRangeSet<const bt_integer_range_set_unsigned>;
 243 using SignedIntegerRangeSet = CommonIntegerRangeSet<bt_integer_range_set_signed>;
 244 using ConstSignedIntegerRangeSet = CommonIntegerRangeSet<const bt_integer_range_set_signed>;
 245
 246 } // namespace bt2
 247
 248 #endif // BABELTRACE_CPP_COMMON_BT2_INTEGER_RANGE_SET_HPP