src/cpp-common/bt2/field-path.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_FIELD_PATH_HPP
   8 #define BABELTRACE_CPP_COMMON_BT2_FIELD_PATH_HPP
   9
  10 #include <cstdint>
  11
  12 #include <babeltrace2/babeltrace.h>
  13
  14 #include "common/assert.h"
  15
  16 #include "borrowed-object.hpp"
  17 #include "common-iter.hpp"
  18 #include "internal/shared-obj.hpp"
  19
  20 namespace bt2 {
  21
  22 class ConstIndexFieldPathItem;
  23
  24 enum class FieldPathItemType
  25 {
  26     INDEX = BT_FIELD_PATH_ITEM_TYPE_INDEX,
  27     CURRENT_ARRAY_ELEMENT = BT_FIELD_PATH_ITEM_TYPE_CURRENT_ARRAY_ELEMENT,
  28     CURRENT_OPTION_CONTENT = BT_FIELD_PATH_ITEM_TYPE_CURRENT_OPTION_CONTENT,
  29 };
  30
  31 class ConstFieldPathItem : public BorrowedObject<const bt_field_path_item>
  32 {
  33 public:
  34     explicit ConstFieldPathItem(const _LibObjPtr libObjPtr) noexcept :
  35         _ThisBorrowedObject {libObjPtr}
  36     {
  37     }
  38
  39     ConstFieldPathItem(const ConstFieldPathItem& fpItem) noexcept : _ThisBorrowedObject {fpItem}
  40     {
  41     }
  42
  43     ConstFieldPathItem& operator=(const ConstFieldPathItem& fpItem) noexcept
  44     {
  45         _ThisBorrowedObject::operator=(fpItem);
  46         return *this;
  47     }
  48
  49     FieldPathItemType type() const noexcept
  50     {
  51         return static_cast<FieldPathItemType>(this->_libType());
  52     }
  53
  54     bool isIndex() const noexcept
  55     {
  56         return this->_libType() == BT_FIELD_PATH_ITEM_TYPE_INDEX;
  57     }
  58
  59     bool isCurrentArrayElement() const noexcept
  60     {
  61         return this->_libType() == BT_FIELD_PATH_ITEM_TYPE_CURRENT_ARRAY_ELEMENT;
  62     }
  63
  64     bool isCurrentOptionContent() const noexcept
  65     {
  66         return this->_libType() == BT_FIELD_PATH_ITEM_TYPE_CURRENT_OPTION_CONTENT;
  67     }
  68
  69     ConstIndexFieldPathItem asIndex() const noexcept;
  70
  71 private:
  72     bt_field_path_item_type _libType() const noexcept
  73     {
  74         return bt_field_path_item_get_type(this->libObjPtr());
  75     }
  76 };
  77
  78 class ConstIndexFieldPathItem final : public ConstFieldPathItem
  79 {
  80 public:
  81     explicit ConstIndexFieldPathItem(const _LibObjPtr libObjPtr) noexcept :
  82         ConstFieldPathItem {libObjPtr}
  83     {
  84         BT_ASSERT_DBG(this->isIndex());
  85     }
  86
  87     ConstIndexFieldPathItem(const ConstIndexFieldPathItem& fpItem) noexcept :
  88         ConstFieldPathItem {fpItem}
  89     {
  90     }
  91
  92     ConstIndexFieldPathItem& operator=(const ConstIndexFieldPathItem& fpItem) noexcept
  93     {
  94         ConstFieldPathItem::operator=(fpItem);
  95         return *this;
  96     }
  97
  98     std::uint64_t index() const noexcept
  99     {
 100         return bt_field_path_item_index_get_index(this->libObjPtr());
 101     }
 102 };
 103
 104 inline ConstIndexFieldPathItem ConstFieldPathItem::asIndex() const noexcept
 105 {
 106     BT_ASSERT_DBG(this->isIndex());
 107     return ConstIndexFieldPathItem {this->libObjPtr()};
 108 }
 109
 110 namespace internal {
 111
 112 struct FieldPathRefFuncs final
 113 {
 114     static void get(const bt_field_path * const libObjPtr)
 115     {
 116         bt_field_path_get_ref(libObjPtr);
 117     }
 118
 119     static void put(const bt_field_path * const libObjPtr)
 120     {
 121         bt_field_path_put_ref(libObjPtr);
 122     }
 123 };
 124
 125 } /* namespace internal */
 126
 127 class ConstFieldPath final : public BorrowedObject<const bt_field_path>
 128 {
 129 public:
 130     using Shared =
 131         internal::SharedObj<ConstFieldPath, const bt_field_path, internal::FieldPathRefFuncs>;
 132
 133     using Iterator = CommonIterator<ConstFieldPath, ConstFieldPathItem>;
 134
 135     enum class Scope
 136     {
 137         PACKET_CONTEXT = BT_FIELD_PATH_SCOPE_PACKET_CONTEXT,
 138         EVENT_COMMON_CONTEXT = BT_FIELD_PATH_SCOPE_EVENT_COMMON_CONTEXT,
 139         EVENT_SPECIFIC_CONTEXT = BT_FIELD_PATH_SCOPE_EVENT_SPECIFIC_CONTEXT,
 140         EVENT_PAYLOAD = BT_FIELD_PATH_SCOPE_EVENT_PAYLOAD,
 141     };
 142
 143     explicit ConstFieldPath(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
 144     {
 145     }
 146
 147     ConstFieldPath(const ConstFieldPath& fieldPath) noexcept : _ThisBorrowedObject {fieldPath}
 148     {
 149     }
 150
 151     ConstFieldPath& operator=(const ConstFieldPath& fieldPath) noexcept
 152     {
 153         _ThisBorrowedObject::operator=(fieldPath);
 154         return *this;
 155     }
 156
 157     Scope rootScope() const noexcept
 158     {
 159         return static_cast<Scope>(bt_field_path_get_root_scope(this->libObjPtr()));
 160     }
 161
 162     std::uint64_t size() const noexcept
 163     {
 164         return bt_field_path_get_item_count(this->libObjPtr());
 165     }
 166
 167     ConstFieldPathItem operator[](const std::uint64_t index) const noexcept
 168     {
 169         return ConstFieldPathItem {
 170             bt_field_path_borrow_item_by_index_const(this->libObjPtr(), index)};
 171     }
 172
 173     Iterator begin() const noexcept
 174     {
 175         return Iterator {*this, 0};
 176     }
 177
 178     Iterator end() const noexcept
 179     {
 180         return Iterator {*this, this->size()};
 181     }
 182
 183     Shared shared() const noexcept
 184     {
 185         return Shared::createWithRef(*this);
 186     }
 187 };
 188
 189 } /* namespace bt2 */
 190
 191 #endif /* BABELTRACE_CPP_COMMON_BT2_FIELD_PATH_HPP */