}
template <typename OtherLibObjT>
- CommonClockClass(const CommonClockClass<OtherLibObjT>& clkClass) noexcept :
+ CommonClockClass(const CommonClockClass<OtherLibObjT> clkClass) noexcept :
_ThisBorrowedObj {clkClass}
{
}
template <typename OtherLibObjT>
- _ThisCommonClockClass& operator=(const CommonClockClass<OtherLibObjT>& clkClass) noexcept
+ _ThisCommonClockClass& operator=(const CommonClockClass<OtherLibObjT> clkClass) noexcept
{
_ThisBorrowedObj::operator=(clkClass);
return *this;
}
template <typename LibValT>
- void userAttributes(const CommonMapValue<LibValT>& userAttrs)
+ void userAttributes(const CommonMapValue<LibValT> userAttrs)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
template <typename OtherLibObjT>
- CommonFieldClass(const CommonFieldClass<OtherLibObjT>& fc) noexcept : _ThisBorrowedObj {fc}
+ CommonFieldClass(const CommonFieldClass<OtherLibObjT> fc) noexcept : _ThisBorrowedObj {fc}
{
}
template <typename OtherLibObjT>
- CommonFieldClass& operator=(const CommonFieldClass<OtherLibObjT>& fc) noexcept
+ CommonFieldClass& operator=(const CommonFieldClass<OtherLibObjT> fc) noexcept
{
_ThisBorrowedObj::operator=(fc);
return *this;
asVariantWithSignedIntegerSelector() const noexcept;
template <typename LibValT>
- void userAttributes(const CommonMapValue<LibValT>& userAttrs)
+ void userAttributes(const CommonMapValue<LibValT> userAttrs)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
template <typename OtherLibObjT>
- CommonBitArrayFieldClass(const CommonBitArrayFieldClass<OtherLibObjT>& fc) noexcept :
+ CommonBitArrayFieldClass(const CommonBitArrayFieldClass<OtherLibObjT> fc) noexcept :
_ThisCommonFieldClass {fc}
{
}
template <typename OtherLibObjT>
CommonBitArrayFieldClass<LibObjT>&
- operator=(const CommonBitArrayFieldClass<OtherLibObjT>& fc) noexcept
+ operator=(const CommonBitArrayFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonFieldClass::operator=(fc);
return *this;
}
template <typename OtherLibObjT>
- CommonIntegerFieldClass(const CommonIntegerFieldClass<OtherLibObjT>& fc) noexcept :
+ CommonIntegerFieldClass(const CommonIntegerFieldClass<OtherLibObjT> fc) noexcept :
_ThisCommonFieldClass {fc}
{
}
template <typename OtherLibObjT>
- CommonIntegerFieldClass& operator=(const CommonIntegerFieldClass<OtherLibObjT>& fc) noexcept
+ CommonIntegerFieldClass& operator=(const CommonIntegerFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonFieldClass::operator=(fc);
return *this;
}
template <typename OtherLibObjT>
- CommonBaseEnumerationFieldClass(
- const CommonBaseEnumerationFieldClass<OtherLibObjT>& fc) noexcept :
+ CommonBaseEnumerationFieldClass(const CommonBaseEnumerationFieldClass<OtherLibObjT> fc) noexcept
+ :
_ThisCommonIntegerFieldClass {fc}
{
}
template <typename OtherLibObjT>
CommonBaseEnumerationFieldClass&
- operator=(const CommonBaseEnumerationFieldClass<OtherLibObjT>& fc) noexcept
+ operator=(const CommonBaseEnumerationFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonIntegerFieldClass::operator=(fc);
return *this;
template <typename OtherLibObjT>
CommonEnumerationFieldClass(
- const CommonEnumerationFieldClass<OtherLibObjT, MappingT>& fc) noexcept :
+ const CommonEnumerationFieldClass<OtherLibObjT, MappingT> fc) noexcept :
_ThisCommonEnumerationFieldClass {fc}
{
}
template <typename OtherLibObjT>
CommonEnumerationFieldClass&
- operator=(const CommonEnumerationFieldClass<OtherLibObjT, MappingT>& fc) noexcept
+ operator=(const CommonEnumerationFieldClass<OtherLibObjT, MappingT> fc) noexcept
{
_ThisCommonEnumerationFieldClass::operator=(fc);
return *this;
}
template <typename OtherLibObjT>
- CommonStructureFieldClassMember(
- const CommonStructureFieldClassMember<OtherLibObjT>& fc) noexcept :
+ CommonStructureFieldClassMember(const CommonStructureFieldClassMember<OtherLibObjT> fc) noexcept
+ :
_ThisBorrowedObj {fc}
{
}
template <typename OtherLibObjT>
CommonStructureFieldClassMember<LibObjT>&
- operator=(const CommonStructureFieldClassMember<OtherLibObjT>& fc) noexcept
+ operator=(const CommonStructureFieldClassMember<OtherLibObjT> fc) noexcept
{
_ThisBorrowedObj::operator=(fc);
return *this;
}
template <typename LibValT>
- void userAttributes(const CommonMapValue<LibValT>& userAttrs)
+ void userAttributes(const CommonMapValue<LibValT> userAttrs)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
template <typename OtherLibObjT>
- CommonStructureFieldClass(const CommonStructureFieldClass<OtherLibObjT>& fc) noexcept :
+ CommonStructureFieldClass(const CommonStructureFieldClass<OtherLibObjT> fc) noexcept :
_ThisCommonFieldClass {fc}
{
}
template <typename OtherLibObjT>
- CommonStructureFieldClass& operator=(const CommonStructureFieldClass<OtherLibObjT>& fc) noexcept
+ CommonStructureFieldClass& operator=(const CommonStructureFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonFieldClass::operator=(fc);
return *this;
}
- void appendMember(const char * const name, const FieldClass& fc)
+ void appendMember(const char * const name, const FieldClass fc)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
}
- void appendMember(const std::string& name, const FieldClass& fc)
+ void appendMember(const std::string& name, const FieldClass fc)
{
this->appendMember(name.data(), fc);
}
}
template <typename OtherLibObjT>
- CommonArrayFieldClass(const CommonArrayFieldClass<OtherLibObjT>& fc) noexcept :
+ CommonArrayFieldClass(const CommonArrayFieldClass<OtherLibObjT> fc) noexcept :
_ThisCommonFieldClass {fc}
{
}
template <typename OtherLibObjT>
- CommonArrayFieldClass& operator=(const CommonArrayFieldClass<OtherLibObjT>& fc) noexcept
+ CommonArrayFieldClass& operator=(const CommonArrayFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonFieldClass::operator=(fc);
return *this;
}
template <typename OtherLibObjT>
- CommonStaticArrayFieldClass(const CommonStaticArrayFieldClass<OtherLibObjT>& fc) noexcept :
+ CommonStaticArrayFieldClass(const CommonStaticArrayFieldClass<OtherLibObjT> fc) noexcept :
_ThisCommonArrayFieldClass {fc}
{
}
template <typename OtherLibObjT>
CommonStaticArrayFieldClass&
- operator=(const CommonStaticArrayFieldClass<OtherLibObjT>& fc) noexcept
+ operator=(const CommonStaticArrayFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonArrayFieldClass::operator=(fc);
return *this;
template <typename OtherLibObjT>
CommonDynamicArrayWithLengthFieldClass(
- const CommonDynamicArrayWithLengthFieldClass<OtherLibObjT>& fc) noexcept :
+ const CommonDynamicArrayWithLengthFieldClass<OtherLibObjT> fc) noexcept :
_ThisCommonArrayFieldClass {fc}
{
}
template <typename OtherLibObjT>
CommonDynamicArrayWithLengthFieldClass&
- operator=(const CommonDynamicArrayWithLengthFieldClass<OtherLibObjT>& fc) noexcept
+ operator=(const CommonDynamicArrayWithLengthFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonArrayFieldClass::operator=(fc);
return *this;
}
template <typename OtherLibObjT>
- CommonOptionFieldClass(const CommonOptionFieldClass<OtherLibObjT>& fc) noexcept :
+ CommonOptionFieldClass(const CommonOptionFieldClass<OtherLibObjT> fc) noexcept :
_ThisCommonFieldClass {fc}
{
}
template <typename OtherLibObjT>
- CommonOptionFieldClass& operator=(const CommonOptionFieldClass<OtherLibObjT>& fc) noexcept
+ CommonOptionFieldClass& operator=(const CommonOptionFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonFieldClass::operator=(fc);
return *this;
template <typename OtherLibObjT>
CommonOptionWithSelectorFieldClass(
- const CommonOptionWithSelectorFieldClass<OtherLibObjT>& fc) noexcept :
+ const CommonOptionWithSelectorFieldClass<OtherLibObjT> fc) noexcept :
_ThisCommonOptionFieldClass {fc}
{
}
template <typename OtherLibObjT>
CommonOptionWithSelectorFieldClass&
- operator=(const CommonOptionWithSelectorFieldClass<OtherLibObjT>& fc) noexcept
+ operator=(const CommonOptionWithSelectorFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonOptionFieldClass::operator=(fc);
return *this;
template <typename OtherLibObjT>
CommonOptionWithBoolSelectorFieldClass(
- const CommonOptionWithBoolSelectorFieldClass<OtherLibObjT>& fc) noexcept :
+ const CommonOptionWithBoolSelectorFieldClass<OtherLibObjT> fc) noexcept :
_ThisCommonOptionWithSelectorFieldClass {fc}
{
}
template <typename OtherLibObjT>
CommonOptionWithBoolSelectorFieldClass&
- operator=(const CommonOptionWithBoolSelectorFieldClass<OtherLibObjT>& fc) noexcept
+ operator=(const CommonOptionWithBoolSelectorFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonOptionWithSelectorFieldClass::operator=(fc);
return *this;
template <typename OtherLibObjT>
CommonOptionWithIntegerSelectorFieldClass(
- const CommonOptionWithIntegerSelectorFieldClass<OtherLibObjT, RangeSetT>& fc) noexcept :
+ const CommonOptionWithIntegerSelectorFieldClass<OtherLibObjT, RangeSetT> fc) noexcept :
_ThisCommonOptionWithSelectorFieldClass {fc}
{
}
template <typename OtherLibObjT>
CommonOptionWithIntegerSelectorFieldClass&
- operator=(const CommonOptionWithIntegerSelectorFieldClass<OtherLibObjT, RangeSetT>& fc) noexcept
+ operator=(const CommonOptionWithIntegerSelectorFieldClass<OtherLibObjT, RangeSetT> fc) noexcept
{
_ThisCommonOptionWithSelectorFieldClass::operator=(fc);
return *this;
}
template <typename OtherLibObjT>
- CommonVariantFieldClassOption(const CommonVariantFieldClassOption<OtherLibObjT>& fc) noexcept :
+ CommonVariantFieldClassOption(const CommonVariantFieldClassOption<OtherLibObjT> fc) noexcept :
_ThisBorrowedObj {fc}
{
}
template <typename OtherLibObjT>
CommonVariantFieldClassOption&
- operator=(const CommonVariantFieldClassOption<OtherLibObjT>& fc) noexcept
+ operator=(const CommonVariantFieldClassOption<OtherLibObjT> fc) noexcept
{
_ThisBorrowedObj::operator=(fc);
return *this;
}
template <typename LibValT>
- void userAttributes(const CommonMapValue<LibValT>& userAttrs)
+ void userAttributes(const CommonMapValue<LibValT> userAttrs)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
template <typename OtherLibObjT>
ConstVariantWithIntegerSelectorFieldClassOption(
- const ConstVariantWithIntegerSelectorFieldClassOption<OtherLibObjT>& fc) noexcept :
+ const ConstVariantWithIntegerSelectorFieldClassOption<OtherLibObjT> fc) noexcept :
_ThisBorrowedObj {fc}
{
}
template <typename OtherLibObjT>
ConstVariantWithIntegerSelectorFieldClassOption&
- operator=(const ConstVariantWithIntegerSelectorFieldClassOption<OtherLibObjT>& fc) noexcept
+ operator=(const ConstVariantWithIntegerSelectorFieldClassOption<OtherLibObjT> fc) noexcept
{
_ThisBorrowedObj::operator=(fc);
return *this;
}
template <typename OtherLibObjT>
- CommonVariantFieldClass(const CommonVariantFieldClass<OtherLibObjT>& fc) noexcept :
+ CommonVariantFieldClass(const CommonVariantFieldClass<OtherLibObjT> fc) noexcept :
_ThisCommonFieldClass {fc}
{
}
template <typename OtherLibObjT>
- CommonVariantFieldClass& operator=(const CommonVariantFieldClass<OtherLibObjT>& fc) noexcept
+ CommonVariantFieldClass& operator=(const CommonVariantFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonFieldClass::operator=(fc);
return *this;
template <typename OtherLibObjT>
CommonVariantWithoutSelectorFieldClass(
- const CommonVariantWithoutSelectorFieldClass<OtherLibObjT>& fc) noexcept :
+ const CommonVariantWithoutSelectorFieldClass<OtherLibObjT> fc) noexcept :
_ThisCommonVariantFieldClass {fc}
{
}
template <typename OtherLibObjT>
CommonVariantWithoutSelectorFieldClass&
- operator=(const CommonVariantWithoutSelectorFieldClass<OtherLibObjT>& fc) noexcept
+ operator=(const CommonVariantWithoutSelectorFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonVariantFieldClass::operator=(fc);
return *this;
}
- void appendOption(const char * const name, const FieldClass& fc)
+ void appendOption(const char * const name, const FieldClass fc)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
}
- void appendOption(const nonstd::optional<std::string>& name, const FieldClass& fc)
+ void appendOption(const nonstd::optional<std::string>& name, const FieldClass fc)
{
this->appendOption(name ? name->data() : nullptr, fc);
}
template <typename OtherLibObjT>
CommonVariantWithSelectorFieldClass(
- const CommonVariantWithSelectorFieldClass<OtherLibObjT>& fc) noexcept :
+ const CommonVariantWithSelectorFieldClass<OtherLibObjT> fc) noexcept :
_ThisCommonVariantFieldClass {fc}
{
}
template <typename OtherLibObjT>
CommonVariantWithSelectorFieldClass&
- operator=(const CommonVariantWithSelectorFieldClass<OtherLibObjT>& fc) noexcept
+ operator=(const CommonVariantWithSelectorFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonVariantFieldClass::operator=(fc);
return *this;
template <typename OtherLibObjT>
CommonVariantWithIntegerSelectorFieldClass(
- const CommonVariantWithIntegerSelectorFieldClass<OtherLibObjT, OptionT>& fc) noexcept :
+ const CommonVariantWithIntegerSelectorFieldClass<OtherLibObjT, OptionT> fc) noexcept :
_ThisCommonVariantWithSelectorFieldClass {fc}
{
}
template <typename OtherLibObjT>
CommonVariantWithIntegerSelectorFieldClass&
- operator=(const CommonVariantWithIntegerSelectorFieldClass<OtherLibObjT, OptionT>& fc) noexcept
+ operator=(const CommonVariantWithIntegerSelectorFieldClass<OtherLibObjT, OptionT> fc) noexcept
{
_ThisCommonVariantWithSelectorFieldClass::operator=(fc);
return *this;
return (*this)[name.data()];
}
- void appendOption(const char * const name, const FieldClass& fc,
- const typename Option::RangeSet& ranges)
+ void appendOption(const char * const name, const FieldClass fc,
+ const typename Option::RangeSet ranges)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
}
- void appendOption(const nonstd::optional<std::string>& name, const FieldClass& fc,
- const typename Option::RangeSet& ranges)
+ void appendOption(const nonstd::optional<std::string>& name, const FieldClass fc,
+ const typename Option::RangeSet ranges)
{
this->appendOption(name ? name->data() : nullptr, fc, ranges);
}
}
template <typename OtherLibObjT>
- CommonField(const CommonField<OtherLibObjT>& val) noexcept : _ThisBorrowedObj {val}
+ CommonField(const CommonField<OtherLibObjT> val) noexcept : _ThisBorrowedObj {val}
{
}
template <typename OtherLibObjT>
- _ThisCommonField& operator=(const CommonField<OtherLibObjT>& val) noexcept
+ _ThisCommonField& operator=(const CommonField<OtherLibObjT> val) noexcept
{
_ThisBorrowedObj::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonBoolField(const CommonBoolField<OtherLibObjT>& val) noexcept : _ThisCommonField {val}
+ CommonBoolField(const CommonBoolField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
{
}
template <typename OtherLibObjT>
- CommonBoolField<LibObjT>& operator=(const CommonBoolField<OtherLibObjT>& val) noexcept
+ CommonBoolField<LibObjT>& operator=(const CommonBoolField<OtherLibObjT> val) noexcept
{
_ThisCommonField::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonBitArrayField(const CommonBitArrayField<OtherLibObjT>& val) noexcept :
+ CommonBitArrayField(const CommonBitArrayField<OtherLibObjT> val) noexcept :
_ThisCommonField {val}
{
}
template <typename OtherLibObjT>
- CommonBitArrayField<LibObjT>& operator=(const CommonBitArrayField<OtherLibObjT>& val) noexcept
+ CommonBitArrayField<LibObjT>& operator=(const CommonBitArrayField<OtherLibObjT> val) noexcept
{
_ThisCommonField::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonUnsignedIntegerField(const CommonUnsignedIntegerField<OtherLibObjT>& val) noexcept :
+ CommonUnsignedIntegerField(const CommonUnsignedIntegerField<OtherLibObjT> val) noexcept :
_ThisCommonField {val}
{
}
template <typename OtherLibObjT>
_ThisCommonUnsignedIntegerField&
- operator=(const CommonUnsignedIntegerField<OtherLibObjT>& val) noexcept
+ operator=(const CommonUnsignedIntegerField<OtherLibObjT> val) noexcept
{
_ThisCommonField::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonSignedIntegerField(const CommonSignedIntegerField<OtherLibObjT>& val) noexcept :
+ CommonSignedIntegerField(const CommonSignedIntegerField<OtherLibObjT> val) noexcept :
_ThisCommonField {val}
{
}
template <typename OtherLibObjT>
_ThisCommonSignedIntegerField&
- operator=(const CommonSignedIntegerField<OtherLibObjT>& val) noexcept
+ operator=(const CommonSignedIntegerField<OtherLibObjT> val) noexcept
{
_ThisCommonField::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonUnsignedEnumerationField(const CommonUnsignedEnumerationField<OtherLibObjT>& val) noexcept
+ CommonUnsignedEnumerationField(const CommonUnsignedEnumerationField<OtherLibObjT> val) noexcept
:
_ThisCommonUnsignedIntegerField {val}
{
template <typename OtherLibObjT>
CommonUnsignedEnumerationField<LibObjT>&
- operator=(const CommonUnsignedEnumerationField<OtherLibObjT>& val) noexcept
+ operator=(const CommonUnsignedEnumerationField<OtherLibObjT> val) noexcept
{
_ThisCommonUnsignedIntegerField::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonSignedEnumerationField(const CommonSignedEnumerationField<OtherLibObjT>& val) noexcept :
+ CommonSignedEnumerationField(const CommonSignedEnumerationField<OtherLibObjT> val) noexcept :
_ThisCommonSignedIntegerField {val}
{
}
template <typename OtherLibObjT>
CommonSignedEnumerationField<LibObjT>&
- operator=(const CommonSignedEnumerationField<OtherLibObjT>& val) noexcept
+ operator=(const CommonSignedEnumerationField<OtherLibObjT> val) noexcept
{
_ThisCommonSignedIntegerField::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonSinglePrecisionRealField(const CommonSinglePrecisionRealField<OtherLibObjT>& val) noexcept
+ CommonSinglePrecisionRealField(const CommonSinglePrecisionRealField<OtherLibObjT> val) noexcept
:
_ThisCommonField {val}
{
template <typename OtherLibObjT>
CommonSinglePrecisionRealField<LibObjT>&
- operator=(const CommonSinglePrecisionRealField<OtherLibObjT>& val) noexcept
+ operator=(const CommonSinglePrecisionRealField<OtherLibObjT> val) noexcept
{
_ThisCommonField::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonDoublePrecisionRealField(const CommonDoublePrecisionRealField<OtherLibObjT>& val) noexcept
+ CommonDoublePrecisionRealField(const CommonDoublePrecisionRealField<OtherLibObjT> val) noexcept
:
_ThisCommonField {val}
{
template <typename OtherLibObjT>
CommonDoublePrecisionRealField<LibObjT>&
- operator=(const CommonDoublePrecisionRealField<OtherLibObjT>& val) noexcept
+ operator=(const CommonDoublePrecisionRealField<OtherLibObjT> val) noexcept
{
_ThisCommonField::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonStringField(const CommonStringField<OtherLibObjT>& val) noexcept : _ThisCommonField {val}
+ CommonStringField(const CommonStringField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
{
}
template <typename OtherLibObjT>
- CommonStringField<LibObjT>& operator=(const CommonStringField<OtherLibObjT>& val) noexcept
+ CommonStringField<LibObjT>& operator=(const CommonStringField<OtherLibObjT> val) noexcept
{
_ThisCommonField::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonStructureField(const CommonStructureField<OtherLibObjT>& val) noexcept :
+ CommonStructureField(const CommonStructureField<OtherLibObjT> val) noexcept :
_ThisCommonField {val}
{
}
template <typename OtherLibObjT>
- CommonStructureField<LibObjT>& operator=(const CommonStructureField<OtherLibObjT>& val) noexcept
+ CommonStructureField<LibObjT>& operator=(const CommonStructureField<OtherLibObjT> val) noexcept
{
_ThisCommonField::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonArrayField(const CommonArrayField<OtherLibObjT>& val) noexcept : _ThisCommonField {val}
+ CommonArrayField(const CommonArrayField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
{
}
template <typename OtherLibObjT>
- _ThisCommonArrayField& operator=(const CommonArrayField<OtherLibObjT>& val) noexcept
+ _ThisCommonArrayField& operator=(const CommonArrayField<OtherLibObjT> val) noexcept
{
_ThisCommonField::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonDynamicArrayField(const CommonDynamicArrayField<OtherLibObjT>& val) noexcept :
+ CommonDynamicArrayField(const CommonDynamicArrayField<OtherLibObjT> val) noexcept :
_ThisCommonArrayField {val}
{
}
template <typename OtherLibObjT>
CommonDynamicArrayField<LibObjT>&
- operator=(const CommonDynamicArrayField<OtherLibObjT>& val) noexcept
+ operator=(const CommonDynamicArrayField<OtherLibObjT> val) noexcept
{
_ThisCommonArrayField::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonOptionField(const CommonOptionField<OtherLibObjT>& val) noexcept : _ThisCommonField {val}
+ CommonOptionField(const CommonOptionField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
{
}
template <typename OtherLibObjT>
- CommonOptionField<LibObjT>& operator=(const CommonOptionField<OtherLibObjT>& val) noexcept
+ CommonOptionField<LibObjT>& operator=(const CommonOptionField<OtherLibObjT> val) noexcept
{
_ThisCommonField::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonVariantField(const CommonVariantField<OtherLibObjT>& val) noexcept :
- _ThisCommonField {val}
+ CommonVariantField(const CommonVariantField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
{
}
template <typename OtherLibObjT>
- CommonVariantField<LibObjT>& operator=(const CommonVariantField<OtherLibObjT>& val) noexcept
+ CommonVariantField<LibObjT>& operator=(const CommonVariantField<OtherLibObjT> val) noexcept
{
_ThisCommonField::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonIntegerRangeSet(const CommonIntegerRangeSet<OtherLibObjT>& rangeSet) noexcept :
+ CommonIntegerRangeSet(const CommonIntegerRangeSet<OtherLibObjT> rangeSet) noexcept :
_ThisBorrowedObj {rangeSet}
{
}
template <typename OtherLibObjT>
_ThisCommonIntegerRangeSet&
- operator=(const CommonIntegerRangeSet<OtherLibObjT>& rangeSet) noexcept
+ operator=(const CommonIntegerRangeSet<OtherLibObjT> rangeSet) noexcept
{
_ThisBorrowedObj::operator=(rangeSet);
return *this;
}
template <typename OtherLibObjT>
- bool operator==(const CommonIntegerRangeSet<OtherLibObjT>& other) const noexcept
+ bool operator==(const CommonIntegerRangeSet<OtherLibObjT> other) const noexcept
{
return _Spec::isEqual(this->libObjPtr(), other.libObjPtr());
}
template <typename OtherLibObjT>
- bool operator!=(const CommonIntegerRangeSet<OtherLibObjT>& other) const noexcept
+ bool operator!=(const CommonIntegerRangeSet<OtherLibObjT> other) const noexcept
{
return !(*this == other);
}
}
template <typename OtherLibObjT>
- CommonMessage(const CommonMessage<OtherLibObjT>& val) noexcept : _ThisBorrowedObj {val}
+ CommonMessage(const CommonMessage<OtherLibObjT> val) noexcept : _ThisBorrowedObj {val}
{
}
template <typename OtherLibObjT>
- _ThisCommonMessage& operator=(const CommonMessage<OtherLibObjT>& val) noexcept
+ _ThisCommonMessage& operator=(const CommonMessage<OtherLibObjT> val) noexcept
{
_ThisBorrowedObj::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonStreamBeginningMessage(const CommonStreamBeginningMessage<OtherLibObjT>& val) noexcept :
+ CommonStreamBeginningMessage(const CommonStreamBeginningMessage<OtherLibObjT> val) noexcept :
_ThisCommonMessage {val}
{
}
template <typename OtherLibObjT>
CommonStreamBeginningMessage<LibObjT>&
- operator=(const CommonStreamBeginningMessage<OtherLibObjT>& val) noexcept
+ operator=(const CommonStreamBeginningMessage<OtherLibObjT> val) noexcept
{
_ThisCommonMessage::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonStreamEndMessage(const CommonStreamEndMessage<OtherLibObjT>& val) noexcept :
+ CommonStreamEndMessage(const CommonStreamEndMessage<OtherLibObjT> val) noexcept :
_ThisCommonMessage {val}
{
}
template <typename OtherLibObjT>
CommonStreamEndMessage<LibObjT>&
- operator=(const CommonStreamEndMessage<OtherLibObjT>& val) noexcept
+ operator=(const CommonStreamEndMessage<OtherLibObjT> val) noexcept
{
_ThisCommonMessage::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonPacketBeginningMessage(const CommonPacketBeginningMessage<OtherLibObjT>& val) noexcept :
+ CommonPacketBeginningMessage(const CommonPacketBeginningMessage<OtherLibObjT> val) noexcept :
_ThisCommonMessage {val}
{
}
template <typename OtherLibObjT>
CommonPacketBeginningMessage<LibObjT>&
- operator=(const CommonPacketBeginningMessage<OtherLibObjT>& val) noexcept
+ operator=(const CommonPacketBeginningMessage<OtherLibObjT> val) noexcept
{
_ThisCommonMessage::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonPacketEndMessage(const CommonPacketEndMessage<OtherLibObjT>& val) noexcept :
+ CommonPacketEndMessage(const CommonPacketEndMessage<OtherLibObjT> val) noexcept :
_ThisCommonMessage {val}
{
}
template <typename OtherLibObjT>
CommonPacketEndMessage<LibObjT>&
- operator=(const CommonPacketEndMessage<OtherLibObjT>& val) noexcept
+ operator=(const CommonPacketEndMessage<OtherLibObjT> val) noexcept
{
_ThisCommonMessage::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonEventMessage(const CommonEventMessage<OtherLibObjT>& val) noexcept :
+ CommonEventMessage(const CommonEventMessage<OtherLibObjT> val) noexcept :
_ThisCommonMessage {val}
{
}
template <typename OtherLibObjT>
- CommonEventMessage<LibObjT>& operator=(const CommonEventMessage<OtherLibObjT>& val) noexcept
+ CommonEventMessage<LibObjT>& operator=(const CommonEventMessage<OtherLibObjT> val) noexcept
{
_ThisCommonMessage::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonDiscardedEventsMessage(const CommonDiscardedEventsMessage<OtherLibObjT>& val) noexcept :
+ CommonDiscardedEventsMessage(const CommonDiscardedEventsMessage<OtherLibObjT> val) noexcept :
_ThisCommonMessage {val}
{
}
template <typename OtherLibObjT>
CommonDiscardedEventsMessage<LibObjT>&
- operator=(const CommonDiscardedEventsMessage<OtherLibObjT>& val) noexcept
+ operator=(const CommonDiscardedEventsMessage<OtherLibObjT> val) noexcept
{
_ThisCommonMessage::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonDiscardedPacketsMessage(const CommonDiscardedPacketsMessage<OtherLibObjT>& val) noexcept :
+ CommonDiscardedPacketsMessage(const CommonDiscardedPacketsMessage<OtherLibObjT> val) noexcept :
_ThisCommonMessage {val}
{
}
template <typename OtherLibObjT>
CommonDiscardedPacketsMessage<LibObjT>&
- operator=(const CommonDiscardedPacketsMessage<OtherLibObjT>& val) noexcept
+ operator=(const CommonDiscardedPacketsMessage<OtherLibObjT> val) noexcept
{
_ThisCommonMessage::operator=(val);
return *this;
template <typename OtherLibObjT>
CommonMessageIteratorInactivityMessage(
- const CommonMessageIteratorInactivityMessage<OtherLibObjT>& val) noexcept :
+ const CommonMessageIteratorInactivityMessage<OtherLibObjT> val) noexcept :
_ThisCommonMessage {val}
{
}
template <typename OtherLibObjT>
CommonMessageIteratorInactivityMessage<LibObjT>&
- operator=(const CommonMessageIteratorInactivityMessage<OtherLibObjT>& val) noexcept
+ operator=(const CommonMessageIteratorInactivityMessage<OtherLibObjT> val) noexcept
{
_ThisCommonMessage::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonEvent(const CommonEvent<OtherLibObjT>& event) noexcept : _ThisBorrowedObj {event}
+ CommonEvent(const CommonEvent<OtherLibObjT> event) noexcept : _ThisBorrowedObj {event}
{
}
template <typename OtherLibObjT>
- CommonEvent<LibObjT>& operator=(const CommonEvent<OtherLibObjT>& event) noexcept
+ CommonEvent<LibObjT>& operator=(const CommonEvent<OtherLibObjT> event) noexcept
{
_ThisBorrowedObj::operator=(event);
return *this;
}
template <typename OtherLibObjT>
- CommonPacket(const CommonPacket<OtherLibObjT>& packet) noexcept : _ThisBorrowedObj {packet}
+ CommonPacket(const CommonPacket<OtherLibObjT> packet) noexcept : _ThisBorrowedObj {packet}
{
}
template <typename OtherLibObjT>
- _ThisCommonPacket& operator=(const CommonPacket<OtherLibObjT>& packet) noexcept
+ _ThisCommonPacket& operator=(const CommonPacket<OtherLibObjT> packet) noexcept
{
_ThisBorrowedObj::operator=(packet);
return *this;
}
template <typename OtherLibObjT>
- CommonStream(const CommonStream<OtherLibObjT>& stream) noexcept : _ThisBorrowedObj {stream}
+ CommonStream(const CommonStream<OtherLibObjT> stream) noexcept : _ThisBorrowedObj {stream}
{
}
template <typename OtherLibObjT>
- _ThisCommonStream& operator=(const CommonStream<OtherLibObjT>& stream) noexcept
+ _ThisCommonStream& operator=(const CommonStream<OtherLibObjT> stream) noexcept
{
_ThisBorrowedObj::operator=(stream);
return *this;
}
template <typename LibValT>
- void userAttributes(const CommonMapValue<LibValT>& userAttrs)
+ void userAttributes(const CommonMapValue<LibValT> userAttrs)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
template <typename OtherLibObjT>
- CommonTrace(const CommonTrace<OtherLibObjT>& trace) noexcept : _ThisBorrowedObj {trace}
+ CommonTrace(const CommonTrace<OtherLibObjT> trace) noexcept : _ThisBorrowedObj {trace}
{
}
template <typename OtherLibObjT>
- _ThisCommonTrace& operator=(const CommonTrace<OtherLibObjT>& trace) noexcept
+ _ThisCommonTrace& operator=(const CommonTrace<OtherLibObjT> trace) noexcept
{
_ThisBorrowedObj::operator=(trace);
return *this;
}
template <typename LibValT>
- void userAttributes(const CommonMapValue<LibValT>& userAttrs)
+ void userAttributes(const CommonMapValue<LibValT> userAttrs)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
template <typename OtherLibObjT>
- CommonEventClass(const CommonEventClass<OtherLibObjT>& eventClass) noexcept :
+ CommonEventClass(const CommonEventClass<OtherLibObjT> eventClass) noexcept :
_ThisBorrowedObj {eventClass}
{
}
template <typename OtherLibObjT>
- _ThisCommonEventClass& operator=(const CommonEventClass<OtherLibObjT>& eventClass) noexcept
+ _ThisCommonEventClass& operator=(const CommonEventClass<OtherLibObjT> eventClass) noexcept
{
_ThisBorrowedObj::operator=(eventClass);
return *this;
return nonstd::nullopt;
}
- void payloadFieldClass(const StructureFieldClass& fc)
+ void payloadFieldClass(const StructureFieldClass fc)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return nonstd::nullopt;
}
- void specificContextFieldClass(const StructureFieldClass& fc)
+ void specificContextFieldClass(const StructureFieldClass fc)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
template <typename LibValT>
- void userAttributes(const CommonMapValue<LibValT>& userAttrs)
+ void userAttributes(const CommonMapValue<LibValT> userAttrs)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
template <typename OtherLibObjT>
- CommonStreamClass(const CommonStreamClass<OtherLibObjT>& streamClass) noexcept :
+ CommonStreamClass(const CommonStreamClass<OtherLibObjT> streamClass) noexcept :
_ThisBorrowedObj {streamClass}
{
}
template <typename OtherLibObjT>
- _ThisCommonStreamClass& operator=(const CommonStreamClass<OtherLibObjT>& streamClass) noexcept
+ _ThisCommonStreamClass& operator=(const CommonStreamClass<OtherLibObjT> streamClass) noexcept
{
_ThisBorrowedObj::operator=(streamClass);
return *this;
}
- Stream::Shared instantiate(const Trace& trace)
+ Stream::Shared instantiate(const Trace trace)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return Stream::Shared::createWithoutRef(libObjPtr);
}
- Stream::Shared instantiate(const Trace& trace, const std::uint64_t id)
+ Stream::Shared instantiate(const Trace trace, const std::uint64_t id)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
bt_stream_class_discarded_packets_have_default_clock_snapshots(this->libObjPtr()));
}
- void defaultClockClass(const ClockClass& clkCls)
+ void defaultClockClass(const ClockClass clkCls)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return nonstd::nullopt;
}
- void packetContextFieldClass(const StructureFieldClass& fc)
+ void packetContextFieldClass(const StructureFieldClass fc)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return nonstd::nullopt;
}
- void eventCommonContextFieldClass(const StructureFieldClass& fc)
+ void eventCommonContextFieldClass(const StructureFieldClass fc)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
template <typename LibValT>
- void userAttributes(const CommonMapValue<LibValT>& userAttrs)
+ void userAttributes(const CommonMapValue<LibValT> userAttrs)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
template <typename OtherLibObjT>
- CommonTraceClass(const CommonTraceClass<OtherLibObjT>& traceClass) noexcept :
+ CommonTraceClass(const CommonTraceClass<OtherLibObjT> traceClass) noexcept :
_ThisBorrowedObj {traceClass}
{
}
template <typename OtherLibObjT>
- _ThisCommonTraceClass& operator=(const CommonTraceClass<OtherLibObjT>& traceClass) noexcept
+ _ThisCommonTraceClass& operator=(const CommonTraceClass<OtherLibObjT> traceClass) noexcept
{
_ThisBorrowedObj::operator=(traceClass);
return *this;
}
- Trace::Shared instantiate(const Trace& trace)
+ Trace::Shared instantiate(const Trace trace)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return FieldClass::Shared::createWithoutRef(libObjPtr);
}
- StaticArrayFieldClass::Shared createStaticArrayFieldClass(const FieldClass& elementFieldClass,
+ StaticArrayFieldClass::Shared createStaticArrayFieldClass(const FieldClass elementFieldClass,
const std::uint64_t length)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return StaticArrayFieldClass::Shared::createWithoutRef(libObjPtr);
}
- ArrayFieldClass::Shared createDynamicArrayFieldClass(const FieldClass& elementFieldClass)
+ ArrayFieldClass::Shared createDynamicArrayFieldClass(const FieldClass elementFieldClass)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
DynamicArrayWithLengthFieldClass::Shared
- createDynamicArrayFieldClass(const FieldClass& elementFieldClass,
- const IntegerFieldClass& lengthFieldClass)
+ createDynamicArrayFieldClass(const FieldClass elementFieldClass,
+ const IntegerFieldClass lengthFieldClass)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
return StructureFieldClass::Shared::createWithoutRef(libObjPtr);
}
- OptionFieldClass::Shared createOptionFieldClass(const FieldClass& optionalFieldClass)
+ OptionFieldClass::Shared createOptionFieldClass(const FieldClass optionalFieldClass)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
OptionWithBoolSelectorFieldClass::Shared
- createOptionWithBoolSelectorFieldClass(const FieldClass& optionalFieldClass,
- const FieldClass& selectorFieldClass)
+ createOptionWithBoolSelectorFieldClass(const FieldClass optionalFieldClass,
+ const FieldClass selectorFieldClass)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
OptionWithUnsignedIntegerSelectorFieldClass::Shared
- createOptionWithUnsignedIntegerSelectorFieldClass(const FieldClass& optionalFieldClass,
- const IntegerFieldClass& selectorFieldClass,
- const ConstUnsignedIntegerRangeSet& ranges)
+ createOptionWithUnsignedIntegerSelectorFieldClass(const FieldClass optionalFieldClass,
+ const IntegerFieldClass selectorFieldClass,
+ const ConstUnsignedIntegerRangeSet ranges)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
OptionWithSignedIntegerSelectorFieldClass::Shared
- createOptionWithSignedIntegerSelectorFieldClass(const FieldClass& optionalFieldClass,
- const IntegerFieldClass& selectorFieldClass,
- const ConstSignedIntegerRangeSet& ranges)
+ createOptionWithSignedIntegerSelectorFieldClass(const FieldClass optionalFieldClass,
+ const IntegerFieldClass selectorFieldClass,
+ const ConstSignedIntegerRangeSet ranges)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
VariantWithUnsignedIntegerSelectorFieldClass::Shared
- createVariantWithUnsignedIntegerSelectorFieldClass(const IntegerFieldClass& selectorFieldClass)
+ createVariantWithUnsignedIntegerSelectorFieldClass(const IntegerFieldClass selectorFieldClass)
{
return VariantWithUnsignedIntegerSelectorFieldClass {
this->_createVariantWithIntegerSelectorFieldClass(selectorFieldClass)}
}
VariantWithSignedIntegerSelectorFieldClass::Shared
- createVariantWithSignedIntegerSelectorFieldClass(const IntegerFieldClass& selectorFieldClass)
+ createVariantWithSignedIntegerSelectorFieldClass(const IntegerFieldClass selectorFieldClass)
{
return VariantWithSignedIntegerSelectorFieldClass {
this->_createVariantWithIntegerSelectorFieldClass(selectorFieldClass)}
}
template <typename LibValT>
- void userAttributes(const CommonMapValue<LibValT>& userAttrs)
+ void userAttributes(const CommonMapValue<LibValT> userAttrs)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
private:
bt_field_class *
- _createVariantWithIntegerSelectorFieldClass(const IntegerFieldClass& selectorFieldClass)
+ _createVariantWithIntegerSelectorFieldClass(const IntegerFieldClass selectorFieldClass)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
template <typename OtherLibObjT>
- CommonValue(const CommonValue<OtherLibObjT>& val) noexcept : _ThisBorrowedObj {val}
+ CommonValue(const CommonValue<OtherLibObjT> val) noexcept : _ThisBorrowedObj {val}
{
}
template <typename OtherLibObjT>
- _ThisCommonValue& operator=(const CommonValue<OtherLibObjT>& val) noexcept
+ _ThisCommonValue& operator=(const CommonValue<OtherLibObjT> val) noexcept
{
_ThisBorrowedObj::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- bool operator==(const CommonValue<OtherLibObjT>& other) const noexcept
+ bool operator==(const CommonValue<OtherLibObjT> other) const noexcept
{
return static_cast<bool>(bt_value_is_equal(this->libObjPtr(), other.libObjPtr()));
}
template <typename OtherLibObjT>
- bool operator!=(const CommonValue<OtherLibObjT>& other) const noexcept
+ bool operator!=(const CommonValue<OtherLibObjT> other) const noexcept
{
return !(*this == other);
}
}
template <typename OtherLibObjT>
- CommonNullValue(const CommonNullValue<OtherLibObjT>& val) noexcept : _ThisCommonValue {val}
+ CommonNullValue(const CommonNullValue<OtherLibObjT> val) noexcept : _ThisCommonValue {val}
{
}
template <typename OtherLibObjT>
- CommonNullValue<LibObjT>& operator=(const CommonNullValue<OtherLibObjT>& val) noexcept
+ CommonNullValue<LibObjT>& operator=(const CommonNullValue<OtherLibObjT> val) noexcept
{
_ThisCommonValue::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonBoolValue(const CommonBoolValue<OtherLibObjT>& val) noexcept : _ThisCommonValue {val}
+ CommonBoolValue(const CommonBoolValue<OtherLibObjT> val) noexcept : _ThisCommonValue {val}
{
}
}
template <typename OtherLibObjT>
- CommonBoolValue<LibObjT>& operator=(const CommonBoolValue<OtherLibObjT>& val) noexcept
+ CommonBoolValue<LibObjT>& operator=(const CommonBoolValue<OtherLibObjT> val) noexcept
{
_ThisCommonValue::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonUnsignedIntegerValue(const CommonUnsignedIntegerValue<OtherLibObjT>& val) noexcept :
+ CommonUnsignedIntegerValue(const CommonUnsignedIntegerValue<OtherLibObjT> val) noexcept :
_ThisCommonValue {val}
{
}
template <typename OtherLibObjT>
CommonUnsignedIntegerValue<LibObjT>&
- operator=(const CommonUnsignedIntegerValue<OtherLibObjT>& val) noexcept
+ operator=(const CommonUnsignedIntegerValue<OtherLibObjT> val) noexcept
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
}
template <typename OtherLibObjT>
- CommonSignedIntegerValue(const CommonSignedIntegerValue<OtherLibObjT>& val) noexcept :
+ CommonSignedIntegerValue(const CommonSignedIntegerValue<OtherLibObjT> val) noexcept :
_ThisCommonValue {val}
{
}
template <typename OtherLibObjT>
CommonSignedIntegerValue<LibObjT>&
- operator=(const CommonSignedIntegerValue<OtherLibObjT>& val) noexcept
+ operator=(const CommonSignedIntegerValue<OtherLibObjT> val) noexcept
{
_ThisCommonValue::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonRealValue(const CommonRealValue<OtherLibObjT>& val) noexcept : _ThisCommonValue {val}
+ CommonRealValue(const CommonRealValue<OtherLibObjT> val) noexcept : _ThisCommonValue {val}
{
}
template <typename OtherLibObjT>
- CommonRealValue<LibObjT>& operator=(const CommonRealValue<OtherLibObjT>& val) noexcept
+ CommonRealValue<LibObjT>& operator=(const CommonRealValue<OtherLibObjT> val) noexcept
{
_ThisCommonValue::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonStringValue(const CommonStringValue<OtherLibObjT>& val) noexcept : _ThisCommonValue {val}
+ CommonStringValue(const CommonStringValue<OtherLibObjT> val) noexcept : _ThisCommonValue {val}
{
}
template <typename OtherLibObjT>
- CommonStringValue<LibObjT>& operator=(const CommonStringValue<OtherLibObjT>& val) noexcept
+ CommonStringValue<LibObjT>& operator=(const CommonStringValue<OtherLibObjT> val) noexcept
{
_ThisCommonValue::operator=(val);
return *this;
}
template <typename OtherLibObjT>
- CommonArrayValue(const CommonArrayValue<OtherLibObjT>& val) noexcept : _ThisCommonValue {val}
+ CommonArrayValue(const CommonArrayValue<OtherLibObjT> val) noexcept : _ThisCommonValue {val}
{
}
template <typename OtherLibObjT>
- CommonArrayValue<LibObjT>& operator=(const CommonArrayValue<OtherLibObjT>& val) noexcept
+ CommonArrayValue<LibObjT>& operator=(const CommonArrayValue<OtherLibObjT> val) noexcept
{
_ThisCommonValue::operator=(val);
return *this;
internal::CommonArrayValueSpec<LibObjT>::elementByIndex(this->libObjPtr(), index)};
}
- void append(const Value& val)
+ void append(const Value val)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
CommonArrayValue<bt_value> appendEmptyArray();
CommonMapValue<bt_value> appendEmptyMap();
- void operator+=(const Value& val)
+ void operator+=(const Value val)
{
this->append(val);
}
}
template <typename OtherLibObjT>
- CommonMapValue(const CommonMapValue<OtherLibObjT>& val) noexcept : _ThisCommonValue {val}
+ CommonMapValue(const CommonMapValue<OtherLibObjT> val) noexcept : _ThisCommonValue {val}
{
}
template <typename OtherLibObjT>
- CommonMapValue<LibObjT>& operator=(const CommonMapValue<OtherLibObjT>& val) noexcept
+ CommonMapValue<LibObjT>& operator=(const CommonMapValue<OtherLibObjT> val) noexcept
{
_ThisCommonValue::operator=(val);
return *this;
return this->hasEntry(key.data());
}
- void insert(const char * const key, const Value& val)
+ void insert(const char * const key, const Value val)
{
static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
this->_handleInsertLibStatus(status);
}
- void insert(const std::string& key, const Value& val)
+ void insert(const std::string& key, const Value val)
{
this->insert(key.data(), val);
}