src/cpp-common/bt2/clock-class.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_CLOCK_CLASS_HPP
   8 #define BABELTRACE_CPP_COMMON_BT2_CLOCK_CLASS_HPP
   9
  10 #include <cstdint>
  11 #include <string>
  12 #include <type_traits>
  13
  14 #include <babeltrace2/babeltrace.h>
  15
  16 #include "cpp-common/optional.hpp"
  17 #include "cpp-common/string_view.hpp"
  18 #include "cpp-common/uuid-view.hpp"
  19
  20 #include "borrowed-object.hpp"
  21 #include "exc.hpp"
  22 #include "internal/utils.hpp"
  23 #include "shared-object.hpp"
  24 #include "value.hpp"
  25
  26 namespace bt2 {
  27 namespace internal {
  28
  29 struct ClockClassRefFuncs final
  30 {
  31     static void get(const bt_clock_class * const libObjPtr) noexcept
  32     {
  33         bt_clock_class_get_ref(libObjPtr);
  34     }
  35
  36     static void put(const bt_clock_class * const libObjPtr) noexcept
  37     {
  38         bt_clock_class_put_ref(libObjPtr);
  39     }
  40 };
  41
  42 template <typename LibObjT>
  43 struct CommonClockClassSpec;
  44
  45 /* Functions specific to mutable clock classes */
  46 template <>
  47 struct CommonClockClassSpec<bt_clock_class> final
  48 {
  49     static bt_value *userAttributes(bt_clock_class * const libObjPtr) noexcept
  50     {
  51         return bt_clock_class_borrow_user_attributes(libObjPtr);
  52     }
  53 };
  54
  55 /* Functions specific to constant clock classes */
  56 template <>
  57 struct CommonClockClassSpec<const bt_clock_class> final
  58 {
  59     static const bt_value *userAttributes(const bt_clock_class * const libObjPtr) noexcept
  60     {
  61         return bt_clock_class_borrow_user_attributes_const(libObjPtr);
  62     }
  63 };
  64
  65 } /* namespace internal */
  66
  67 class ClockClassOffset final
  68 {
  69 public:
  70     explicit ClockClassOffset(const std::int64_t seconds, const std::uint64_t cycles) :
  71         _mSeconds {seconds}, _mCycles {cycles}
  72     {
  73     }
  74
  75     ClockClassOffset(const ClockClassOffset&) noexcept = default;
  76     ClockClassOffset& operator=(const ClockClassOffset&) noexcept = default;
  77
  78     std::int64_t seconds() const noexcept
  79     {
  80         return _mSeconds;
  81     }
  82
  83     std::uint64_t cycles() const noexcept
  84     {
  85         return _mCycles;
  86     }
  87
  88 private:
  89     std::int64_t _mSeconds;
  90     std::uint64_t _mCycles;
  91 };
  92
  93 template <typename LibObjT>
  94 class CommonClockClass final : public BorrowedObject<LibObjT>
  95 {
  96 private:
  97     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
  98     using typename BorrowedObject<LibObjT>::_LibObjPtr;
  99     using _ThisCommonClockClass = CommonClockClass<LibObjT>;
 100
 101 public:
 102     using Shared = SharedObject<_ThisCommonClockClass, LibObjT, internal::ClockClassRefFuncs>;
 103
 104     using UserAttributes =
 105         typename std::conditional<std::is_const<LibObjT>::value, ConstMapValue, MapValue>::type;
 106
 107     explicit CommonClockClass(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
 108     {
 109     }
 110
 111     template <typename OtherLibObjT>
 112     CommonClockClass(const CommonClockClass<OtherLibObjT> clkClass) noexcept :
 113         _ThisBorrowedObject {clkClass}
 114     {
 115     }
 116
 117     template <typename OtherLibObjT>
 118     _ThisCommonClockClass& operator=(const CommonClockClass<OtherLibObjT> clkClass) noexcept
 119     {
 120         _ThisBorrowedObject::operator=(clkClass);
 121         return *this;
 122     }
 123
 124     CommonClockClass<const bt_clock_class> asConst() const noexcept
 125     {
 126         return CommonClockClass<const bt_clock_class> {*this};
 127     }
 128
 129     void frequency(const std::uint64_t frequency) const noexcept
 130     {
 131         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 132
 133         bt_clock_class_set_frequency(this->libObjPtr(), frequency);
 134     }
 135
 136     std::uint64_t frequency() const noexcept
 137     {
 138         return bt_clock_class_get_frequency(this->libObjPtr());
 139     }
 140
 141     void offset(const ClockClassOffset& offset) const noexcept
 142     {
 143         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 144
 145         bt_clock_class_set_offset(this->libObjPtr(), offset.seconds(), offset.cycles());
 146     }
 147
 148     ClockClassOffset offset() const noexcept
 149     {
 150         std::int64_t seconds;
 151         std::uint64_t cycles;
 152
 153         bt_clock_class_get_offset(this->libObjPtr(), &seconds, &cycles);
 154         return ClockClassOffset {seconds, cycles};
 155     }
 156
 157     void precision(const std::uint64_t precision) const noexcept
 158     {
 159         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 160
 161         bt_clock_class_set_precision(this->libObjPtr(), precision);
 162     }
 163
 164     std::uint64_t precision() const noexcept
 165     {
 166         return bt_clock_class_get_precision(this->libObjPtr());
 167     }
 168
 169     void originIsUnixEpoch(const bool originIsUnixEpoch) const noexcept
 170     {
 171         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 172
 173         bt_clock_class_set_origin_is_unix_epoch(this->libObjPtr(),
 174                                                 static_cast<bt_bool>(originIsUnixEpoch));
 175     }
 176
 177     bool originIsUnixEpoch() const noexcept
 178     {
 179         return static_cast<bool>(bt_clock_class_origin_is_unix_epoch(this->libObjPtr()));
 180     }
 181
 182     void name(const char * const name) const
 183     {
 184         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 185
 186         const auto status = bt_clock_class_set_name(this->libObjPtr(), name);
 187
 188         if (status == BT_CLOCK_CLASS_SET_NAME_STATUS_MEMORY_ERROR) {
 189             throw MemoryError {};
 190         }
 191     }
 192
 193     void name(const std::string& name) const
 194     {
 195         this->name(name.data());
 196     }
 197
 198     nonstd::optional<bpstd::string_view> name() const noexcept
 199     {
 200         const auto name = bt_clock_class_get_name(this->libObjPtr());
 201
 202         if (name) {
 203             return name;
 204         }
 205
 206         return nonstd::nullopt;
 207     }
 208
 209     void description(const char * const description) const
 210     {
 211         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 212
 213         const auto status = bt_clock_class_set_description(this->libObjPtr(), description);
 214
 215         if (status == BT_CLOCK_CLASS_SET_DESCRIPTION_STATUS_MEMORY_ERROR) {
 216             throw MemoryError {};
 217         }
 218     }
 219
 220     void description(const std::string& description) const
 221     {
 222         this->description(description.data());
 223     }
 224
 225     nonstd::optional<bpstd::string_view> description() const noexcept
 226     {
 227         const auto description = bt_clock_class_get_description(this->libObjPtr());
 228
 229         if (description) {
 230             return description;
 231         }
 232
 233         return nonstd::nullopt;
 234     }
 235
 236     void uuid(const std::uint8_t * const uuid) const noexcept
 237     {
 238         bt_clock_class_set_uuid(this->libObjPtr(), uuid);
 239     }
 240
 241     nonstd::optional<bt2_common::UuidView> uuid() const noexcept
 242     {
 243         const auto uuid = bt_clock_class_get_uuid(this->libObjPtr());
 244
 245         if (uuid) {
 246             return bt2_common::UuidView {uuid};
 247         }
 248
 249         return nonstd::nullopt;
 250     }
 251
 252     template <typename LibValT>
 253     void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
 254     {
 255         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 256
 257         bt_clock_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
 258     }
 259
 260     UserAttributes userAttributes() const noexcept
 261     {
 262         return UserAttributes {
 263             internal::CommonClockClassSpec<LibObjT>::userAttributes(this->libObjPtr())};
 264     }
 265
 266     std::int64_t cyclesToNsFromOrigin(const std::uint64_t value) const
 267     {
 268         std::int64_t nsFromOrigin;
 269         const auto status =
 270             bt_clock_class_cycles_to_ns_from_origin(this->libObjPtr(), value, &nsFromOrigin);
 271
 272         if (status == BT_CLOCK_CLASS_CYCLES_TO_NS_FROM_ORIGIN_STATUS_OVERFLOW_ERROR) {
 273             throw OverflowError {};
 274         }
 275
 276         return nsFromOrigin;
 277     }
 278
 279     Shared shared() const noexcept
 280     {
 281         return Shared::createWithRef(*this);
 282     }
 283 };
 284
 285 using ClockClass = CommonClockClass<bt_clock_class>;
 286 using ConstClockClass = CommonClockClass<const bt_clock_class>;
 287
 288 namespace internal {
 289
 290 struct ClockClassTypeDescr
 291 {
 292     using Const = ConstClockClass;
 293     using NonConst = ClockClass;
 294 };
 295
 296 template <>
 297 struct TypeDescr<ClockClass> : public ClockClassTypeDescr
 298 {
 299 };
 300
 301 template <>
 302 struct TypeDescr<ConstClockClass> : public ClockClassTypeDescr
 303 {
 304 };
 305
 306 } /* namespace internal */
 307 } /* namespace bt2 */
 308
 309 #endif /* BABELTRACE_CPP_COMMON_BT2_CLOCK_CLASS_HPP */