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
  13 #include <babeltrace2/babeltrace.h>
  14
  15 #include "borrowed-object.hpp"
  16 #include "common-iterator.hpp"
  17 #include "exc.hpp"
  18 #include "integer-range.hpp"
  19 #include "internal/utils.hpp"
  20 #include "shared-object.hpp"
  21
  22 namespace bt2 {
  23 namespace internal {
  24
  25 template <typename LibObjT>
  26 struct IntegerRangeSetRefFuncs;
  27
  28 template <>
  29 struct IntegerRangeSetRefFuncs<const bt_integer_range_set_unsigned> final
  30 {
  31     static void get(const bt_integer_range_set_unsigned * const libObjPtr) noexcept
  32     {
  33         bt_integer_range_set_unsigned_get_ref(libObjPtr);
  34     }
  35
  36     static void put(const bt_integer_range_set_unsigned * const libObjPtr) noexcept
  37     {
  38         bt_integer_range_set_unsigned_put_ref(libObjPtr);
  39     }
  40 };
  41
  42 template <>
  43 struct IntegerRangeSetRefFuncs<const bt_integer_range_set_signed> final
  44 {
  45     static void get(const bt_integer_range_set_signed * const libObjPtr) noexcept
  46     {
  47         bt_integer_range_set_signed_get_ref(libObjPtr);
  48     }
  49
  50     static void put(const bt_integer_range_set_signed * const libObjPtr) noexcept
  51     {
  52         bt_integer_range_set_signed_put_ref(libObjPtr);
  53     }
  54 };
  55
  56 template <typename LibObjT>
  57 struct CommonIntegerRangeSetSpec;
  58
  59 /* Functions specific to unsigned integer range sets */
  60 template <>
  61 struct CommonIntegerRangeSetSpec<const bt_integer_range_set_unsigned> final
  62 {
  63     static std::uint64_t length(const bt_integer_range_set_unsigned * const libRangePtr) noexcept
  64     {
  65         return bt_integer_range_set_get_range_count(
  66             bt_integer_range_set_unsigned_as_range_set_const(libRangePtr));
  67     }
  68
  69     static const bt_integer_range_unsigned *
  70     rangeByIndex(const bt_integer_range_set_unsigned * const libRangePtr,
  71                  const std::uint64_t index) noexcept
  72     {
  73         return bt_integer_range_set_unsigned_borrow_range_by_index_const(libRangePtr, index);
  74     }
  75
  76     static bool isEqual(const bt_integer_range_set_unsigned * const libRangePtrA,
  77                         const bt_integer_range_set_unsigned * const libRangePtrB) noexcept
  78     {
  79         return static_cast<bool>(
  80             bt_integer_range_set_unsigned_is_equal(libRangePtrA, libRangePtrB));
  81     }
  82
  83     static bt_integer_range_set_add_range_status
  84     addRange(bt_integer_range_set_unsigned * const libRangePtr, const std::uint64_t lower,
  85              const std::uint64_t upper) noexcept
  86     {
  87         return bt_integer_range_set_unsigned_add_range(libRangePtr, lower, upper);
  88     }
  89
  90     static bt_integer_range_set_unsigned *create() noexcept
  91     {
  92         return bt_integer_range_set_unsigned_create();
  93     }
  94 };
  95
  96 /* Functions specific to signed integer range sets */
  97 template <>
  98 struct CommonIntegerRangeSetSpec<const bt_integer_range_set_signed> final
  99 {
 100     static std::uint64_t length(const bt_integer_range_set_signed * const libRangePtr) noexcept
 101     {
 102         return bt_integer_range_set_get_range_count(
 103             bt_integer_range_set_signed_as_range_set_const(libRangePtr));
 104     }
 105
 106     static const bt_integer_range_signed *
 107     rangeByIndex(const bt_integer_range_set_signed * const libRangePtr,
 108                  const std::uint64_t index) noexcept
 109     {
 110         return bt_integer_range_set_signed_borrow_range_by_index_const(libRangePtr, index);
 111     }
 112
 113     static bool isEqual(const bt_integer_range_set_signed * const libRangePtrA,
 114                         const bt_integer_range_set_signed * const libRangePtrB) noexcept
 115     {
 116         return static_cast<bool>(bt_integer_range_set_signed_is_equal(libRangePtrA, libRangePtrB));
 117     }
 118
 119     static bt_integer_range_set_add_range_status
 120     addRange(bt_integer_range_set_signed * const libRangePtr, const std::int64_t lower,
 121              const std::int64_t upper) noexcept
 122     {
 123         return bt_integer_range_set_signed_add_range(libRangePtr, lower, upper);
 124     }
 125
 126     static bt_integer_range_set_signed *create() noexcept
 127     {
 128         return bt_integer_range_set_signed_create();
 129     }
 130 };
 131
 132 } /* namespace internal */
 133
 134 template <typename LibObjT>
 135 class CommonIntegerRangeSet final : public BorrowedObject<LibObjT>
 136 {
 137 private:
 138     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
 139     using typename BorrowedObject<LibObjT>::_LibObjPtr;
 140     using _ConstLibObjT = typename std::add_const<LibObjT>::type;
 141     using _RefFuncs = internal::IntegerRangeSetRefFuncs<_ConstLibObjT>;
 142     using _Spec = internal::CommonIntegerRangeSetSpec<_ConstLibObjT>;
 143     using _ThisCommonIntegerRangeSet = CommonIntegerRangeSet<LibObjT>;
 144
 145 public:
 146     using Shared = SharedObject<_ThisCommonIntegerRangeSet, LibObjT, _RefFuncs>;
 147
 148     using Range = typename std::conditional<
 149         std::is_same<_ConstLibObjT, const bt_integer_range_set_unsigned>::value,
 150         ConstUnsignedIntegerRange, ConstSignedIntegerRange>::type;
 151
 152     using Value = typename Range::Value;
 153     using Iterator = CommonIterator<CommonIntegerRangeSet, Range>;
 154
 155     explicit CommonIntegerRangeSet(const _LibObjPtr libObjPtr) noexcept :
 156         _ThisBorrowedObject {libObjPtr}
 157     {
 158     }
 159
 160     static Shared create()
 161     {
 162         const auto libObjPtr = _Spec::create();
 163
 164         internal::validateCreatedObjPtr(libObjPtr);
 165         return CommonIntegerRangeSet::Shared::createWithoutRef(libObjPtr);
 166     }
 167
 168     template <typename OtherLibObjT>
 169     CommonIntegerRangeSet(const CommonIntegerRangeSet<OtherLibObjT> rangeSet) noexcept :
 170         _ThisBorrowedObject {rangeSet}
 171     {
 172     }
 173
 174     template <typename OtherLibObjT>
 175     _ThisCommonIntegerRangeSet&
 176     operator=(const CommonIntegerRangeSet<OtherLibObjT> rangeSet) noexcept
 177     {
 178         _ThisBorrowedObject::operator=(rangeSet);
 179         return *this;
 180     }
 181
 182     template <typename OtherLibObjT>
 183     bool operator==(const CommonIntegerRangeSet<OtherLibObjT> other) const noexcept
 184     {
 185         return _Spec::isEqual(this->libObjPtr(), other.libObjPtr());
 186     }
 187
 188     template <typename OtherLibObjT>
 189     bool operator!=(const CommonIntegerRangeSet<OtherLibObjT> other) const noexcept
 190     {
 191         return !(*this == other);
 192     }
 193
 194     void addRange(const Value lower, const Value upper) const
 195     {
 196         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 197
 198         const auto status = _Spec::addRange(this->libObjPtr(), lower, upper);
 199
 200         if (status == BT_INTEGER_RANGE_SET_ADD_RANGE_STATUS_MEMORY_ERROR) {
 201             throw MemoryError {};
 202         }
 203     }
 204
 205     std::uint64_t length() const noexcept
 206     {
 207         return _Spec::length(this->libObjPtr());
 208     }
 209
 210     Range operator[](const std::uint64_t index) const noexcept
 211     {
 212         return Range {_Spec::rangeByIndex(this->libObjPtr(), index)};
 213     }
 214
 215     Iterator begin() const noexcept
 216     {
 217         return Iterator {*this, 0};
 218     }
 219
 220     Iterator end() const noexcept
 221     {
 222         return Iterator {*this, this->length()};
 223     }
 224
 225     Shared shared() const noexcept
 226     {
 227         return Shared::createWithRef(*this);
 228     }
 229 };
 230
 231 using UnsignedIntegerRangeSet = CommonIntegerRangeSet<bt_integer_range_set_unsigned>;
 232 using ConstUnsignedIntegerRangeSet = CommonIntegerRangeSet<const bt_integer_range_set_unsigned>;
 233 using SignedIntegerRangeSet = CommonIntegerRangeSet<bt_integer_range_set_signed>;
 234 using ConstSignedIntegerRangeSet = CommonIntegerRangeSet<const bt_integer_range_set_signed>;
 235
 236 namespace internal {
 237
 238 struct UnsignedIntegerRangeSetTypeDescr
 239 {
 240     using Const = ConstUnsignedIntegerRangeSet;
 241     using NonConst = UnsignedIntegerRangeSet;
 242 };
 243
 244 template <>
 245 struct TypeDescr<UnsignedIntegerRangeSet> : public UnsignedIntegerRangeSetTypeDescr
 246 {
 247 };
 248
 249 template <>
 250 struct TypeDescr<ConstUnsignedIntegerRangeSet> : public UnsignedIntegerRangeSetTypeDescr
 251 {
 252 };
 253
 254 struct SignedIntegerRangeSetTypeDescr
 255 {
 256     using Const = ConstSignedIntegerRangeSet;
 257     using NonConst = SignedIntegerRangeSet;
 258 };
 259
 260 template <>
 261 struct TypeDescr<SignedIntegerRangeSet> : public SignedIntegerRangeSetTypeDescr
 262 {
 263 };
 264
 265 template <>
 266 struct TypeDescr<ConstSignedIntegerRangeSet> : public SignedIntegerRangeSetTypeDescr
 267 {
 268 };
 269
 270 } /* namespace internal */
 271 } /* namespace bt2 */
 272
 273 #endif /* BABELTRACE_CPP_COMMON_BT2_INTEGER_RANGE_SET_HPP */