#include "common/assert.h"
#include "common/common.h"
-#include "cpp-common/optional.hpp"
-#include "cpp-common/string_view.hpp"
+#include "cpp-common/bt2s/optional.hpp"
+#include "borrowed-object-iterator.hpp"
#include "borrowed-object.hpp"
-#include "common-iterator.hpp"
#include "exc.hpp"
#include "internal/utils.hpp"
+#include "raw-value-proxy.hpp"
#include "shared-object.hpp"
namespace bt2 {
MAP = BT_VALUE_TYPE_MAP,
};
+template <typename ValueObjT>
+class CommonValueRawValueProxy final
+{
+public:
+ explicit CommonValueRawValueProxy(const ValueObjT obj) : _mObj {obj}
+ {
+ }
+
+ CommonValueRawValueProxy& operator=(bool rawVal) noexcept;
+ CommonValueRawValueProxy& operator=(std::int64_t rawVal) noexcept;
+ CommonValueRawValueProxy& operator=(std::uint64_t rawVal) noexcept;
+ CommonValueRawValueProxy& operator=(double rawVal) noexcept;
+ CommonValueRawValueProxy& operator=(const char *rawVal);
+ CommonValueRawValueProxy& operator=(const std::string& rawVal);
+ operator bool() const noexcept;
+ operator std::int64_t() const noexcept;
+ operator std::uint64_t() const noexcept;
+ operator double() const noexcept;
+ operator const char *() const noexcept;
+
+private:
+ ValueObjT _mObj;
+};
+
template <typename LibObjT>
class CommonValue : public BorrowedObject<LibObjT>
{
}
template <typename OtherLibObjT>
- _ThisCommonValue& operator=(const CommonValue<OtherLibObjT> val) noexcept
+ _ThisCommonValue operator=(const CommonValue<OtherLibObjT> val) noexcept
{
_ThisBorrowedObject::operator=(val);
return *this;
}
+ CommonValue<const bt_value> asConst() const noexcept
+ {
+ return CommonValue<const bt_value> {*this};
+ }
+
ValueType type() const noexcept
{
return static_cast<ValueType>(bt_value_get_type(this->libObjPtr()));
return !(*this == other);
}
+ CommonValueRawValueProxy<CommonValue> operator*() const noexcept
+ {
+ return CommonValueRawValueProxy<CommonValue> {*this};
+ }
+
+ std::uint64_t arrayLength() const noexcept
+ {
+ return this->asArray().length();
+ }
+
+ bool arrayIsEmpty() const noexcept
+ {
+ return this->asArray().isEmpty();
+ }
+
+ CommonValue<LibObjT> operator[](const std::uint64_t index) const noexcept
+ {
+ return this->asArray()[index];
+ }
+
+ template <typename T>
+ void append(T&& elem) const
+ {
+ this->asArray().append(std::forward<T>(elem));
+ }
+
+ CommonArrayValue<bt_value> appendEmptyArray() const;
+ CommonMapValue<bt_value> appendEmptyMap() const;
+
+ std::uint64_t mapLength() const noexcept
+ {
+ return this->asMap().length();
+ }
+
+ bool mapIsEmpty() const noexcept
+ {
+ return this->asMap().isEmpty();
+ }
+
+ template <typename KeyT>
+ bt2s::optional<CommonValue<LibObjT>> operator[](KeyT&& key) const noexcept
+ {
+ return this->asMap()[std::forward<KeyT>(key)];
+ }
+
+ template <typename KeyT>
+ bool hasEntry(KeyT&& key) const noexcept
+ {
+ return this->asMap().hasEntry(std::forward<KeyT>(key));
+ }
+
+ template <typename KeyT, typename ValT>
+ void insert(KeyT&& key, ValT&& val) const
+ {
+ this->asMap().insert(std::forward<KeyT>(key), std::forward<ValT>(val));
+ }
+
+ CommonArrayValue<bt_value> insertEmptyArray(const char *key) const;
+ CommonArrayValue<bt_value> insertEmptyArray(const std::string& key) const;
+ CommonMapValue<bt_value> insertEmptyMap(const char *key) const;
+ CommonMapValue<bt_value> insertEmptyMap(const std::string& key) const;
+
Shared shared() const noexcept
{
return Shared::createWithRef(*this);
using Value = CommonValue<bt_value>;
using ConstValue = CommonValue<const bt_value>;
+template <typename ValueObjT>
+CommonValueRawValueProxy<ValueObjT>&
+CommonValueRawValueProxy<ValueObjT>::operator=(const bool rawVal) noexcept
+{
+ _mObj.asBool().value(rawVal);
+ return *this;
+}
+
+template <typename ValueObjT>
+CommonValueRawValueProxy<ValueObjT>&
+CommonValueRawValueProxy<ValueObjT>::operator=(const std::int64_t rawVal) noexcept
+{
+ _mObj.asSignedInteger().value(rawVal);
+ return *this;
+}
+
+template <typename ValueObjT>
+CommonValueRawValueProxy<ValueObjT>&
+CommonValueRawValueProxy<ValueObjT>::operator=(const std::uint64_t rawVal) noexcept
+{
+ _mObj.asUnsignedInteger().value(rawVal);
+ return *this;
+}
+
+template <typename ValueObjT>
+CommonValueRawValueProxy<ValueObjT>&
+CommonValueRawValueProxy<ValueObjT>::operator=(const double rawVal) noexcept
+{
+ _mObj.asReal().value(rawVal);
+ return *this;
+}
+
+template <typename ValueObjT>
+CommonValueRawValueProxy<ValueObjT>&
+CommonValueRawValueProxy<ValueObjT>::operator=(const char * const rawVal)
+{
+ _mObj.asString().value(rawVal);
+ return *this;
+}
+
+template <typename ValueObjT>
+CommonValueRawValueProxy<ValueObjT>&
+CommonValueRawValueProxy<ValueObjT>::operator=(const std::string& rawVal)
+{
+ return *this = rawVal.data();
+}
+
+template <typename ValueObjT>
+CommonValueRawValueProxy<ValueObjT>::operator bool() const noexcept
+{
+ return _mObj.asBool().value();
+}
+
+template <typename ValueObjT>
+CommonValueRawValueProxy<ValueObjT>::operator std::int64_t() const noexcept
+{
+ return _mObj.asSignedInteger().value();
+}
+
+template <typename ValueObjT>
+CommonValueRawValueProxy<ValueObjT>::operator std::uint64_t() const noexcept
+{
+ return _mObj.asUnsignedInteger().value();
+}
+
+template <typename ValueObjT>
+CommonValueRawValueProxy<ValueObjT>::operator double() const noexcept
+{
+ return _mObj.asReal().value();
+}
+
+template <typename ValueObjT>
+CommonValueRawValueProxy<ValueObjT>::operator const char *() const noexcept
+{
+ return _mObj.asString().value();
+}
+
namespace internal {
struct ValueTypeDescr
}
template <typename OtherLibObjT>
- CommonNullValue<LibObjT>& operator=(const CommonNullValue<OtherLibObjT> val) noexcept
+ CommonNullValue<LibObjT> operator=(const CommonNullValue<OtherLibObjT> val) noexcept
{
_ThisCommonValue::operator=(val);
return *this;
}
+ CommonNullValue<const bt_value> asConst() const noexcept
+ {
+ return CommonNullValue<const bt_value> {*this};
+ }
+
Shared shared() const noexcept
{
return Shared::createWithRef(*this);
}
template <typename OtherLibObjT>
- CommonBoolValue<LibObjT>& operator=(const CommonBoolValue<OtherLibObjT> val) noexcept
+ CommonBoolValue<LibObjT> operator=(const CommonBoolValue<OtherLibObjT> val) noexcept
{
_ThisCommonValue::operator=(val);
return *this;
}
- CommonBoolValue<LibObjT> operator=(const Value rawVal) const noexcept
+ CommonBoolValue<const bt_value> asConst() const noexcept
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ return CommonBoolValue<const bt_value> {*this};
+ }
- bt_value_bool_set(this->libObjPtr(), static_cast<bt_bool>(rawVal));
- return *this;
+ RawValueProxy<CommonBoolValue> operator*() const noexcept
+ {
+ return RawValueProxy<CommonBoolValue> {*this};
}
Value value() const noexcept
return static_cast<Value>(bt_value_bool_get(this->libObjPtr()));
}
- operator Value() const noexcept
+ void value(const Value val) const noexcept
{
- return this->value();
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstBoolValue`.");
+
+ bt_value_bool_set(this->libObjPtr(), static_cast<bt_bool>(val));
}
Shared shared() const noexcept
}
template <typename OtherLibObjT>
- CommonUnsignedIntegerValue<LibObjT>&
+ CommonUnsignedIntegerValue<LibObjT>
operator=(const CommonUnsignedIntegerValue<OtherLibObjT> val) noexcept
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
-
_ThisCommonValue::operator=(val);
return *this;
}
- CommonUnsignedIntegerValue<LibObjT> operator=(const Value rawVal) const noexcept
+ CommonUnsignedIntegerValue<const bt_value> asConst() const noexcept
{
- bt_value_integer_unsigned_set(this->libObjPtr(), rawVal);
- return *this;
+ return CommonUnsignedIntegerValue<const bt_value> {*this};
}
- Value value() const noexcept
+ RawValueProxy<CommonUnsignedIntegerValue> operator*() const noexcept
{
- return bt_value_integer_unsigned_get(this->libObjPtr());
+ return RawValueProxy<CommonUnsignedIntegerValue> {*this};
}
- operator Value() const noexcept
+ void value(const Value val) const noexcept
{
- return this->value();
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstUnsignedIntegerValue`.");
+
+ bt_value_integer_unsigned_set(this->libObjPtr(), val);
+ }
+
+ Value value() const noexcept
+ {
+ return bt_value_integer_unsigned_get(this->libObjPtr());
}
Shared shared() const noexcept
return *this;
}
- CommonSignedIntegerValue<LibObjT> operator=(const Value rawVal) const noexcept
+ CommonSignedIntegerValue<const bt_value> asConst() const noexcept
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ return CommonSignedIntegerValue<const bt_value> {*this};
+ }
- bt_value_integer_signed_set(this->libObjPtr(), rawVal);
- return *this;
+ RawValueProxy<CommonSignedIntegerValue> operator*() const noexcept
+ {
+ return RawValueProxy<CommonSignedIntegerValue> {*this};
}
- Value value() const noexcept
+ void value(const Value val) const noexcept
{
- return bt_value_integer_signed_get(this->libObjPtr());
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstSignedIntegerValue`.");
+
+ bt_value_integer_signed_set(this->libObjPtr(), val);
}
- operator Value() const noexcept
+ Value value() const noexcept
{
- return this->value();
+ return bt_value_integer_signed_get(this->libObjPtr());
}
Shared shared() const noexcept
}
template <typename OtherLibObjT>
- CommonRealValue<LibObjT>& operator=(const CommonRealValue<OtherLibObjT> val) noexcept
+ CommonRealValue<LibObjT> operator=(const CommonRealValue<OtherLibObjT> val) noexcept
{
_ThisCommonValue::operator=(val);
return *this;
}
- CommonRealValue<LibObjT> operator=(const Value rawVal) const noexcept
+ CommonRealValue<const bt_value> asConst() const noexcept
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ return CommonRealValue<const bt_value> {*this};
+ }
- bt_value_real_set(this->libObjPtr(), rawVal);
- return *this;
+ RawValueProxy<CommonRealValue> operator*() const noexcept
+ {
+ return RawValueProxy<CommonRealValue> {*this};
}
- Value value() const noexcept
+ void value(const Value val) const noexcept
{
- return bt_value_real_get(this->libObjPtr());
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstRealValue`.");
+
+ bt_value_real_set(this->libObjPtr(), val);
}
- operator Value() const noexcept
+ Value value() const noexcept
{
- return this->value();
+ return bt_value_real_get(this->libObjPtr());
}
Shared shared() const noexcept
public:
using Shared = SharedValue<CommonStringValue<LibObjT>, LibObjT>;
+ using Value = const char *;
explicit CommonStringValue(const _LibObjPtr libObjPtr) noexcept : _ThisCommonValue {libObjPtr}
{
}
template <typename OtherLibObjT>
- CommonStringValue<LibObjT>& operator=(const CommonStringValue<OtherLibObjT> val) noexcept
+ CommonStringValue<LibObjT> operator=(const CommonStringValue<OtherLibObjT> val) noexcept
{
_ThisCommonValue::operator=(val);
return *this;
}
- CommonStringValue<LibObjT> operator=(const char * const rawVal) const
+ CommonStringValue<const bt_value> asConst() const noexcept
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ return CommonStringValue<const bt_value> {*this};
+ }
+
+ RawStringValueProxy<CommonStringValue> operator*() const noexcept
+ {
+ return RawStringValueProxy<CommonStringValue> {*this};
+ }
+
+ void value(const Value val) const
+ {
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstStringValue`.");
- const auto status = bt_value_string_set(this->libObjPtr(), rawVal);
+ const auto status = bt_value_string_set(this->libObjPtr(), val);
if (status == BT_VALUE_STRING_SET_STATUS_MEMORY_ERROR) {
throw MemoryError {};
}
-
- return *this;
}
- CommonStringValue<LibObjT> operator=(const std::string& rawVal) const noexcept
+ void value(const std::string& val) const
{
- return *this = rawVal.data();
+ this->value(val.data());
}
- bpstd::string_view value() const noexcept
+ const char *value() const noexcept
{
return bt_value_string_get(this->libObjPtr());
}
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}
{
}
template <typename OtherLibObjT>
- CommonArrayValue<LibObjT>& operator=(const CommonArrayValue<OtherLibObjT> val) noexcept
+ CommonArrayValue<LibObjT> operator=(const CommonArrayValue<OtherLibObjT> val) noexcept
{
_ThisCommonValue::operator=(val);
return *this;
}
+ CommonArrayValue<const bt_value> asConst() const noexcept
+ {
+ return CommonArrayValue<const bt_value> {*this};
+ }
+
std::uint64_t length() const noexcept
{
return bt_value_array_get_length(this->libObjPtr());
void append(const Value val) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstArrayValue`.");
const auto status = bt_value_array_append_element(this->libObjPtr(), val.libObjPtr());
void append(const bool rawVal) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstArrayValue`.");
const auto status =
bt_value_array_append_bool_element(this->libObjPtr(), static_cast<bt_bool>(rawVal));
void append(const std::uint64_t rawVal) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstArrayValue`.");
const auto status =
bt_value_array_append_unsigned_integer_element(this->libObjPtr(), rawVal);
void append(const std::int64_t rawVal) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstArrayValue`.");
const auto status = bt_value_array_append_signed_integer_element(this->libObjPtr(), rawVal);
void append(const double rawVal) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstArrayValue`.");
const auto status = bt_value_array_append_real_element(this->libObjPtr(), rawVal);
void append(const char * const rawVal) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstArrayValue`.");
const auto status = bt_value_array_append_string_element(this->libObjPtr(), rawVal);
* First argument is the entry's key, second is its value.
*/
template <typename ObjT>
-using CommonMapValueForEachUserFunc = std::function<void(const bpstd::string_view&, ObjT)>;
+using CommonMapValueForEachUserFunc = std::function<void(const char *, ObjT)>;
/*
* Template of a function to be passed to bt_value_map_foreach_entry()
}
template <typename OtherLibObjT>
- CommonMapValue<LibObjT>& operator=(const CommonMapValue<OtherLibObjT> val) noexcept
+ CommonMapValue<LibObjT> operator=(const CommonMapValue<OtherLibObjT> val) noexcept
{
_ThisCommonValue::operator=(val);
return *this;
}
+ CommonMapValue<const bt_value> asConst() const noexcept
+ {
+ return CommonMapValue<const bt_value> {*this};
+ }
+
std::uint64_t length() const noexcept
{
return bt_value_map_get_size(this->libObjPtr());
return this->length() == 0;
}
- nonstd::optional<CommonValue<LibObjT>> operator[](const char * const key) const noexcept
+ bt2s::optional<CommonValue<LibObjT>> operator[](const char * const key) const noexcept
{
const auto libObjPtr =
internal::CommonMapValueSpec<LibObjT>::entryByKey(this->libObjPtr(), key);
if (!libObjPtr) {
- return nonstd::nullopt;
+ return bt2s::nullopt;
}
return CommonValue<LibObjT> {libObjPtr};
}
- nonstd::optional<CommonValue<LibObjT>> operator[](const std::string& key) const noexcept
+ bt2s::optional<CommonValue<LibObjT>> operator[](const std::string& key) const noexcept
{
return (*this)[key.data()];
}
void insert(const char * const key, const Value val) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstMapValue`.");
const auto status = bt_value_map_insert_entry(this->libObjPtr(), key, val.libObjPtr());
void insert(const char * const key, const bool rawVal) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstMapValue`.");
const auto status =
bt_value_map_insert_bool_entry(this->libObjPtr(), key, static_cast<bt_bool>(rawVal));
void insert(const char * const key, const std::uint64_t rawVal) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstMapValue`.");
const auto status =
bt_value_map_insert_unsigned_integer_entry(this->libObjPtr(), key, rawVal);
void insert(const char * const key, const std::int64_t rawVal) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstMapValue`.");
const auto status =
bt_value_map_insert_signed_integer_entry(this->libObjPtr(), key, rawVal);
void insert(const char * const key, const double rawVal) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstMapValue`.");
const auto status = bt_value_map_insert_real_entry(this->libObjPtr(), key, rawVal);
void insert(const char * const key, const char * const rawVal) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstMapValue`.");
const auto status = bt_value_map_insert_string_entry(this->libObjPtr(), key, rawVal);
} /* namespace internal */
+template <typename LibObjT>
+ArrayValue CommonValue<LibObjT>::appendEmptyArray() const
+{
+ return this->asArray().appendEmptyArray();
+}
+
+template <typename LibObjT>
+MapValue CommonValue<LibObjT>::appendEmptyMap() const
+{
+ return this->asArray().appendEmptyMap();
+}
+
+template <typename LibObjT>
+ArrayValue CommonValue<LibObjT>::insertEmptyArray(const char * const key) const
+{
+ return this->asMap().insertEmptyArray(key);
+}
+
+template <typename LibObjT>
+ArrayValue CommonValue<LibObjT>::insertEmptyArray(const std::string& key) const
+{
+ return this->asMap().insertEmptyArray(key);
+}
+
+template <typename LibObjT>
+MapValue CommonValue<LibObjT>::insertEmptyMap(const char * const key) const
+{
+ return this->asMap().insertEmptyMap(key);
+}
+
+template <typename LibObjT>
+MapValue CommonValue<LibObjT>::insertEmptyMap(const std::string& key) const
+{
+ return this->asMap().insertEmptyMap(key);
+}
+
template <typename LibObjT>
CommonNullValue<LibObjT> CommonValue<LibObjT>::asNull() const noexcept
{
template <typename LibObjT>
ArrayValue CommonArrayValue<LibObjT>::appendEmptyArray() const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstArrayValue`.");
bt_value *libElemPtr;
const auto status = bt_value_array_append_empty_array_element(this->libObjPtr(), &libElemPtr);
template <typename LibObjT>
MapValue CommonArrayValue<LibObjT>::appendEmptyMap() const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstArrayValue`.");
bt_value *libElemPtr;
const auto status = bt_value_array_append_empty_map_element(this->libObjPtr(), &libElemPtr);
template <typename LibObjT>
ArrayValue CommonMapValue<LibObjT>::insertEmptyArray(const char * const key) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstMapValue`.");
bt_value *libEntryPtr;
const auto status = bt_value_map_insert_empty_array_entry(this->libObjPtr(), key, &libEntryPtr);
template <typename LibObjT>
MapValue CommonMapValue<LibObjT>::insertEmptyMap(const char * const key) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstMapValue`.");
bt_value *libEntryPtr;
const auto status = bt_value_map_insert_empty_map_entry(this->libObjPtr(), key, &libEntryPtr);