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