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