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-iterator.hpp"
  16 #include "borrowed-object.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 = BorrowedObjectIterator<CommonIntegerRangeSet>;
 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     _ConstLibObjT asConst() const noexcept
 183     {
 184         return _ConstLibObjT {*this};
 185     }
 186
 187     template <typename OtherLibObjT>
 188     bool operator==(const CommonIntegerRangeSet<OtherLibObjT> other) const noexcept
 189     {
 190         return _Spec::isEqual(this->libObjPtr(), other.libObjPtr());
 191     }
 192
 193     template <typename OtherLibObjT>
 194     bool operator!=(const CommonIntegerRangeSet<OtherLibObjT> other) const noexcept
 195     {
 196         return !(*this == other);
 197     }
 198
 199     void addRange(const Value lower, const Value upper) const
 200     {
 201         static_assert(
 202             !std::is_const<LibObjT>::value,
 203             "Not available with `bt2::ConstUnsignedIntegerRangeSet` or `bt2::ConstSignedIntegerRangeSet`.");
 204
 205         const auto status = _Spec::addRange(this->libObjPtr(), lower, upper);
 206
 207         if (status == BT_INTEGER_RANGE_SET_ADD_RANGE_STATUS_MEMORY_ERROR) {
 208             throw MemoryError {};
 209         }
 210     }
 211
 212     std::uint64_t length() const noexcept
 213     {
 214         return _Spec::length(this->libObjPtr());
 215     }
 216
 217     Range operator[](const std::uint64_t index) const noexcept
 218     {
 219         return Range {_Spec::rangeByIndex(this->libObjPtr(), index)};
 220     }
 221
 222     Iterator begin() const noexcept
 223     {
 224         return Iterator {*this, 0};
 225     }
 226
 227     Iterator end() const noexcept
 228     {
 229         return Iterator {*this, this->length()};
 230     }
 231
 232     Shared shared() const noexcept
 233     {
 234         return Shared::createWithRef(*this);
 235     }
 236 };
 237
 238 using UnsignedIntegerRangeSet = CommonIntegerRangeSet<bt_integer_range_set_unsigned>;
 239 using ConstUnsignedIntegerRangeSet = CommonIntegerRangeSet<const bt_integer_range_set_unsigned>;
 240 using SignedIntegerRangeSet = CommonIntegerRangeSet<bt_integer_range_set_signed>;
 241 using ConstSignedIntegerRangeSet = CommonIntegerRangeSet<const bt_integer_range_set_signed>;
 242
 243 namespace internal {
 244
 245 struct UnsignedIntegerRangeSetTypeDescr
 246 {
 247     using Const = ConstUnsignedIntegerRangeSet;
 248     using NonConst = UnsignedIntegerRangeSet;
 249 };
 250
 251 template <>
 252 struct TypeDescr<UnsignedIntegerRangeSet> : public UnsignedIntegerRangeSetTypeDescr
 253 {
 254 };
 255
 256 template <>
 257 struct TypeDescr<ConstUnsignedIntegerRangeSet> : public UnsignedIntegerRangeSetTypeDescr
 258 {
 259 };
 260
 261 struct SignedIntegerRangeSetTypeDescr
 262 {
 263     using Const = ConstSignedIntegerRangeSet;
 264     using NonConst = SignedIntegerRangeSet;
 265 };
 266
 267 template <>
 268 struct TypeDescr<SignedIntegerRangeSet> : public SignedIntegerRangeSetTypeDescr
 269 {
 270 };
 271
 272 template <>
 273 struct TypeDescr<ConstSignedIntegerRangeSet> : public SignedIntegerRangeSetTypeDescr
 274 {
 275 };
 276
 277 } /* namespace internal */
 278 } /* namespace bt2 */
 279
 280 #endif /* BABELTRACE_CPP_COMMON_BT2_INTEGER_RANGE_SET_HPP */