src/cpp-common/bt2/integer-range.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_HPP
   8 #define BABELTRACE_CPP_COMMON_BT2_INTEGER_RANGE_HPP
   9
  10 #include <cstdint>
  11 #include <type_traits>
  12
  13 #include <babeltrace2/babeltrace.h>
  14
  15 #include "borrowed-object.hpp"
  16
  17 namespace bt2 {
  18
  19 namespace internal {
  20
  21 template <typename ValueT>
  22 struct ConstIntegerRangeSpec;
  23
  24 /* Functions specific to unsigned integer ranges */
  25 template <>
  26 struct ConstIntegerRangeSpec<const bt_integer_range_unsigned> final
  27 {
  28     static std::uint64_t lower(const bt_integer_range_unsigned * const libRangePtr) noexcept
  29     {
  30         return bt_integer_range_unsigned_get_lower(libRangePtr);
  31     }
  32
  33     static std::uint64_t upper(const bt_integer_range_unsigned * const libRangePtr) noexcept
  34     {
  35         return bt_integer_range_unsigned_get_upper(libRangePtr);
  36     }
  37
  38     static bool isEqual(const bt_integer_range_unsigned * const libRangePtrA,
  39                         const bt_integer_range_unsigned * const libRangePtrB) noexcept
  40     {
  41         return static_cast<bool>(bt_integer_range_unsigned_is_equal(libRangePtrA, libRangePtrB));
  42     }
  43 };
  44
  45 /* Functions specific to signed integer ranges */
  46 template <>
  47 struct ConstIntegerRangeSpec<const bt_integer_range_signed> final
  48 {
  49     static std::int64_t lower(const bt_integer_range_signed * const libRangePtr) noexcept
  50     {
  51         return bt_integer_range_signed_get_lower(libRangePtr);
  52     }
  53
  54     static std::int64_t upper(const bt_integer_range_signed * const libRangePtr) noexcept
  55     {
  56         return bt_integer_range_signed_get_upper(libRangePtr);
  57     }
  58
  59     static bool isEqual(const bt_integer_range_signed * const libRangePtrA,
  60                         const bt_integer_range_signed * const libRangePtrB) noexcept
  61     {
  62         return static_cast<bool>(bt_integer_range_signed_is_equal(libRangePtrA, libRangePtrB));
  63     }
  64 };
  65
  66 } /* namespace internal */
  67
  68 template <typename LibObjT>
  69 class ConstIntegerRange final : public BorrowedObject<LibObjT>
  70 {
  71 private:
  72     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
  73     using typename BorrowedObject<LibObjT>::_LibObjPtr;
  74     using _ThisConstIntegerRange = ConstIntegerRange<LibObjT>;
  75
  76 public:
  77     using Value =
  78         typename std::conditional<std::is_same<LibObjT, const bt_integer_range_unsigned>::value,
  79                                   std::uint64_t, std::int64_t>::type;
  80
  81 public:
  82     explicit ConstIntegerRange(const _LibObjPtr libObjPtr) noexcept :
  83         _ThisBorrowedObject {libObjPtr}
  84     {
  85     }
  86
  87     ConstIntegerRange(const _ThisConstIntegerRange& range) noexcept : _ThisBorrowedObject {range}
  88     {
  89     }
  90
  91     _ThisConstIntegerRange& operator=(const _ThisConstIntegerRange& range) noexcept
  92     {
  93         _ThisBorrowedObject::operator=(range);
  94         return *this;
  95     }
  96
  97     bool operator==(const _ThisConstIntegerRange& other) const noexcept
  98     {
  99         return internal::ConstIntegerRangeSpec<LibObjT>::isEqual(this->libObjPtr(),
 100                                                                  other.libObjPtr());
 101     }
 102
 103     bool operator!=(const _ThisConstIntegerRange& other) const noexcept
 104     {
 105         return !(*this == other);
 106     }
 107
 108     Value lower() const noexcept
 109     {
 110         return internal::ConstIntegerRangeSpec<LibObjT>::lower(this->libObjPtr());
 111     }
 112
 113     Value upper() const noexcept
 114     {
 115         return internal::ConstIntegerRangeSpec<LibObjT>::upper(this->libObjPtr());
 116     }
 117 };
 118
 119 using ConstUnsignedIntegerRange = ConstIntegerRange<const bt_integer_range_unsigned>;
 120 using ConstSignedIntegerRange = ConstIntegerRange<const bt_integer_range_signed>;
 121
 122 } /* namespace bt2 */
 123
 124 #endif /* BABELTRACE_CPP_COMMON_BT2_INTEGER_RANGE_HPP */