enum class ValueType
{
- NUL = BT_VALUE_TYPE_NULL,
- BOOL = BT_VALUE_TYPE_BOOL,
- UNSIGNED_INTEGER = BT_VALUE_TYPE_UNSIGNED_INTEGER,
- SIGNED_INTEGER = BT_VALUE_TYPE_SIGNED_INTEGER,
- REAL = BT_VALUE_TYPE_REAL,
- STRING = BT_VALUE_TYPE_STRING,
- ARRAY = BT_VALUE_TYPE_ARRAY,
- MAP = BT_VALUE_TYPE_MAP,
+ Null = BT_VALUE_TYPE_NULL,
+ Bool = BT_VALUE_TYPE_BOOL,
+ UnsignedInteger = BT_VALUE_TYPE_UNSIGNED_INTEGER,
+ SignedInteger = BT_VALUE_TYPE_SIGNED_INTEGER,
+ Real = BT_VALUE_TYPE_REAL,
+ String = BT_VALUE_TYPE_STRING,
+ Array = BT_VALUE_TYPE_ARRAY,
+ Map = BT_VALUE_TYPE_MAP,
};
template <typename ValueObjT>
return static_cast<Value>(bt_value_bool_get(this->libObjPtr()));
}
- void value(const Value val) const noexcept
+ CommonBoolValue value(const Value val) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstBoolValue`.");
bt_value_bool_set(this->libObjPtr(), static_cast<bt_bool>(val));
+ return *this;
}
Shared shared() const noexcept
return RawValueProxy<CommonUnsignedIntegerValue> {*this};
}
- void value(const Value val) const noexcept
+ CommonUnsignedIntegerValue value(const Value val) const noexcept
{
static_assert(!std::is_const<LibObjT>::value,
"Not available with `bt2::ConstUnsignedIntegerValue`.");
bt_value_integer_unsigned_set(this->libObjPtr(), val);
+ return *this;
}
Value value() const noexcept
return RawValueProxy<CommonSignedIntegerValue> {*this};
}
- void value(const Value val) const noexcept
+ CommonSignedIntegerValue value(const Value val) const noexcept
{
static_assert(!std::is_const<LibObjT>::value,
"Not available with `bt2::ConstSignedIntegerValue`.");
bt_value_integer_signed_set(this->libObjPtr(), val);
+ return *this;
}
Value value() const noexcept
return RawValueProxy<CommonRealValue> {*this};
}
- void value(const Value val) const noexcept
+ CommonRealValue value(const Value val) const noexcept
{
static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstRealValue`.");
bt_value_real_set(this->libObjPtr(), val);
+ return *this;
}
Value value() const noexcept
return RawValueProxy<CommonStringValue> {*this};
}
- void value(const Value val) const
+ CommonStringValue value(const Value val) const
{
static_assert(!std::is_const<LibObjT>::value,
"Not available with `bt2::ConstStringValue`.");
if (status == BT_VALUE_STRING_SET_STATUS_MEMORY_ERROR) {
throw MemoryError {};
}
+
+ return *this;
}
Value value() const noexcept
internal::CommonArrayValueSpec<LibObjT>::elementByIndex(this->libObjPtr(), index)};
}
- void append(const Value val) const
+ CommonArrayValue append(const Value val) 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());
this->_handleAppendLibStatus(status);
+ return *this;
}
- void append(const bool rawVal) const
+ CommonArrayValue append(const bool rawVal) const
{
static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstArrayValue`.");
bt_value_array_append_bool_element(this->libObjPtr(), static_cast<bt_bool>(rawVal));
this->_handleAppendLibStatus(status);
+ return *this;
}
- void append(const std::uint64_t rawVal) const
+ CommonArrayValue append(const std::uint64_t rawVal) const
{
static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstArrayValue`.");
bt_value_array_append_unsigned_integer_element(this->libObjPtr(), rawVal);
this->_handleAppendLibStatus(status);
+ return *this;
}
- void append(const std::int64_t rawVal) const
+ CommonArrayValue append(const std::int64_t rawVal) 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);
this->_handleAppendLibStatus(status);
+ return *this;
}
- void append(const double rawVal) const
+ CommonArrayValue append(const double rawVal) 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);
this->_handleAppendLibStatus(status);
+ return *this;
}
- void append(const char * const rawVal) const
+ CommonArrayValue append(const char * const rawVal) 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);
this->_handleAppendLibStatus(status);
+ return *this;
}
- void append(const bt2c::CStringView rawVal) const
+ CommonArrayValue append(const bt2c::CStringView rawVal) const
{
- this->append(rawVal.data());
+ return this->append(rawVal.data());
}
CommonArrayValue<bt_value> appendEmptyArray() const;
return static_cast<bool>(bt_value_map_has_entry(this->libObjPtr(), key));
}
- void insert(const bt2c::CStringView key, const Value val) const
+ CommonMapValue insert(const bt2c::CStringView key, const Value val) 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());
this->_handleInsertLibStatus(status);
+ return *this;
}
- void insert(const bt2c::CStringView key, const bool rawVal) const
+ CommonMapValue insert(const bt2c::CStringView key, const bool rawVal) const
{
static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstMapValue`.");
bt_value_map_insert_bool_entry(this->libObjPtr(), key, static_cast<bt_bool>(rawVal));
this->_handleInsertLibStatus(status);
+ return *this;
}
- void insert(const bt2c::CStringView key, const std::uint64_t rawVal) const
+ CommonMapValue insert(const bt2c::CStringView key, const std::uint64_t rawVal) const
{
static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstMapValue`.");
bt_value_map_insert_unsigned_integer_entry(this->libObjPtr(), key, rawVal);
this->_handleInsertLibStatus(status);
+ return *this;
}
- void insert(const bt2c::CStringView key, const std::int64_t rawVal) const
+
+ CommonMapValue insert(const bt2c::CStringView key, const std::int64_t rawVal) const
{
static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstMapValue`.");
bt_value_map_insert_signed_integer_entry(this->libObjPtr(), key, rawVal);
this->_handleInsertLibStatus(status);
+ return *this;
}
- void insert(const bt2c::CStringView key, const double rawVal) const
+ CommonMapValue insert(const bt2c::CStringView key, const double rawVal) 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);
this->_handleInsertLibStatus(status);
+ return *this;
}
- void insert(const bt2c::CStringView key, const char *rawVal) const
+ CommonMapValue insert(const bt2c::CStringView key, const char *rawVal) 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);
this->_handleInsertLibStatus(status);
+ return *this;
}
- void insert(const bt2c::CStringView key, const bt2c::CStringView rawVal) const
+ CommonMapValue insert(const bt2c::CStringView key, const bt2c::CStringView rawVal) const
{
return this->insert(key, rawVal.data());
}
CommonArrayValue<bt_value> insertEmptyArray(bt2c::CStringView key) const;
CommonMapValue<bt_value> insertEmptyMap(bt2c::CStringView key) const;
- void forEach(const internal::CommonMapValueForEachUserFunc<CommonValue<LibObjT>>& func) const
+ CommonMapValue
+ forEach(const internal::CommonMapValueForEachUserFunc<CommonValue<LibObjT>>& func) const
{
internal::CommonMapValueSpec<LibObjT>::forEach(this->libObjPtr(), func);
+ return *this;
}
Shared shared() const noexcept
CommonNullValue<LibObjT> CommonValue<LibObjT>::asNull() const noexcept
{
BT_ASSERT_DBG(this->isNull());
- return CommonNullValue<LibObjT> {this->libObjPtr()};
+ return CommonNullValue<LibObjT> {};
}
template <typename LibObjT>
CommonBoolValue<LibObjT> CommonValue<LibObjT>::asBool() const noexcept
{
- BT_ASSERT_DBG(this->isBool());
return CommonBoolValue<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonSignedIntegerValue<LibObjT> CommonValue<LibObjT>::asSignedInteger() const noexcept
{
- BT_ASSERT_DBG(this->isSignedInteger());
return CommonSignedIntegerValue<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonUnsignedIntegerValue<LibObjT> CommonValue<LibObjT>::asUnsignedInteger() const noexcept
{
- BT_ASSERT_DBG(this->isUnsignedInteger());
return CommonUnsignedIntegerValue<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonRealValue<LibObjT> CommonValue<LibObjT>::asReal() const noexcept
{
- BT_ASSERT_DBG(this->isReal());
return CommonRealValue<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonStringValue<LibObjT> CommonValue<LibObjT>::asString() const noexcept
{
- BT_ASSERT_DBG(this->isString());
return CommonStringValue<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonArrayValue<LibObjT> CommonValue<LibObjT>::asArray() const noexcept
{
- BT_ASSERT_DBG(this->isArray());
return CommonArrayValue<LibObjT> {this->libObjPtr()};
}
template <typename LibObjT>
CommonMapValue<LibObjT> CommonValue<LibObjT>::asMap() const noexcept
{
- BT_ASSERT_DBG(this->isMap());
return CommonMapValue<LibObjT> {this->libObjPtr()};
}