endif
noinst_HEADERS = \
+ cpp-common/bt2/borrowed-object-iterator.hpp \
cpp-common/bt2/borrowed-object-proxy.hpp \
cpp-common/bt2/borrowed-object.hpp \
cpp-common/bt2/clock-class.hpp \
cpp-common/bt2/clock-snapshot.hpp \
- cpp-common/bt2/common-iterator.hpp \
cpp-common/bt2/exc.hpp \
cpp-common/bt2/field-class.hpp \
cpp-common/bt2/field.hpp \
--- /dev/null
+/*
+ * Copyright (c) 2022 Francis Deslauriers <francis.deslauriers@efficios.com>
+ * Copyright (c) 2023 Philippe Proulx <pproulx@efficios.com>
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef BABELTRACE_CPP_COMMON_BT2_BORROWED_OBJECT_ITERATOR_HPP
+#define BABELTRACE_CPP_COMMON_BT2_BORROWED_OBJECT_ITERATOR_HPP
+
+#include <cstdint>
+#include <type_traits>
+#include <utility>
+
+#include "common/assert.h"
+
+#include "borrowed-object-proxy.hpp"
+
+namespace bt2 {
+
+/*
+ * An iterator class to iterate an instance of a borrowed object
+ * container of type `ContainerT`.
+ *
+ * `ContainerT` must implement:
+ *
+ * // Returns the number of contained borrowed objects.
+ * std::uint64_t length() const noexcept;
+ *
+ * // Returns the borrowed object at index `i`.
+ * SomeObject operator[](std::uint64_t i) const noexcept;
+ */
+template <typename ContainerT>
+class BorrowedObjectIterator final
+{
+ friend ContainerT;
+
+public:
+ using Object = typename std::remove_reference<
+ decltype(std::declval<ContainerT>()[std::declval<std::uint64_t>()])>::type;
+
+private:
+ explicit BorrowedObjectIterator(const ContainerT container, const uint64_t idx) :
+ _mContainer {container}, _mIdx {idx}
+ {
+ }
+
+public:
+ BorrowedObjectIterator& operator++() noexcept
+ {
+ ++_mIdx;
+ return *this;
+ }
+
+ BorrowedObjectIterator operator++(int) noexcept
+ {
+ const auto tmp = *this;
+
+ ++(*this);
+ return tmp;
+ }
+
+ bool operator==(const BorrowedObjectIterator& other) const noexcept
+ {
+ BT_ASSERT_DBG(_mContainer.isSame(other._mContainer));
+ return _mIdx == other._mIdx;
+ }
+
+ bool operator!=(const BorrowedObjectIterator& other) const noexcept
+ {
+ return !(*this == other);
+ }
+
+ Object operator*() const noexcept
+ {
+ BT_ASSERT_DBG(_mIdx < _mContainer.length());
+ return _mContainer[_mIdx];
+ }
+
+ BorrowedObjectProxy<Object> operator->() const noexcept
+ {
+ return BorrowedObjectProxy<Object> {(**this).libObjPtr()};
+ }
+
+private:
+ ContainerT _mContainer;
+ std::uint64_t _mIdx;
+};
+
+} /* namespace bt2 */
+
+#endif /* BABELTRACE_CPP_COMMON_BT2_BORROWED_OBJECT_ITERATOR_HPP */
+++ /dev/null
-/*
- * Copyright (c) 2022 Francis Deslauriers <francis.deslauriers@efficios.com>
- *
- * SPDX-License-Identifier: MIT
- */
-
-#ifndef BABELTRACE_CPP_COMMON_BT2_COMMON_ITERATOR_HPP
-#define BABELTRACE_CPP_COMMON_BT2_COMMON_ITERATOR_HPP
-
-#include <cstdint>
-#include <iterator>
-
-#include "cpp-common/optional.hpp"
-
-namespace bt2 {
-
-template <typename ContainerT, typename ElemT>
-class CommonIterator
-{
- friend ContainerT;
-
-public:
- using difference_type = std::ptrdiff_t;
- using value_type = ElemT;
- using pointer = value_type *;
- using reference = value_type&;
- using iterator_category = std::input_iterator_tag;
-
-private:
- explicit CommonIterator(const ContainerT container, const uint64_t idx) :
- _mContainer {container}, _mIdx {idx}
- {
- this->_updateCurrentValue();
- }
-
-public:
- CommonIterator(const CommonIterator&) = default;
- CommonIterator(CommonIterator&&) = default;
- CommonIterator& operator=(const CommonIterator&) = default;
- CommonIterator& operator=(CommonIterator&&) = default;
-
- CommonIterator& operator++() noexcept
- {
- ++_mIdx;
- this->_updateCurrentValue();
- return *this;
- }
-
- CommonIterator operator++(int) noexcept
- {
- const auto tmp = *this;
-
- ++(*this);
- return tmp;
- }
-
- bool operator==(const CommonIterator& other) const noexcept
- {
- return _mIdx == other._mIdx;
- }
-
- bool operator!=(const CommonIterator& other) const noexcept
- {
- return !(*this == other);
- }
-
- reference operator*() const noexcept
- {
- return *_mCurrVal;
- }
-
- pointer operator->() const noexcept
- {
- return &(*_mCurrVal);
- }
-
-private:
- void _updateCurrentValue() noexcept
- {
- if (_mIdx < _mContainer.length()) {
- _mCurrVal = _mContainer[_mIdx];
- } else {
- _mCurrVal = nonstd::nullopt;
- }
- }
-
- nonstd::optional<value_type> _mCurrVal;
- ContainerT _mContainer;
- uint64_t _mIdx;
-};
-
-} /* namespace bt2 */
-
-#endif /* BABELTRACE_CPP_COMMON_BT2_COMMON_ITERATOR_HPP */
#include "cpp-common/optional.hpp"
#include "cpp-common/string_view.hpp"
+#include "borrowed-object-iterator.hpp"
#include "borrowed-object.hpp"
-#include "common-iterator.hpp"
#include "exc.hpp"
#include "field-path.hpp"
#include "integer-range-set.hpp"
public:
using Shared = SharedFieldClass<_ThisCommonEnumerationFieldClass, LibObjT>;
- using Iterator = CommonIterator<CommonEnumerationFieldClass, MappingT>;
+ using Iterator = BorrowedObjectIterator<CommonEnumerationFieldClass>;
using Mapping = MappingT;
explicit CommonEnumerationFieldClass(const _LibObjPtr libObjPtr) noexcept :
public:
using Shared = SharedFieldClass<CommonStructureFieldClass<LibObjT>, LibObjT>;
+ using Iterator = BorrowedObjectIterator<CommonStructureFieldClass<LibObjT>>;
using Member =
internal::DepType<LibObjT, StructureFieldClassMember, ConstStructureFieldClassMember>;
- using Iterator = CommonIterator<CommonStructureFieldClass<LibObjT>, Member>;
-
explicit CommonStructureFieldClass(const _LibObjPtr libObjPtr) noexcept :
_ThisCommonFieldClass {libObjPtr}
{
public:
using Shared = SharedFieldClass<CommonVariantFieldClass<LibObjT>, LibObjT>;
+ using Iterator = BorrowedObjectIterator<CommonVariantFieldClass>;
using Option =
internal::DepType<LibObjT, VariantFieldClassOption, ConstVariantFieldClassOption>;
- using Iterator = CommonIterator<CommonVariantFieldClass, Option>;
-
explicit CommonVariantFieldClass(const _LibObjPtr libObjPtr) noexcept :
_ThisCommonFieldClass {libObjPtr}
{
using Shared = SharedFieldClass<_ThisCommonVariantWithIntegerSelectorFieldClass, LibObjT>;
using Option = OptionT;
+
using Iterator =
- CommonIterator<CommonVariantWithIntegerSelectorFieldClass<LibObjT, Option>, Option>;
+ BorrowedObjectIterator<CommonVariantWithIntegerSelectorFieldClass<LibObjT, Option>>;
explicit CommonVariantWithIntegerSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
_ThisCommonVariantWithSelectorFieldClass {libObjPtr}
#include "common/assert.h"
+#include "borrowed-object-iterator.hpp"
#include "borrowed-object.hpp"
-#include "common-iterator.hpp"
#include "shared-object.hpp"
namespace bt2 {
{
public:
using Shared = SharedObject<ConstFieldPath, const bt_field_path, internal::FieldPathRefFuncs>;
-
- using Iterator = CommonIterator<ConstFieldPath, ConstFieldPathItem>;
+ using Iterator = BorrowedObjectIterator<ConstFieldPath>;
enum class Scope
{
#include <babeltrace2/babeltrace.h>
+#include "borrowed-object-iterator.hpp"
#include "borrowed-object.hpp"
-#include "common-iterator.hpp"
#include "exc.hpp"
#include "integer-range.hpp"
#include "internal/utils.hpp"
ConstUnsignedIntegerRange, ConstSignedIntegerRange>::type;
using Value = typename Range::Value;
- using Iterator = CommonIterator<CommonIntegerRangeSet, Range>;
+ using Iterator = BorrowedObjectIterator<CommonIntegerRangeSet>;
explicit CommonIntegerRangeSet(const _LibObjPtr libObjPtr) noexcept :
_ThisBorrowedObject {libObjPtr}
#include "cpp-common/optional.hpp"
#include "cpp-common/string_view.hpp"
+#include "borrowed-object-iterator.hpp"
#include "borrowed-object.hpp"
-#include "common-iterator.hpp"
#include "exc.hpp"
#include "internal/utils.hpp"
#include "shared-object.hpp"
public:
using Shared = SharedValue<CommonArrayValue<LibObjT>, LibObjT>;
- using Iterator = CommonIterator<CommonArrayValue<LibObjT>, CommonValue<LibObjT>>;
+ using Iterator = BorrowedObjectIterator<CommonArrayValue<LibObjT>>;
explicit CommonArrayValue(const _LibObjPtr libObjPtr) noexcept : _ThisCommonValue {libObjPtr}
{