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
 100 public:
 101     using Shared = SharedObject<CommonClockClass, LibObjT, internal::ClockClassRefFuncs>;
 102     using UserAttributes = internal::DepUserAttrs<LibObjT>;
 103
 104     explicit CommonClockClass(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
 105     {
 106     }
 107
 108     template <typename OtherLibObjT>
 109     CommonClockClass(const CommonClockClass<OtherLibObjT> clkClass) noexcept :
 110         _ThisBorrowedObject {clkClass}
 111     {
 112     }
 113
 114     template <typename OtherLibObjT>
 115     CommonClockClass& operator=(const CommonClockClass<OtherLibObjT> clkClass) noexcept
 116     {
 117         _ThisBorrowedObject::operator=(clkClass);
 118         return *this;
 119     }
 120
 121     CommonClockClass<const bt_clock_class> asConst() const noexcept
 122     {
 123         return CommonClockClass<const bt_clock_class> {*this};
 124     }
 125
 126     void frequency(const std::uint64_t frequency) const noexcept
 127     {
 128         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstClockClass`.");
 129
 130         bt_clock_class_set_frequency(this->libObjPtr(), frequency);
 131     }
 132
 133     std::uint64_t frequency() const noexcept
 134     {
 135         return bt_clock_class_get_frequency(this->libObjPtr());
 136     }
 137
 138     void offset(const ClockClassOffset& offset) const noexcept
 139     {
 140         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstClockClass`.");
 141
 142         bt_clock_class_set_offset(this->libObjPtr(), offset.seconds(), offset.cycles());
 143     }
 144
 145     ClockClassOffset offset() const noexcept
 146     {
 147         std::int64_t seconds;
 148         std::uint64_t cycles;
 149
 150         bt_clock_class_get_offset(this->libObjPtr(), &seconds, &cycles);
 151         return ClockClassOffset {seconds, cycles};
 152     }
 153
 154     void precision(const std::uint64_t precision) const noexcept
 155     {
 156         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstClockClass`.");
 157
 158         bt_clock_class_set_precision(this->libObjPtr(), precision);
 159     }
 160
 161     std::uint64_t precision() const noexcept
 162     {
 163         return bt_clock_class_get_precision(this->libObjPtr());
 164     }
 165
 166     void originIsUnixEpoch(const bool originIsUnixEpoch) const noexcept
 167     {
 168         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstClockClass`.");
 169
 170         bt_clock_class_set_origin_is_unix_epoch(this->libObjPtr(),
 171                                                 static_cast<bt_bool>(originIsUnixEpoch));
 172     }
 173
 174     bool originIsUnixEpoch() const noexcept
 175     {
 176         return static_cast<bool>(bt_clock_class_origin_is_unix_epoch(this->libObjPtr()));
 177     }
 178
 179     void name(const char * const name) const
 180     {
 181         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstClockClass`.");
 182
 183         const auto status = bt_clock_class_set_name(this->libObjPtr(), name);
 184
 185         if (status == BT_CLOCK_CLASS_SET_NAME_STATUS_MEMORY_ERROR) {
 186             throw MemoryError {};
 187         }
 188     }
 189
 190     void name(const std::string& name) const
 191     {
 192         this->name(name.data());
 193     }
 194
 195     nonstd::optional<bpstd::string_view> name() const noexcept
 196     {
 197         const auto name = bt_clock_class_get_name(this->libObjPtr());
 198
 199         if (name) {
 200             return name;
 201         }
 202
 203         return nonstd::nullopt;
 204     }
 205
 206     void description(const char * const description) const
 207     {
 208         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstClockClass`.");
 209
 210         const auto status = bt_clock_class_set_description(this->libObjPtr(), description);
 211
 212         if (status == BT_CLOCK_CLASS_SET_DESCRIPTION_STATUS_MEMORY_ERROR) {
 213             throw MemoryError {};
 214         }
 215     }
 216
 217     void description(const std::string& description) const
 218     {
 219         this->description(description.data());
 220     }
 221
 222     nonstd::optional<bpstd::string_view> description() const noexcept
 223     {
 224         const auto description = bt_clock_class_get_description(this->libObjPtr());
 225
 226         if (description) {
 227             return description;
 228         }
 229
 230         return nonstd::nullopt;
 231     }
 232
 233     void uuid(const std::uint8_t * const uuid) const noexcept
 234     {
 235         bt_clock_class_set_uuid(this->libObjPtr(), uuid);
 236     }
 237
 238     nonstd::optional<bt2_common::UuidView> uuid() const noexcept
 239     {
 240         const auto uuid = bt_clock_class_get_uuid(this->libObjPtr());
 241
 242         if (uuid) {
 243             return bt2_common::UuidView {uuid};
 244         }
 245
 246         return nonstd::nullopt;
 247     }
 248
 249     template <typename LibValT>
 250     void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
 251     {
 252         static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstClockClass`.");
 253
 254         bt_clock_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
 255     }
 256
 257     UserAttributes userAttributes() const noexcept
 258     {
 259         return UserAttributes {
 260             internal::CommonClockClassSpec<LibObjT>::userAttributes(this->libObjPtr())};
 261     }
 262
 263     std::int64_t cyclesToNsFromOrigin(const std::uint64_t value) const
 264     {
 265         std::int64_t nsFromOrigin;
 266         const auto status =
 267             bt_clock_class_cycles_to_ns_from_origin(this->libObjPtr(), value, &nsFromOrigin);
 268
 269         if (status == BT_CLOCK_CLASS_CYCLES_TO_NS_FROM_ORIGIN_STATUS_OVERFLOW_ERROR) {
 270             throw OverflowError {};
 271         }
 272
 273         return nsFromOrigin;
 274     }
 275
 276     Shared shared() const noexcept
 277     {
 278         return Shared::createWithRef(*this);
 279     }
 280 };
 281
 282 using ClockClass = CommonClockClass<bt_clock_class>;
 283 using ConstClockClass = CommonClockClass<const bt_clock_class>;
 284
 285 namespace internal {
 286
 287 struct ClockClassTypeDescr
 288 {
 289     using Const = ConstClockClass;
 290     using NonConst = ClockClass;
 291 };
 292
 293 template <>
 294 struct TypeDescr<ClockClass> : public ClockClassTypeDescr
 295 {
 296 };
 297
 298 template <>
 299 struct TypeDescr<ConstClockClass> : public ClockClassTypeDescr
 300 {
 301 };
 302
 303 } /* namespace internal */
 304 } /* namespace bt2 */
 305
 306 #endif /* BABELTRACE_CPP_COMMON_BT2_CLOCK_CLASS_HPP */