X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=src%2Fbindings%2Fpython%2Fbt2%2Fbt2%2Ffield_class.py;h=3f81c47c6331acfdefd161c75d0f5361374f2d23;hb=e5914347c8eea0f26c07348d0ac64dbe020de44a;hp=bad407b41401234cb3c4220a2c867bff270f2e7e;hpb=5679964cffc1ecbb1b7d4fbd6a5ab9f3a7832bba;p=babeltrace.git diff --git a/src/bindings/python/bt2/bt2/field_class.py b/src/bindings/python/bt2/bt2/field_class.py index bad407b4..3f81c47c 100644 --- a/src/bindings/python/bt2/bt2/field_class.py +++ b/src/bindings/python/bt2/bt2/field_class.py @@ -1,26 +1,10 @@ -# The MIT License (MIT) +# SPDX-License-Identifier: MIT # # Copyright (c) 2017 Philippe Proulx -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in -# all copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -# THE SOFTWARE. - -from bt2 import native_bt, object, utils + +from bt2 import native_bt +from bt2 import object as bt2_object +from bt2 import utils as bt2_utils import collections.abc from bt2 import field_path as bt2_field_path from bt2 import integer_range_set as bt2_integer_range_set @@ -28,9 +12,19 @@ from bt2 import value as bt2_value import bt2 -def _create_field_class_from_ptr_and_get_ref_template(type_map, ptr): +def _obj_type_from_field_class_ptr_template(type_map, ptr): typeid = native_bt.field_class_get_type(ptr) - return type_map[typeid]._create_from_ptr_and_get_ref(ptr) + return type_map[typeid] + + +def _obj_type_from_field_class_ptr(ptr): + return _obj_type_from_field_class_ptr_template(_FIELD_CLASS_TYPE_TO_OBJ, ptr) + + +def _create_field_class_from_ptr_and_get_ref_template(type_map, ptr): + return _obj_type_from_field_class_ptr_template( + type_map, ptr + )._create_from_ptr_and_get_ref(ptr) def _create_field_class_from_ptr_and_get_ref(ptr): @@ -52,9 +46,15 @@ class IntegerDisplayBase: HEXADECIMAL = native_bt.FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL -class _FieldClassConst(object._SharedObject): - _get_ref = staticmethod(native_bt.field_class_get_ref) - _put_ref = staticmethod(native_bt.field_class_put_ref) +class _FieldClassConst(bt2_object._SharedObject): + @staticmethod + def _get_ref(ptr): + native_bt.field_class_get_ref(ptr) + + @staticmethod + def _put_ref(ptr): + native_bt.field_class_put_ref(ptr) + _borrow_user_attributes_ptr = staticmethod( native_bt.field_class_borrow_user_attributes_const ) @@ -65,7 +65,7 @@ class _FieldClassConst(object._SharedObject): def _check_create_status(self, ptr): if ptr is None: raise bt2._MemoryError( - 'cannot create {} field class object'.format(self._NAME.lower()) + "cannot create {} field class object".format(self._NAME.lower()) ) @property @@ -85,22 +85,22 @@ class _FieldClass(_FieldClassConst): def _user_attributes(self, user_attributes): value = bt2_value.create_value(user_attributes) - utils._check_type(value, bt2_value.MapValue) + bt2_utils._check_type(value, bt2_value.MapValue) native_bt.field_class_set_user_attributes(self._ptr, value._ptr) _user_attributes = property(fset=_user_attributes) class _BoolFieldClassConst(_FieldClassConst): - _NAME = 'Const Boolean' + _NAME = "Const boolean" class _BoolFieldClass(_BoolFieldClassConst, _FieldClass): - _NAME = 'Boolean' + _NAME = "Boolean" class _BitArrayFieldClassConst(_FieldClassConst): - _NAME = 'Const Bit array' + _NAME = "Const bit array" @property def length(self): @@ -110,7 +110,7 @@ class _BitArrayFieldClassConst(_FieldClassConst): class _BitArrayFieldClass(_BitArrayFieldClassConst, _FieldClass): - _NAME = 'Bit array' + _NAME = "Bit array" class _IntegerFieldClassConst(_FieldClassConst): @@ -136,7 +136,7 @@ class _IntegerFieldClass(_FieldClass, _IntegerFieldClassConst): _field_value_range = property(fset=_field_value_range) def _preferred_display_base(self, base): - utils._check_uint64(base) + bt2_utils._check_uint64(base) if base not in ( IntegerDisplayBase.BINARY, @@ -152,43 +152,47 @@ class _IntegerFieldClass(_FieldClass, _IntegerFieldClassConst): class _UnsignedIntegerFieldClassConst(_IntegerFieldClassConst, _FieldClassConst): - _NAME = 'Const unsigned integer' + _NAME = "Const unsigned integer" class _UnsignedIntegerFieldClass( _UnsignedIntegerFieldClassConst, _IntegerFieldClass, _FieldClass ): - _NAME = 'Unsigned integer' + _NAME = "Unsigned integer" class _SignedIntegerFieldClassConst(_IntegerFieldClassConst, _FieldClassConst): - _NAME = 'Const signed integer' + _NAME = "Const signed integer" class _SignedIntegerFieldClass( _SignedIntegerFieldClassConst, _IntegerFieldClass, _FieldClass ): - _NAME = 'Signed integer' + _NAME = "Signed integer" class _RealFieldClassConst(_FieldClassConst): - _NAME = 'Const real' + pass - @property - def is_single_precision(self): - return native_bt.field_class_real_is_single_precision(self._ptr) + +class _SinglePrecisionRealFieldClassConst(_RealFieldClassConst): + _NAME = "Const single-precision real" + + +class _DoublePrecisionRealFieldClassConst(_RealFieldClassConst): + _NAME = "Const double-precision real" class _RealFieldClass(_FieldClass, _RealFieldClassConst): - _NAME = 'Real' + pass - def _is_single_precision(self, is_single_precision): - utils._check_bool(is_single_precision) - native_bt.field_class_real_set_is_single_precision( - self._ptr, is_single_precision - ) - _is_single_precision = property(fset=_is_single_precision) +class _SinglePrecisionRealFieldClass(_RealFieldClass): + _NAME = "Single-precision real" + + +class _DoublePrecisionRealFieldClass(_RealFieldClass): + _NAME = "Double-precision real" # an enumeration field class mapping does not have a reference count, so @@ -214,7 +218,7 @@ class _EnumerationFieldClassMapping: class _UnsignedEnumerationFieldClassMappingConst(_EnumerationFieldClassMapping): - _range_set_pycls = bt2_integer_range_set.UnsignedIntegerRangeSet + _range_set_pycls = bt2_integer_range_set._UnsignedIntegerRangeSetConst _as_enumeration_field_class_mapping_ptr = staticmethod( native_bt.field_class_enumeration_unsigned_mapping_as_mapping_const ) @@ -224,7 +228,7 @@ class _UnsignedEnumerationFieldClassMappingConst(_EnumerationFieldClassMapping): class _SignedEnumerationFieldClassMappingConst(_EnumerationFieldClassMapping): - _range_set_pycls = bt2_integer_range_set.SignedIntegerRangeSet + _range_set_pycls = bt2_integer_range_set._SignedIntegerRangeSetConst _as_enumeration_field_class_mapping_ptr = staticmethod( native_bt.field_class_enumeration_signed_mapping_as_mapping_const ) @@ -243,8 +247,8 @@ class _EnumerationFieldClassConst(_IntegerFieldClassConst, collections.abc.Mappi self._check_int_type(value) status, labels = self._get_mapping_labels_for_value(self._ptr, value) - utils._handle_func_status( - status, 'cannot get mapping labels for value {}'.format(value) + bt2_utils._handle_func_status( + status, "cannot get mapping labels for value {}".format(value) ) return [self[label] for label in labels] @@ -254,7 +258,7 @@ class _EnumerationFieldClassConst(_IntegerFieldClassConst, collections.abc.Mappi yield self._mapping_pycls(mapping_ptr).label def __getitem__(self, label): - utils._check_str(label) + bt2_utils._check_str(label) mapping_ptr = self._borrow_mapping_ptr_by_label(self._ptr, label) if mapping_ptr is None: @@ -265,15 +269,15 @@ class _EnumerationFieldClassConst(_IntegerFieldClassConst, collections.abc.Mappi class _EnumerationFieldClass(_EnumerationFieldClassConst, _IntegerFieldClass): def add_mapping(self, label, ranges): - utils._check_str(label) - utils._check_type(ranges, self._range_set_pycls) + bt2_utils._check_str(label) + bt2_utils._check_type(ranges, self._range_set_pycls) if label in self: raise ValueError("duplicate mapping label '{}'".format(label)) status = self._add_mapping(self._ptr, label, ranges._ptr) - utils._handle_func_status( - status, 'cannot add mapping to enumeration field class object' + bt2_utils._handle_func_status( + status, "cannot add mapping to enumeration field class object" ) def __iadd__(self, mappings): @@ -286,8 +290,7 @@ class _EnumerationFieldClass(_EnumerationFieldClassConst, _IntegerFieldClass): class _UnsignedEnumerationFieldClassConst( _EnumerationFieldClassConst, _UnsignedIntegerFieldClassConst ): - _NAME = 'Const nsigned enumeration' - _range_set_pycls = bt2_integer_range_set.UnsignedIntegerRangeSet + _NAME = "Const unsigned enumeration" _borrow_mapping_ptr_by_label = staticmethod( native_bt.field_class_enumeration_unsigned_borrow_mapping_by_label_const ) @@ -298,7 +301,7 @@ class _UnsignedEnumerationFieldClassConst( _get_mapping_labels_for_value = staticmethod( native_bt.field_class_enumeration_unsigned_get_mapping_labels_for_value ) - _check_int_type = staticmethod(utils._check_uint64) + _check_int_type = staticmethod(bt2_utils._check_uint64) class _UnsignedEnumerationFieldClass( @@ -306,15 +309,15 @@ class _UnsignedEnumerationFieldClass( _EnumerationFieldClass, _UnsignedIntegerFieldClass, ): - _NAME = 'Unsigned enumeration' + _NAME = "Unsigned enumeration" + _range_set_pycls = bt2_integer_range_set.UnsignedIntegerRangeSet _add_mapping = staticmethod(native_bt.field_class_enumeration_unsigned_add_mapping) class _SignedEnumerationFieldClassConst( _EnumerationFieldClassConst, _SignedIntegerFieldClassConst ): - _NAME = 'Const signed enumeration' - _range_set_pycls = bt2_integer_range_set.SignedIntegerRangeSet + _NAME = "Const signed enumeration" _borrow_mapping_ptr_by_label = staticmethod( native_bt.field_class_enumeration_signed_borrow_mapping_by_label_const ) @@ -325,22 +328,23 @@ class _SignedEnumerationFieldClassConst( _get_mapping_labels_for_value = staticmethod( native_bt.field_class_enumeration_signed_get_mapping_labels_for_value ) - _check_int_type = staticmethod(utils._check_int64) + _check_int_type = staticmethod(bt2_utils._check_int64) class _SignedEnumerationFieldClass( _SignedEnumerationFieldClassConst, _EnumerationFieldClass, _SignedIntegerFieldClass ): - _NAME = 'Signed enumeration' + _NAME = "Signed enumeration" + _range_set_pycls = bt2_integer_range_set.SignedIntegerRangeSet _add_mapping = staticmethod(native_bt.field_class_enumeration_signed_add_mapping) class _StringFieldClassConst(_FieldClassConst): - _NAME = 'Const string' + _NAME = "Const string" class _StringFieldClass(_StringFieldClassConst, _FieldClass): - _NAME = 'String' + _NAME = "String" class _StructureFieldClassMemberConst: @@ -398,7 +402,7 @@ class _StructureFieldClassMember(_StructureFieldClassMemberConst): def _user_attributes(self, user_attributes): value = bt2_value.create_value(user_attributes) - utils._check_type(value, bt2_value.MapValue) + bt2_utils._check_type(value, bt2_value.MapValue) native_bt.field_class_structure_member_set_user_attributes( self._ptr, value._ptr ) @@ -407,7 +411,7 @@ class _StructureFieldClassMember(_StructureFieldClassMemberConst): class _StructureFieldClassConst(_FieldClassConst, collections.abc.Mapping): - _NAME = 'Const structure' + _NAME = "Const structure" _borrow_member_ptr_by_index = staticmethod( native_bt.field_class_structure_borrow_member_by_index_const ) @@ -443,7 +447,7 @@ class _StructureFieldClassConst(_FieldClassConst, collections.abc.Mapping): yield native_bt.field_class_structure_member_get_name(member_ptr) def member_at_index(self, index): - utils._check_uint64(index) + bt2_utils._check_uint64(index) if index >= len(self): raise IndexError @@ -454,7 +458,7 @@ class _StructureFieldClassConst(_FieldClassConst, collections.abc.Mapping): class _StructureFieldClass(_StructureFieldClassConst, _FieldClass): - _NAME = 'Structure' + _NAME = "Structure" _borrow_member_by_index = staticmethod( native_bt.field_class_structure_borrow_member_by_index ) @@ -464,8 +468,8 @@ class _StructureFieldClass(_StructureFieldClassConst, _FieldClass): _structure_member_field_class_pycls = property(lambda _: _StructureFieldClassMember) def append_member(self, name, field_class, user_attributes=None): - utils._check_str(name) - utils._check_type(field_class, _FieldClass) + bt2_utils._check_str(name) + bt2_utils._check_type(field_class, _FieldClass) if name in self: raise ValueError("duplicate member name '{}'".format(name)) @@ -479,8 +483,8 @@ class _StructureFieldClass(_StructureFieldClassConst, _FieldClass): status = native_bt.field_class_structure_append_member( self._ptr, name, field_class._ptr ) - utils._handle_func_status( - status, 'cannot append member to structure field class object' + bt2_utils._handle_func_status( + status, "cannot append member to structure field class object" ) if user_attributes is not None: @@ -494,33 +498,78 @@ class _StructureFieldClass(_StructureFieldClassConst, _FieldClass): class _OptionFieldClassConst(_FieldClassConst): - _NAME = 'Const Option' + _NAME = "Const option" _create_field_class_from_ptr_and_get_ref = staticmethod( _create_field_class_from_const_ptr_and_get_ref ) _borrow_field_class_ptr = staticmethod( native_bt.field_class_option_borrow_field_class_const ) - _borrow_selector_field_path = staticmethod( - native_bt.field_class_option_borrow_selector_field_path_const - ) @property def field_class(self): elem_fc_ptr = self._borrow_field_class_ptr(self._ptr) return self._create_field_class_from_ptr_and_get_ref(elem_fc_ptr) + +class _OptionWithSelectorFieldClassConst(_OptionFieldClassConst): + _NAME = "Const option (with selector)" + @property def selector_field_path(self): - ptr = self._borrow_selector_field_path(self._ptr) + ptr = native_bt.field_class_option_with_selector_field_borrow_selector_field_path_const( + self._ptr + ) if ptr is None: return return bt2_field_path._FieldPathConst._create_from_ptr_and_get_ref(ptr) +class _OptionWithBoolSelectorFieldClassConst(_OptionWithSelectorFieldClassConst): + _NAME = "Const option (with boolean selector)" + + @property + def selector_is_reversed(self): + return bool( + native_bt.field_class_option_with_selector_field_bool_selector_is_reversed( + self._ptr + ) + ) + + +class _OptionWithIntegerSelectorFieldClassConst(_OptionWithSelectorFieldClassConst): + _NAME = "Const option (with integer selector)" + + @property + def ranges(self): + range_set_ptr = self._borrow_selector_ranges_ptr(self._ptr) + assert range_set_ptr is not None + return self._range_set_pycls._create_from_ptr_and_get_ref(range_set_ptr) + + +class _OptionWithUnsignedIntegerSelectorFieldClassConst( + _OptionWithIntegerSelectorFieldClassConst +): + _NAME = "Const option (with unsigned integer selector)" + _range_set_pycls = bt2_integer_range_set._UnsignedIntegerRangeSetConst + _borrow_selector_ranges_ptr = staticmethod( + native_bt.field_class_option_with_selector_field_integer_unsigned_borrow_selector_ranges_const + ) + + +class _OptionWithSignedIntegerSelectorFieldClassConst( + _OptionWithIntegerSelectorFieldClassConst +): + _NAME = "Const option (with signed integer selector)" + _range_set_pycls = bt2_integer_range_set._SignedIntegerRangeSetConst + _borrow_selector_ranges_ptr = staticmethod( + native_bt.field_class_option_with_selector_field_integer_signed_borrow_selector_ranges_const + ) + + class _OptionFieldClass(_OptionFieldClassConst, _FieldClass): - _NAME = 'Option' + _NAME = "Option" _borrow_field_class_ptr = staticmethod( native_bt.field_class_option_borrow_field_class ) @@ -529,6 +578,46 @@ class _OptionFieldClass(_OptionFieldClassConst, _FieldClass): ) +class _OptionWithSelectorFieldClass( + _OptionWithSelectorFieldClassConst, _OptionFieldClass +): + _NAME = "Option (with selector)" + + +class _OptionWithBoolSelectorFieldClass( + _OptionWithBoolSelectorFieldClassConst, _OptionWithSelectorFieldClass +): + _NAME = "Option (with boolean selector)" + + def _selector_is_reversed(self, selector_is_reversed): + bt2_utils._check_bool(selector_is_reversed) + native_bt.field_class_option_with_selector_field_bool_set_selector_is_reversed( + self._ptr, selector_is_reversed + ) + + _selector_is_reversed = property(fset=_selector_is_reversed) + + +class _OptionWithIntegerSelectorFieldClass( + _OptionWithIntegerSelectorFieldClassConst, _OptionWithSelectorFieldClass +): + _NAME = "Option (with integer selector)" + + +class _OptionWithUnsignedIntegerSelectorFieldClass( + _OptionWithUnsignedIntegerSelectorFieldClassConst, + _OptionWithIntegerSelectorFieldClass, +): + _NAME = "Option (with unsigned integer selector)" + + +class _OptionWithSignedIntegerSelectorFieldClass( + _OptionWithSignedIntegerSelectorFieldClassConst, + _OptionWithIntegerSelectorFieldClass, +): + _NAME = "Option (with signed integer selector)" + + class _VariantFieldClassOptionConst: _create_field_class_from_ptr_and_get_ref = staticmethod( _create_field_class_from_const_ptr_and_get_ref @@ -584,13 +673,13 @@ class _VariantFieldClassOption(_VariantFieldClassOptionConst): def _user_attributes(self, user_attributes): value = bt2_value.create_value(user_attributes) - utils._check_type(value, bt2_value.MapValue) + bt2_utils._check_type(value, bt2_value.MapValue) native_bt.field_class_variant_option_set_user_attributes(self._ptr, value._ptr) _user_attributes = property(fset=_user_attributes) -class _VariantFieldClassWithSelectorOptionConst(_VariantFieldClassOptionConst): +class _VariantFieldClassWithIntegerSelectorOptionConst(_VariantFieldClassOptionConst): def __init__(self, owning_var_fc, spec_opt_ptr): self._spec_ptr = spec_opt_ptr super().__init__(owning_var_fc, self._as_option_ptr(spec_opt_ptr)) @@ -602,52 +691,52 @@ class _VariantFieldClassWithSelectorOptionConst(_VariantFieldClassOptionConst): return self._range_set_pycls._create_from_ptr_and_get_ref(range_set_ptr) -class _VariantFieldClassWithSelectorOption( - _VariantFieldClassWithSelectorOptionConst, _VariantFieldClassOption +class _VariantFieldClassWithIntegerSelectorOption( + _VariantFieldClassWithIntegerSelectorOptionConst, _VariantFieldClassOption ): pass -class _VariantFieldClassWithSignedSelectorOptionConst( - _VariantFieldClassWithSelectorOptionConst +class _VariantFieldClassWithSignedIntegerSelectorOptionConst( + _VariantFieldClassWithIntegerSelectorOptionConst ): _as_option_ptr = staticmethod( - native_bt.field_class_variant_with_selector_signed_option_as_option_const + native_bt.field_class_variant_with_selector_field_integer_signed_option_as_option_const ) _borrow_ranges_ptr = staticmethod( - native_bt.field_class_variant_with_selector_signed_option_borrow_ranges_const + native_bt.field_class_variant_with_selector_field_integer_signed_option_borrow_ranges_const ) - _range_set_pycls = bt2_integer_range_set.SignedIntegerRangeSet + _range_set_pycls = bt2_integer_range_set._SignedIntegerRangeSetConst -class _VariantFieldClassWithSignedSelectorOption( - _VariantFieldClassWithSignedSelectorOptionConst, - _VariantFieldClassWithSelectorOption, +class _VariantFieldClassWithSignedIntegerSelectorOption( + _VariantFieldClassWithSignedIntegerSelectorOptionConst, + _VariantFieldClassWithIntegerSelectorOption, ): pass -class _VariantFieldClassWithUnsignedSelectorOptionConst( - _VariantFieldClassWithSelectorOptionConst +class _VariantFieldClassWithUnsignedIntegerSelectorOptionConst( + _VariantFieldClassWithIntegerSelectorOptionConst ): _as_option_ptr = staticmethod( - native_bt.field_class_variant_with_selector_unsigned_option_as_option_const + native_bt.field_class_variant_with_selector_field_integer_unsigned_option_as_option_const ) _borrow_ranges_ptr = staticmethod( - native_bt.field_class_variant_with_selector_unsigned_option_borrow_ranges_const + native_bt.field_class_variant_with_selector_field_integer_unsigned_option_borrow_ranges_const ) - _range_set_pycls = bt2_integer_range_set.UnsignedIntegerRangeSet + _range_set_pycls = bt2_integer_range_set._UnsignedIntegerRangeSetConst -class _VariantFieldClassWithUnsignedSelectorOption( - _VariantFieldClassWithUnsignedSelectorOptionConst, - _VariantFieldClassWithSelectorOption, +class _VariantFieldClassWithUnsignedIntegerSelectorOption( + _VariantFieldClassWithUnsignedIntegerSelectorOptionConst, + _VariantFieldClassWithIntegerSelectorOption, ): pass class _VariantFieldClassConst(_FieldClassConst, collections.abc.Mapping): - _NAME = 'Const Variant' + _NAME = "Const variant" _borrow_option_ptr_by_name = staticmethod( native_bt.field_class_variant_borrow_option_by_name_const ) @@ -689,7 +778,7 @@ class _VariantFieldClassConst(_FieldClassConst, collections.abc.Mapping): yield native_bt.field_class_variant_option_get_name(base_opt_ptr) def option_at_index(self, index): - utils._check_uint64(index) + bt2_utils._check_uint64(index) if index >= len(self): raise IndexError @@ -700,7 +789,7 @@ class _VariantFieldClassConst(_FieldClassConst, collections.abc.Mapping): class _VariantFieldClass(_VariantFieldClassConst, _FieldClass, collections.abc.Mapping): - _NAME = 'Variant' + _NAME = "Variant" _borrow_option_ptr_by_name = staticmethod( native_bt.field_class_variant_borrow_option_by_name ) @@ -711,17 +800,17 @@ class _VariantFieldClass(_VariantFieldClassConst, _FieldClass, collections.abc.M class _VariantFieldClassWithoutSelectorConst(_VariantFieldClassConst): - _NAME = 'Const Variant (without selector)' + _NAME = "Const variant (without selector)" class _VariantFieldClassWithoutSelector( _VariantFieldClassWithoutSelectorConst, _VariantFieldClass ): - _NAME = 'Variant (without selector)' + _NAME = "Variant (without selector)" def append_option(self, name, field_class, user_attributes=None): - utils._check_str(name) - utils._check_type(field_class, _FieldClass) + bt2_utils._check_str(name) + bt2_utils._check_type(field_class, _FieldClass) if name in self: raise ValueError("duplicate option name '{}'".format(name)) @@ -735,8 +824,8 @@ class _VariantFieldClassWithoutSelector( status = native_bt.field_class_variant_without_selector_append_option( self._ptr, name, field_class._ptr ) - utils._handle_func_status( - status, 'cannot append option to variant field class object' + bt2_utils._handle_func_status( + status, "cannot append option to variant field class object" ) if user_attributes is not None: @@ -749,12 +838,12 @@ class _VariantFieldClassWithoutSelector( return self -class _VariantFieldClassWithSelectorConst(_VariantFieldClassConst): - _NAME = 'Const Variant (with selector)' +class _VariantFieldClassWithIntegerSelectorConst(_VariantFieldClassConst): + _NAME = "Const variant (with selector)" @property def selector_field_path(self): - ptr = native_bt.field_class_variant_with_selector_borrow_selector_field_path_const( + ptr = native_bt.field_class_variant_with_selector_field_borrow_selector_field_path_const( self._ptr ) @@ -764,21 +853,21 @@ class _VariantFieldClassWithSelectorConst(_VariantFieldClassConst): return bt2_field_path._FieldPathConst._create_from_ptr_and_get_ref(ptr) -class _VariantFieldClassWithSelector( - _VariantFieldClassWithSelectorConst, _VariantFieldClass +class _VariantFieldClassWithIntegerSelector( + _VariantFieldClassWithIntegerSelectorConst, _VariantFieldClass ): - _NAME = 'Variant (with selector)' + _NAME = "Variant (with selector)" def append_option(self, name, field_class, ranges, user_attributes=None): - utils._check_str(name) - utils._check_type(field_class, _FieldClass) - utils._check_type(ranges, self._variant_option_pycls._range_set_pycls) + bt2_utils._check_str(name) + bt2_utils._check_type(field_class, _FieldClass) + bt2_utils._check_type(ranges, self._variant_option_pycls._range_set_pycls) if name in self: raise ValueError("duplicate option name '{}'".format(name)) if len(ranges) == 0: - raise ValueError('range set is empty') + raise ValueError("range set is empty") user_attributes_value = None @@ -789,8 +878,8 @@ class _VariantFieldClassWithSelector( # TODO: check overlaps (precondition of self._append_option()) status = self._append_option(self._ptr, name, field_class._ptr, ranges._ptr) - utils._handle_func_status( - status, 'cannot append option to variant field class object' + bt2_utils._handle_func_status( + status, "cannot append option to variant field class object" ) if user_attributes is not None: @@ -803,49 +892,55 @@ class _VariantFieldClassWithSelector( return self -class _VariantFieldClassWithUnsignedSelectorConst(_VariantFieldClassWithSelectorConst): - _NAME = 'Const Variant (with unsigned selector)' +class _VariantFieldClassWithUnsignedIntegerSelectorConst( + _VariantFieldClassWithIntegerSelectorConst +): + _NAME = "Const variant (with unsigned integer selector)" _borrow_option_ptr_by_name = staticmethod( - native_bt.field_class_variant_with_selector_unsigned_borrow_option_by_name_const + native_bt.field_class_variant_with_selector_field_integer_unsigned_borrow_option_by_name_const ) _borrow_option_ptr_by_index = staticmethod( - native_bt.field_class_variant_with_selector_unsigned_borrow_option_by_index_const + native_bt.field_class_variant_with_selector_field_integer_unsigned_borrow_option_by_index_const ) - _variant_option_pycls = _VariantFieldClassWithUnsignedSelectorOptionConst + _variant_option_pycls = _VariantFieldClassWithUnsignedIntegerSelectorOptionConst _as_option_ptr = staticmethod(_variant_option_pycls._as_option_ptr) -class _VariantFieldClassWithUnsignedSelector( - _VariantFieldClassWithUnsignedSelectorConst, _VariantFieldClassWithSelector +class _VariantFieldClassWithUnsignedIntegerSelector( + _VariantFieldClassWithUnsignedIntegerSelectorConst, + _VariantFieldClassWithIntegerSelector, ): - _NAME = 'Variant (with unsigned selector)' - _variant_option_pycls = _VariantFieldClassWithUnsignedSelectorOption + _NAME = "Variant (with unsigned integer selector)" + _variant_option_pycls = _VariantFieldClassWithUnsignedIntegerSelectorOption _as_option_ptr = staticmethod(_variant_option_pycls._as_option_ptr) _append_option = staticmethod( - native_bt.field_class_variant_with_selector_unsigned_append_option + native_bt.field_class_variant_with_selector_field_integer_unsigned_append_option ) -class _VariantFieldClassWithSignedSelectorConst(_VariantFieldClassWithSelectorConst): - _NAME = 'Const Variant (with signed selector)' +class _VariantFieldClassWithSignedIntegerSelectorConst( + _VariantFieldClassWithIntegerSelectorConst +): + _NAME = "Const variant (with signed integer selector)" _borrow_option_ptr_by_name = staticmethod( - native_bt.field_class_variant_with_selector_signed_borrow_option_by_name_const + native_bt.field_class_variant_with_selector_field_integer_signed_borrow_option_by_name_const ) _borrow_option_ptr_by_index = staticmethod( - native_bt.field_class_variant_with_selector_signed_borrow_option_by_index_const + native_bt.field_class_variant_with_selector_field_integer_signed_borrow_option_by_index_const ) - _variant_option_pycls = _VariantFieldClassWithSignedSelectorOptionConst + _variant_option_pycls = _VariantFieldClassWithSignedIntegerSelectorOptionConst _as_option_ptr = staticmethod(_variant_option_pycls._as_option_ptr) -class _VariantFieldClassWithSignedSelector( - _VariantFieldClassWithSignedSelectorConst, _VariantFieldClassWithSelector +class _VariantFieldClassWithSignedIntegerSelector( + _VariantFieldClassWithSignedIntegerSelectorConst, + _VariantFieldClassWithIntegerSelector, ): - _NAME = 'Variant (with signed selector)' - _variant_option_pycls = _VariantFieldClassWithSignedSelectorOption + _NAME = "Variant (with signed integer selector)" + _variant_option_pycls = _VariantFieldClassWithSignedIntegerSelectorOption _as_option_ptr = staticmethod(_variant_option_pycls._as_option_ptr) _append_option = staticmethod( - native_bt.field_class_variant_with_selector_signed_append_option + native_bt.field_class_variant_with_selector_field_integer_signed_append_option ) @@ -873,7 +968,7 @@ class _ArrayFieldClass(_ArrayFieldClassConst, _FieldClass): class _StaticArrayFieldClassConst(_ArrayFieldClassConst): - _NAME = 'Const static array' + _NAME = "Const static array" @property def length(self): @@ -881,15 +976,19 @@ class _StaticArrayFieldClassConst(_ArrayFieldClassConst): class _StaticArrayFieldClass(_StaticArrayFieldClassConst, _ArrayFieldClass): - _NAME = 'Static array' + _NAME = "Static array" class _DynamicArrayFieldClassConst(_ArrayFieldClassConst): - _NAME = 'Const dynamic array' + _NAME = "Const dynamic array" + + +class _DynamicArrayWithLengthFieldFieldClassConst(_DynamicArrayFieldClassConst): + _NAME = "Const dynamic array (with length field)" @property def length_field_path(self): - ptr = native_bt.field_class_array_dynamic_borrow_length_field_path_const( + ptr = native_bt.field_class_array_dynamic_with_length_field_borrow_length_field_path_const( self._ptr ) if ptr is None: @@ -899,7 +998,13 @@ class _DynamicArrayFieldClassConst(_ArrayFieldClassConst): class _DynamicArrayFieldClass(_DynamicArrayFieldClassConst, _ArrayFieldClass): - _NAME = 'Dynamic Array' + _NAME = "Dynamic array" + + +class _DynamicArrayWithLengthFieldFieldClass( + _DynamicArrayWithLengthFieldFieldClassConst, _DynamicArrayFieldClass +): + _NAME = "Dynamic array (with length field)" _FIELD_CLASS_TYPE_TO_CONST_OBJ = { @@ -907,17 +1012,22 @@ _FIELD_CLASS_TYPE_TO_CONST_OBJ = { native_bt.FIELD_CLASS_TYPE_BIT_ARRAY: _BitArrayFieldClassConst, native_bt.FIELD_CLASS_TYPE_UNSIGNED_INTEGER: _UnsignedIntegerFieldClassConst, native_bt.FIELD_CLASS_TYPE_SIGNED_INTEGER: _SignedIntegerFieldClassConst, - native_bt.FIELD_CLASS_TYPE_REAL: _RealFieldClassConst, + native_bt.FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL: _SinglePrecisionRealFieldClassConst, + native_bt.FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL: _DoublePrecisionRealFieldClassConst, native_bt.FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION: _UnsignedEnumerationFieldClassConst, native_bt.FIELD_CLASS_TYPE_SIGNED_ENUMERATION: _SignedEnumerationFieldClassConst, native_bt.FIELD_CLASS_TYPE_STRING: _StringFieldClassConst, native_bt.FIELD_CLASS_TYPE_STRUCTURE: _StructureFieldClassConst, native_bt.FIELD_CLASS_TYPE_STATIC_ARRAY: _StaticArrayFieldClassConst, - native_bt.FIELD_CLASS_TYPE_DYNAMIC_ARRAY: _DynamicArrayFieldClassConst, - native_bt.FIELD_CLASS_TYPE_OPTION: _OptionFieldClassConst, - native_bt.FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR: _VariantFieldClassWithoutSelectorConst, - native_bt.FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_SELECTOR: _VariantFieldClassWithUnsignedSelectorConst, - native_bt.FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_SELECTOR: _VariantFieldClassWithSignedSelectorConst, + native_bt.FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD: _DynamicArrayFieldClassConst, + native_bt.FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD: _DynamicArrayWithLengthFieldFieldClassConst, + native_bt.FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD: _OptionFieldClassConst, + native_bt.FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD: _OptionWithBoolSelectorFieldClassConst, + native_bt.FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD: _OptionWithUnsignedIntegerSelectorFieldClassConst, + native_bt.FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD: _OptionWithSignedIntegerSelectorFieldClassConst, + native_bt.FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD: _VariantFieldClassWithoutSelectorConst, + native_bt.FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD: _VariantFieldClassWithUnsignedIntegerSelectorConst, + native_bt.FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD: _VariantFieldClassWithSignedIntegerSelectorConst, } _FIELD_CLASS_TYPE_TO_OBJ = { @@ -925,15 +1035,20 @@ _FIELD_CLASS_TYPE_TO_OBJ = { native_bt.FIELD_CLASS_TYPE_BIT_ARRAY: _BitArrayFieldClass, native_bt.FIELD_CLASS_TYPE_UNSIGNED_INTEGER: _UnsignedIntegerFieldClass, native_bt.FIELD_CLASS_TYPE_SIGNED_INTEGER: _SignedIntegerFieldClass, - native_bt.FIELD_CLASS_TYPE_REAL: _RealFieldClass, + native_bt.FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL: _SinglePrecisionRealFieldClass, + native_bt.FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL: _DoublePrecisionRealFieldClass, native_bt.FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION: _UnsignedEnumerationFieldClass, native_bt.FIELD_CLASS_TYPE_SIGNED_ENUMERATION: _SignedEnumerationFieldClass, native_bt.FIELD_CLASS_TYPE_STRING: _StringFieldClass, native_bt.FIELD_CLASS_TYPE_STRUCTURE: _StructureFieldClass, native_bt.FIELD_CLASS_TYPE_STATIC_ARRAY: _StaticArrayFieldClass, - native_bt.FIELD_CLASS_TYPE_DYNAMIC_ARRAY: _DynamicArrayFieldClass, - native_bt.FIELD_CLASS_TYPE_OPTION: _OptionFieldClass, - native_bt.FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR: _VariantFieldClassWithoutSelector, - native_bt.FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_SELECTOR: _VariantFieldClassWithUnsignedSelector, - native_bt.FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_SELECTOR: _VariantFieldClassWithSignedSelector, + native_bt.FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD: _DynamicArrayFieldClass, + native_bt.FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD: _DynamicArrayWithLengthFieldFieldClass, + native_bt.FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD: _OptionFieldClass, + native_bt.FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD: _OptionWithBoolSelectorFieldClass, + native_bt.FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD: _OptionWithUnsignedIntegerSelectorFieldClass, + native_bt.FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD: _OptionWithSignedIntegerSelectorFieldClass, + native_bt.FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD: _VariantFieldClassWithoutSelector, + native_bt.FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD: _VariantFieldClassWithUnsignedIntegerSelector, + native_bt.FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD: _VariantFieldClassWithSignedIntegerSelector, }