src/bindings/python/bt2/bt2/field_class.py

   1 # The MIT License (MIT)
   2 #
   3 # Copyright (c) 2017 Philippe Proulx <pproulx@efficios.com>
   4 #
   5 # Permission is hereby granted, free of charge, to any person obtaining a copy
   6 # of this software and associated documentation files (the "Software"), to deal
   7 # in the Software without restriction, including without limitation the rights
   8 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   9 # copies of the Software, and to permit persons to whom the Software is
  10 # furnished to do so, subject to the following conditions:
  11 #
  12 # The above copyright notice and this permission notice shall be included in
  13 # all copies or substantial portions of the Software.
  14 #
  15 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  21 # THE SOFTWARE.
  22
  23 from bt2 import native_bt, object, utils
  24 import collections.abc
  25 from bt2 import field_path as bt2_field_path
  26 from bt2 import integer_range_set as bt2_integer_range_set
  27 from bt2 import value as bt2_value
  28 import bt2
  29
  30
  31 def _create_field_class_from_ptr_and_get_ref_template(type_map, ptr):
  32     typeid = native_bt.field_class_get_type(ptr)
  33     return type_map[typeid]._create_from_ptr_and_get_ref(ptr)
  34
  35
  36 def _create_field_class_from_ptr_and_get_ref(ptr):
  37     return _create_field_class_from_ptr_and_get_ref_template(
  38         _FIELD_CLASS_TYPE_TO_OBJ, ptr
  39     )
  40
  41
  42 def _create_field_class_from_const_ptr_and_get_ref(ptr):
  43     return _create_field_class_from_ptr_and_get_ref_template(
  44         _FIELD_CLASS_TYPE_TO_CONST_OBJ, ptr
  45     )
  46
  47
  48 class IntegerDisplayBase:
  49     BINARY = native_bt.FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_BINARY
  50     OCTAL = native_bt.FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_OCTAL
  51     DECIMAL = native_bt.FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL
  52     HEXADECIMAL = native_bt.FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL
  53
  54
  55 class _FieldClassConst(object._SharedObject):
  56     _get_ref = staticmethod(native_bt.field_class_get_ref)
  57     _put_ref = staticmethod(native_bt.field_class_put_ref)
  58     _borrow_user_attributes_ptr = staticmethod(
  59         native_bt.field_class_borrow_user_attributes_const
  60     )
  61     _create_value_from_ptr_and_get_ref = staticmethod(
  62         bt2_value._create_from_const_ptr_and_get_ref
  63     )
  64
  65     def _check_create_status(self, ptr):
  66         if ptr is None:
  67             raise bt2._MemoryError(
  68                 'cannot create {} field class object'.format(self._NAME.lower())
  69             )
  70
  71     @property
  72     def user_attributes(self):
  73         ptr = self._borrow_user_attributes_ptr(self._ptr)
  74         assert ptr is not None
  75         return self._create_value_from_ptr_and_get_ref(ptr)
  76
  77
  78 class _FieldClass(_FieldClassConst):
  79     _borrow_user_attributes_ptr = staticmethod(
  80         native_bt.field_class_borrow_user_attributes
  81     )
  82     _create_value_from_ptr_and_get_ref = staticmethod(
  83         bt2_value._create_from_ptr_and_get_ref
  84     )
  85
  86     def _user_attributes(self, user_attributes):
  87         value = bt2_value.create_value(user_attributes)
  88         utils._check_type(value, bt2_value.MapValue)
  89         native_bt.field_class_set_user_attributes(self._ptr, value._ptr)
  90
  91     _user_attributes = property(fset=_user_attributes)
  92
  93
  94 class _BoolFieldClassConst(_FieldClassConst):
  95     _NAME = 'Const Boolean'
  96
  97
  98 class _BoolFieldClass(_BoolFieldClassConst, _FieldClass):
  99     _NAME = 'Boolean'
 100
 101
 102 class _BitArrayFieldClassConst(_FieldClassConst):
 103     _NAME = 'Const Bit array'
 104
 105     @property
 106     def length(self):
 107         length = native_bt.field_class_bit_array_get_length(self._ptr)
 108         assert length >= 1
 109         return length
 110
 111
 112 class _BitArrayFieldClass(_BitArrayFieldClassConst, _FieldClass):
 113     _NAME = 'Bit array'
 114
 115
 116 class _IntegerFieldClassConst(_FieldClassConst):
 117     @property
 118     def field_value_range(self):
 119         size = native_bt.field_class_integer_get_field_value_range(self._ptr)
 120         assert size >= 1
 121         return size
 122
 123     @property
 124     def preferred_display_base(self):
 125         base = native_bt.field_class_integer_get_preferred_display_base(self._ptr)
 126         assert base >= 0
 127         return base
 128
 129
 130 class _IntegerFieldClass(_FieldClass, _IntegerFieldClassConst):
 131     def _field_value_range(self, size):
 132         if size < 1 or size > 64:
 133             raise ValueError("Value is outside valid range [1, 64] ({})".format(size))
 134         native_bt.field_class_integer_set_field_value_range(self._ptr, size)
 135
 136     _field_value_range = property(fset=_field_value_range)
 137
 138     def _preferred_display_base(self, base):
 139         utils._check_uint64(base)
 140
 141         if base not in (
 142             IntegerDisplayBase.BINARY,
 143             IntegerDisplayBase.OCTAL,
 144             IntegerDisplayBase.DECIMAL,
 145             IntegerDisplayBase.HEXADECIMAL,
 146         ):
 147             raise ValueError("Display base is not a valid IntegerDisplayBase value")
 148
 149         native_bt.field_class_integer_set_preferred_display_base(self._ptr, base)
 150
 151     _preferred_display_base = property(fset=_preferred_display_base)
 152
 153
 154 class _UnsignedIntegerFieldClassConst(_IntegerFieldClassConst, _FieldClassConst):
 155     _NAME = 'Const unsigned integer'
 156
 157
 158 class _UnsignedIntegerFieldClass(
 159     _UnsignedIntegerFieldClassConst, _IntegerFieldClass, _FieldClass
 160 ):
 161     _NAME = 'Unsigned integer'
 162
 163
 164 class _SignedIntegerFieldClassConst(_IntegerFieldClassConst, _FieldClassConst):
 165     _NAME = 'Const signed integer'
 166
 167
 168 class _SignedIntegerFieldClass(
 169     _SignedIntegerFieldClassConst, _IntegerFieldClass, _FieldClass
 170 ):
 171     _NAME = 'Signed integer'
 172
 173
 174 class _RealFieldClassConst(_FieldClassConst):
 175     pass
 176
 177
 178 class _SinglePrecisionRealFieldClassConst(_RealFieldClassConst):
 179     _NAME = 'Const single-precision real'
 180
 181
 182 class _DoublePrecisionRealFieldClassConst(_RealFieldClassConst):
 183     _NAME = 'Const double-precision real'
 184
 185
 186 class _RealFieldClass(_FieldClass, _RealFieldClassConst):
 187     pass
 188
 189
 190 class _SinglePrecisionRealFieldClass(_RealFieldClass):
 191     _NAME = 'Single-precision real'
 192
 193
 194 class _DoublePrecisionRealFieldClass(_RealFieldClass):
 195     _NAME = 'Double-precision real'
 196
 197
 198 # an enumeration field class mapping does not have a reference count, so
 199 # we copy the properties here to avoid eventual memory access errors.
 200 class _EnumerationFieldClassMapping:
 201     def __init__(self, mapping_ptr):
 202         base_mapping_ptr = self._as_enumeration_field_class_mapping_ptr(mapping_ptr)
 203         self._label = native_bt.field_class_enumeration_mapping_get_label(
 204             base_mapping_ptr
 205         )
 206         assert self._label is not None
 207         ranges_ptr = self._mapping_borrow_ranges_ptr(mapping_ptr)
 208         assert ranges_ptr is not None
 209         self._ranges = self._range_set_pycls._create_from_ptr_and_get_ref(ranges_ptr)
 210
 211     @property
 212     def label(self):
 213         return self._label
 214
 215     @property
 216     def ranges(self):
 217         return self._ranges
 218
 219
 220 class _UnsignedEnumerationFieldClassMappingConst(_EnumerationFieldClassMapping):
 221     _range_set_pycls = bt2_integer_range_set.UnsignedIntegerRangeSet
 222     _as_enumeration_field_class_mapping_ptr = staticmethod(
 223         native_bt.field_class_enumeration_unsigned_mapping_as_mapping_const
 224     )
 225     _mapping_borrow_ranges_ptr = staticmethod(
 226         native_bt.field_class_enumeration_unsigned_mapping_borrow_ranges_const
 227     )
 228
 229
 230 class _SignedEnumerationFieldClassMappingConst(_EnumerationFieldClassMapping):
 231     _range_set_pycls = bt2_integer_range_set.SignedIntegerRangeSet
 232     _as_enumeration_field_class_mapping_ptr = staticmethod(
 233         native_bt.field_class_enumeration_signed_mapping_as_mapping_const
 234     )
 235     _mapping_borrow_ranges_ptr = staticmethod(
 236         native_bt.field_class_enumeration_signed_mapping_borrow_ranges_const
 237     )
 238
 239
 240 class _EnumerationFieldClassConst(_IntegerFieldClassConst, collections.abc.Mapping):
 241     def __len__(self):
 242         count = native_bt.field_class_enumeration_get_mapping_count(self._ptr)
 243         assert count >= 0
 244         return count
 245
 246     def mappings_for_value(self, value):
 247         self._check_int_type(value)
 248
 249         status, labels = self._get_mapping_labels_for_value(self._ptr, value)
 250         utils._handle_func_status(
 251             status, 'cannot get mapping labels for value {}'.format(value)
 252         )
 253         return [self[label] for label in labels]
 254
 255     def __iter__(self):
 256         for idx in range(len(self)):
 257             mapping_ptr = self._borrow_mapping_ptr_by_index(self._ptr, idx)
 258             yield self._mapping_pycls(mapping_ptr).label
 259
 260     def __getitem__(self, label):
 261         utils._check_str(label)
 262         mapping_ptr = self._borrow_mapping_ptr_by_label(self._ptr, label)
 263
 264         if mapping_ptr is None:
 265             raise KeyError(label)
 266
 267         return self._mapping_pycls(mapping_ptr)
 268
 269
 270 class _EnumerationFieldClass(_EnumerationFieldClassConst, _IntegerFieldClass):
 271     def add_mapping(self, label, ranges):
 272         utils._check_str(label)
 273         utils._check_type(ranges, self._range_set_pycls)
 274
 275         if label in self:
 276             raise ValueError("duplicate mapping label '{}'".format(label))
 277
 278         status = self._add_mapping(self._ptr, label, ranges._ptr)
 279         utils._handle_func_status(
 280             status, 'cannot add mapping to enumeration field class object'
 281         )
 282
 283     def __iadd__(self, mappings):
 284         for label, ranges in mappings:
 285             self.add_mapping(label, ranges)
 286
 287         return self
 288
 289
 290 class _UnsignedEnumerationFieldClassConst(
 291     _EnumerationFieldClassConst, _UnsignedIntegerFieldClassConst
 292 ):
 293     _NAME = 'Const unsigned enumeration'
 294     _range_set_pycls = bt2_integer_range_set.UnsignedIntegerRangeSet
 295     _borrow_mapping_ptr_by_label = staticmethod(
 296         native_bt.field_class_enumeration_unsigned_borrow_mapping_by_label_const
 297     )
 298     _borrow_mapping_ptr_by_index = staticmethod(
 299         native_bt.field_class_enumeration_unsigned_borrow_mapping_by_index_const
 300     )
 301     _mapping_pycls = property(lambda _: _UnsignedEnumerationFieldClassMappingConst)
 302     _get_mapping_labels_for_value = staticmethod(
 303         native_bt.field_class_enumeration_unsigned_get_mapping_labels_for_value
 304     )
 305     _check_int_type = staticmethod(utils._check_uint64)
 306
 307
 308 class _UnsignedEnumerationFieldClass(
 309     _UnsignedEnumerationFieldClassConst,
 310     _EnumerationFieldClass,
 311     _UnsignedIntegerFieldClass,
 312 ):
 313     _NAME = 'Unsigned enumeration'
 314     _add_mapping = staticmethod(native_bt.field_class_enumeration_unsigned_add_mapping)
 315
 316
 317 class _SignedEnumerationFieldClassConst(
 318     _EnumerationFieldClassConst, _SignedIntegerFieldClassConst
 319 ):
 320     _NAME = 'Const signed enumeration'
 321     _range_set_pycls = bt2_integer_range_set.SignedIntegerRangeSet
 322     _borrow_mapping_ptr_by_label = staticmethod(
 323         native_bt.field_class_enumeration_signed_borrow_mapping_by_label_const
 324     )
 325     _borrow_mapping_ptr_by_index = staticmethod(
 326         native_bt.field_class_enumeration_signed_borrow_mapping_by_index_const
 327     )
 328     _mapping_pycls = property(lambda _: _SignedEnumerationFieldClassMappingConst)
 329     _get_mapping_labels_for_value = staticmethod(
 330         native_bt.field_class_enumeration_signed_get_mapping_labels_for_value
 331     )
 332     _check_int_type = staticmethod(utils._check_int64)
 333
 334
 335 class _SignedEnumerationFieldClass(
 336     _SignedEnumerationFieldClassConst, _EnumerationFieldClass, _SignedIntegerFieldClass
 337 ):
 338     _NAME = 'Signed enumeration'
 339     _add_mapping = staticmethod(native_bt.field_class_enumeration_signed_add_mapping)
 340
 341
 342 class _StringFieldClassConst(_FieldClassConst):
 343     _NAME = 'Const string'
 344
 345
 346 class _StringFieldClass(_StringFieldClassConst, _FieldClass):
 347     _NAME = 'String'
 348
 349
 350 class _StructureFieldClassMemberConst:
 351     _create_field_class_from_ptr_and_get_ref = staticmethod(
 352         _create_field_class_from_const_ptr_and_get_ref
 353     )
 354     _borrow_field_class_ptr = staticmethod(
 355         native_bt.field_class_structure_member_borrow_field_class_const
 356     )
 357     _borrow_user_attributes_ptr = staticmethod(
 358         native_bt.field_class_structure_member_borrow_user_attributes_const
 359     )
 360     _create_value_from_ptr_and_get_ref = staticmethod(
 361         bt2_value._create_from_const_ptr_and_get_ref
 362     )
 363
 364     def __init__(self, owning_struct_fc, member_ptr):
 365         # this field class owns the member; keeping it here maintains
 366         # the member alive as members are not shared objects
 367         self._owning_struct_fc = owning_struct_fc
 368         self._ptr = member_ptr
 369
 370     @property
 371     def name(self):
 372         name = native_bt.field_class_structure_member_get_name(self._ptr)
 373         assert name is not None
 374         return name
 375
 376     @property
 377     def field_class(self):
 378         fc_ptr = self._borrow_field_class_ptr(self._ptr)
 379         assert fc_ptr is not None
 380         return self._create_field_class_from_ptr_and_get_ref(fc_ptr)
 381
 382     @property
 383     def user_attributes(self):
 384         ptr = self._borrow_user_attributes_ptr(self._ptr)
 385         assert ptr is not None
 386         return self._create_value_from_ptr_and_get_ref(ptr)
 387
 388
 389 class _StructureFieldClassMember(_StructureFieldClassMemberConst):
 390     _borrow_field_class_ptr = staticmethod(
 391         native_bt.field_class_structure_member_borrow_field_class
 392     )
 393     _borrow_user_attributes_ptr = staticmethod(
 394         native_bt.field_class_structure_member_borrow_user_attributes
 395     )
 396     _create_field_class_from_ptr_and_get_ref = staticmethod(
 397         _create_field_class_from_ptr_and_get_ref
 398     )
 399     _create_value_from_ptr_and_get_ref = staticmethod(
 400         bt2_value._create_from_ptr_and_get_ref
 401     )
 402
 403     def _user_attributes(self, user_attributes):
 404         value = bt2_value.create_value(user_attributes)
 405         utils._check_type(value, bt2_value.MapValue)
 406         native_bt.field_class_structure_member_set_user_attributes(
 407             self._ptr, value._ptr
 408         )
 409
 410     _user_attributes = property(fset=_user_attributes)
 411
 412
 413 class _StructureFieldClassConst(_FieldClassConst, collections.abc.Mapping):
 414     _NAME = 'Const structure'
 415     _borrow_member_ptr_by_index = staticmethod(
 416         native_bt.field_class_structure_borrow_member_by_index_const
 417     )
 418     _borrow_member_ptr_by_name = staticmethod(
 419         native_bt.field_class_structure_borrow_member_by_name_const
 420     )
 421     _structure_member_field_class_pycls = property(
 422         lambda _: _StructureFieldClassMemberConst
 423     )
 424
 425     def __len__(self):
 426         count = native_bt.field_class_structure_get_member_count(self._ptr)
 427         assert count >= 0
 428         return count
 429
 430     def __getitem__(self, key):
 431         if not isinstance(key, str):
 432             raise TypeError(
 433                 "key must be a 'str' object, got '{}'".format(key.__class__.__name__)
 434             )
 435
 436         member_ptr = self._borrow_member_ptr_by_name(self._ptr, key)
 437
 438         if member_ptr is None:
 439             raise KeyError(key)
 440
 441         return self._structure_member_field_class_pycls(self, member_ptr)
 442
 443     def __iter__(self):
 444         for idx in range(len(self)):
 445             member_ptr = self._borrow_member_ptr_by_index(self._ptr, idx)
 446             assert member_ptr is not None
 447             yield native_bt.field_class_structure_member_get_name(member_ptr)
 448
 449     def member_at_index(self, index):
 450         utils._check_uint64(index)
 451
 452         if index >= len(self):
 453             raise IndexError
 454
 455         member_ptr = self._borrow_member_ptr_by_index(self._ptr, index)
 456         assert member_ptr is not None
 457         return self._structure_member_field_class_pycls(self, member_ptr)
 458
 459
 460 class _StructureFieldClass(_StructureFieldClassConst, _FieldClass):
 461     _NAME = 'Structure'
 462     _borrow_member_by_index = staticmethod(
 463         native_bt.field_class_structure_borrow_member_by_index
 464     )
 465     _borrow_member_ptr_by_name = staticmethod(
 466         native_bt.field_class_structure_borrow_member_by_name
 467     )
 468     _structure_member_field_class_pycls = property(lambda _: _StructureFieldClassMember)
 469
 470     def append_member(self, name, field_class, user_attributes=None):
 471         utils._check_str(name)
 472         utils._check_type(field_class, _FieldClass)
 473
 474         if name in self:
 475             raise ValueError("duplicate member name '{}'".format(name))
 476
 477         user_attributes_value = None
 478
 479         if user_attributes is not None:
 480             # check now that user attributes are valid
 481             user_attributes_value = bt2.create_value(user_attributes)
 482
 483         status = native_bt.field_class_structure_append_member(
 484             self._ptr, name, field_class._ptr
 485         )
 486         utils._handle_func_status(
 487             status, 'cannot append member to structure field class object'
 488         )
 489
 490         if user_attributes is not None:
 491             self[name]._user_attributes = user_attributes_value
 492
 493     def __iadd__(self, members):
 494         for name, field_class in members:
 495             self.append_member(name, field_class)
 496
 497         return self
 498
 499
 500 class _OptionFieldClassConst(_FieldClassConst):
 501     _NAME = 'Const Option'
 502     _create_field_class_from_ptr_and_get_ref = staticmethod(
 503         _create_field_class_from_const_ptr_and_get_ref
 504     )
 505     _borrow_field_class_ptr = staticmethod(
 506         native_bt.field_class_option_borrow_field_class_const
 507     )
 508     _borrow_selector_field_path = staticmethod(
 509         native_bt.field_class_option_borrow_selector_field_path_const
 510     )
 511
 512     @property
 513     def field_class(self):
 514         elem_fc_ptr = self._borrow_field_class_ptr(self._ptr)
 515         return self._create_field_class_from_ptr_and_get_ref(elem_fc_ptr)
 516
 517     @property
 518     def selector_field_path(self):
 519         ptr = self._borrow_selector_field_path(self._ptr)
 520         if ptr is None:
 521             return
 522
 523         return bt2_field_path._FieldPathConst._create_from_ptr_and_get_ref(ptr)
 524
 525
 526 class _OptionFieldClass(_OptionFieldClassConst, _FieldClass):
 527     _NAME = 'Option'
 528     _borrow_field_class_ptr = staticmethod(
 529         native_bt.field_class_option_borrow_field_class
 530     )
 531     _create_field_class_from_ptr_and_get_ref = staticmethod(
 532         _create_field_class_from_ptr_and_get_ref
 533     )
 534
 535
 536 class _VariantFieldClassOptionConst:
 537     _create_field_class_from_ptr_and_get_ref = staticmethod(
 538         _create_field_class_from_const_ptr_and_get_ref
 539     )
 540     _borrow_field_class_ptr = staticmethod(
 541         native_bt.field_class_variant_option_borrow_field_class_const
 542     )
 543     _borrow_user_attributes_ptr = staticmethod(
 544         native_bt.field_class_variant_option_borrow_user_attributes_const
 545     )
 546     _create_value_from_ptr_and_get_ref = staticmethod(
 547         bt2_value._create_from_const_ptr_and_get_ref
 548     )
 549
 550     def __init__(self, owning_var_fc, option_ptr):
 551         # this field class owns the option; keeping it here maintains
 552         # the option alive as options are not shared objects
 553         self._owning_var_fc = owning_var_fc
 554         self._ptr = option_ptr
 555
 556     @property
 557     def name(self):
 558         name = native_bt.field_class_variant_option_get_name(self._ptr)
 559         assert name is not None
 560         return name
 561
 562     @property
 563     def field_class(self):
 564         fc_ptr = self._borrow_field_class_ptr(self._ptr)
 565         assert fc_ptr is not None
 566         return self._create_field_class_from_ptr_and_get_ref(fc_ptr)
 567
 568     @property
 569     def user_attributes(self):
 570         ptr = self._borrow_user_attributes_ptr(self._ptr)
 571         assert ptr is not None
 572         return self._create_value_from_ptr_and_get_ref(ptr)
 573
 574
 575 class _VariantFieldClassOption(_VariantFieldClassOptionConst):
 576     _create_field_class_from_ptr_and_get_ref = staticmethod(
 577         _create_field_class_from_ptr_and_get_ref
 578     )
 579     _borrow_field_class_ptr = staticmethod(
 580         native_bt.field_class_variant_option_borrow_field_class
 581     )
 582     _borrow_user_attributes_ptr = staticmethod(
 583         native_bt.field_class_variant_option_borrow_user_attributes
 584     )
 585     _create_value_from_ptr_and_get_ref = staticmethod(
 586         bt2_value._create_from_ptr_and_get_ref
 587     )
 588
 589     def _user_attributes(self, user_attributes):
 590         value = bt2_value.create_value(user_attributes)
 591         utils._check_type(value, bt2_value.MapValue)
 592         native_bt.field_class_variant_option_set_user_attributes(self._ptr, value._ptr)
 593
 594     _user_attributes = property(fset=_user_attributes)
 595
 596
 597 class _VariantFieldClassWithSelectorOptionConst(_VariantFieldClassOptionConst):
 598     def __init__(self, owning_var_fc, spec_opt_ptr):
 599         self._spec_ptr = spec_opt_ptr
 600         super().__init__(owning_var_fc, self._as_option_ptr(spec_opt_ptr))
 601
 602     @property
 603     def ranges(self):
 604         range_set_ptr = self._borrow_ranges_ptr(self._spec_ptr)
 605         assert range_set_ptr is not None
 606         return self._range_set_pycls._create_from_ptr_and_get_ref(range_set_ptr)
 607
 608
 609 class _VariantFieldClassWithSelectorOption(
 610     _VariantFieldClassWithSelectorOptionConst, _VariantFieldClassOption
 611 ):
 612     pass
 613
 614
 615 class _VariantFieldClassWithSignedSelectorOptionConst(
 616     _VariantFieldClassWithSelectorOptionConst
 617 ):
 618     _as_option_ptr = staticmethod(
 619         native_bt.field_class_variant_with_selector_signed_option_as_option_const
 620     )
 621     _borrow_ranges_ptr = staticmethod(
 622         native_bt.field_class_variant_with_selector_signed_option_borrow_ranges_const
 623     )
 624     _range_set_pycls = bt2_integer_range_set.SignedIntegerRangeSet
 625
 626
 627 class _VariantFieldClassWithSignedSelectorOption(
 628     _VariantFieldClassWithSignedSelectorOptionConst,
 629     _VariantFieldClassWithSelectorOption,
 630 ):
 631     pass
 632
 633
 634 class _VariantFieldClassWithUnsignedSelectorOptionConst(
 635     _VariantFieldClassWithSelectorOptionConst
 636 ):
 637     _as_option_ptr = staticmethod(
 638         native_bt.field_class_variant_with_selector_unsigned_option_as_option_const
 639     )
 640     _borrow_ranges_ptr = staticmethod(
 641         native_bt.field_class_variant_with_selector_unsigned_option_borrow_ranges_const
 642     )
 643     _range_set_pycls = bt2_integer_range_set.UnsignedIntegerRangeSet
 644
 645
 646 class _VariantFieldClassWithUnsignedSelectorOption(
 647     _VariantFieldClassWithUnsignedSelectorOptionConst,
 648     _VariantFieldClassWithSelectorOption,
 649 ):
 650     pass
 651
 652
 653 class _VariantFieldClassConst(_FieldClassConst, collections.abc.Mapping):
 654     _NAME = 'Const Variant'
 655     _borrow_option_ptr_by_name = staticmethod(
 656         native_bt.field_class_variant_borrow_option_by_name_const
 657     )
 658     _borrow_option_ptr_by_index = staticmethod(
 659         native_bt.field_class_variant_borrow_option_by_index_const
 660     )
 661     _variant_option_pycls = _VariantFieldClassOptionConst
 662
 663     @staticmethod
 664     def _as_option_ptr(opt_ptr):
 665         return opt_ptr
 666
 667     def _create_option_from_ptr(self, opt_ptr):
 668         return self._variant_option_pycls(self, opt_ptr)
 669
 670     def __len__(self):
 671         count = native_bt.field_class_variant_get_option_count(self._ptr)
 672         assert count >= 0
 673         return count
 674
 675     def __getitem__(self, key):
 676         if not isinstance(key, str):
 677             raise TypeError(
 678                 "key must be a 'str' object, got '{}'".format(key.__class__.__name__)
 679             )
 680
 681         opt_ptr = self._borrow_option_ptr_by_name(self._ptr, key)
 682
 683         if opt_ptr is None:
 684             raise KeyError(key)
 685
 686         return self._create_option_from_ptr(opt_ptr)
 687
 688     def __iter__(self):
 689         for idx in range(len(self)):
 690             opt_ptr = self._borrow_option_ptr_by_index(self._ptr, idx)
 691             assert opt_ptr is not None
 692             base_opt_ptr = self._as_option_ptr(opt_ptr)
 693             yield native_bt.field_class_variant_option_get_name(base_opt_ptr)
 694
 695     def option_at_index(self, index):
 696         utils._check_uint64(index)
 697
 698         if index >= len(self):
 699             raise IndexError
 700
 701         opt_ptr = self._borrow_option_ptr_by_index(self._ptr, index)
 702         assert opt_ptr is not None
 703         return self._create_option_from_ptr(opt_ptr)
 704
 705
 706 class _VariantFieldClass(_VariantFieldClassConst, _FieldClass, collections.abc.Mapping):
 707     _NAME = 'Variant'
 708     _borrow_option_ptr_by_name = staticmethod(
 709         native_bt.field_class_variant_borrow_option_by_name
 710     )
 711     _borrow_option_ptr_by_index = staticmethod(
 712         native_bt.field_class_variant_borrow_option_by_index
 713     )
 714     _variant_option_pycls = _VariantFieldClassOption
 715
 716
 717 class _VariantFieldClassWithoutSelectorConst(_VariantFieldClassConst):
 718     _NAME = 'Const Variant (without selector)'
 719
 720
 721 class _VariantFieldClassWithoutSelector(
 722     _VariantFieldClassWithoutSelectorConst, _VariantFieldClass
 723 ):
 724     _NAME = 'Variant (without selector)'
 725
 726     def append_option(self, name, field_class, user_attributes=None):
 727         utils._check_str(name)
 728         utils._check_type(field_class, _FieldClass)
 729
 730         if name in self:
 731             raise ValueError("duplicate option name '{}'".format(name))
 732
 733         user_attributes_value = None
 734
 735         if user_attributes is not None:
 736             # check now that user attributes are valid
 737             user_attributes_value = bt2.create_value(user_attributes)
 738
 739         status = native_bt.field_class_variant_without_selector_append_option(
 740             self._ptr, name, field_class._ptr
 741         )
 742         utils._handle_func_status(
 743             status, 'cannot append option to variant field class object'
 744         )
 745
 746         if user_attributes is not None:
 747             self[name]._user_attributes = user_attributes_value
 748
 749     def __iadd__(self, options):
 750         for name, field_class in options:
 751             self.append_option(name, field_class)
 752
 753         return self
 754
 755
 756 class _VariantFieldClassWithSelectorConst(_VariantFieldClassConst):
 757     _NAME = 'Const Variant (with selector)'
 758
 759     @property
 760     def selector_field_path(self):
 761         ptr = native_bt.field_class_variant_with_selector_borrow_selector_field_path_const(
 762             self._ptr
 763         )
 764
 765         if ptr is None:
 766             return
 767
 768         return bt2_field_path._FieldPathConst._create_from_ptr_and_get_ref(ptr)
 769
 770
 771 class _VariantFieldClassWithSelector(
 772     _VariantFieldClassWithSelectorConst, _VariantFieldClass
 773 ):
 774     _NAME = 'Variant (with selector)'
 775
 776     def append_option(self, name, field_class, ranges, user_attributes=None):
 777         utils._check_str(name)
 778         utils._check_type(field_class, _FieldClass)
 779         utils._check_type(ranges, self._variant_option_pycls._range_set_pycls)
 780
 781         if name in self:
 782             raise ValueError("duplicate option name '{}'".format(name))
 783
 784         if len(ranges) == 0:
 785             raise ValueError('range set is empty')
 786
 787         user_attributes_value = None
 788
 789         if user_attributes is not None:
 790             # check now that user attributes are valid
 791             user_attributes_value = bt2.create_value(user_attributes)
 792
 793         # TODO: check overlaps (precondition of self._append_option())
 794
 795         status = self._append_option(self._ptr, name, field_class._ptr, ranges._ptr)
 796         utils._handle_func_status(
 797             status, 'cannot append option to variant field class object'
 798         )
 799
 800         if user_attributes is not None:
 801             self[name]._user_attributes = user_attributes_value
 802
 803     def __iadd__(self, options):
 804         for name, field_class, ranges in options:
 805             self.append_option(name, field_class, ranges)
 806
 807         return self
 808
 809
 810 class _VariantFieldClassWithUnsignedSelectorConst(_VariantFieldClassWithSelectorConst):
 811     _NAME = 'Const Variant (with unsigned selector)'
 812     _borrow_option_ptr_by_name = staticmethod(
 813         native_bt.field_class_variant_with_selector_unsigned_borrow_option_by_name_const
 814     )
 815     _borrow_option_ptr_by_index = staticmethod(
 816         native_bt.field_class_variant_with_selector_unsigned_borrow_option_by_index_const
 817     )
 818     _variant_option_pycls = _VariantFieldClassWithUnsignedSelectorOptionConst
 819     _as_option_ptr = staticmethod(_variant_option_pycls._as_option_ptr)
 820
 821
 822 class _VariantFieldClassWithUnsignedSelector(
 823     _VariantFieldClassWithUnsignedSelectorConst, _VariantFieldClassWithSelector
 824 ):
 825     _NAME = 'Variant (with unsigned selector)'
 826     _variant_option_pycls = _VariantFieldClassWithUnsignedSelectorOption
 827     _as_option_ptr = staticmethod(_variant_option_pycls._as_option_ptr)
 828     _append_option = staticmethod(
 829         native_bt.field_class_variant_with_selector_unsigned_append_option
 830     )
 831
 832
 833 class _VariantFieldClassWithSignedSelectorConst(_VariantFieldClassWithSelectorConst):
 834     _NAME = 'Const Variant (with signed selector)'
 835     _borrow_option_ptr_by_name = staticmethod(
 836         native_bt.field_class_variant_with_selector_signed_borrow_option_by_name_const
 837     )
 838     _borrow_option_ptr_by_index = staticmethod(
 839         native_bt.field_class_variant_with_selector_signed_borrow_option_by_index_const
 840     )
 841     _variant_option_pycls = _VariantFieldClassWithSignedSelectorOptionConst
 842     _as_option_ptr = staticmethod(_variant_option_pycls._as_option_ptr)
 843
 844
 845 class _VariantFieldClassWithSignedSelector(
 846     _VariantFieldClassWithSignedSelectorConst, _VariantFieldClassWithSelector
 847 ):
 848     _NAME = 'Variant (with signed selector)'
 849     _variant_option_pycls = _VariantFieldClassWithSignedSelectorOption
 850     _as_option_ptr = staticmethod(_variant_option_pycls._as_option_ptr)
 851     _append_option = staticmethod(
 852         native_bt.field_class_variant_with_selector_signed_append_option
 853     )
 854
 855
 856 class _ArrayFieldClassConst(_FieldClassConst):
 857     _create_field_class_from_ptr_and_get_ref = staticmethod(
 858         _create_field_class_from_const_ptr_and_get_ref
 859     )
 860     _borrow_element_field_class = staticmethod(
 861         native_bt.field_class_array_borrow_element_field_class_const
 862     )
 863
 864     @property
 865     def element_field_class(self):
 866         elem_fc_ptr = self._borrow_element_field_class(self._ptr)
 867         return self._create_field_class_from_ptr_and_get_ref(elem_fc_ptr)
 868
 869
 870 class _ArrayFieldClass(_ArrayFieldClassConst, _FieldClass):
 871     _create_field_class_from_ptr_and_get_ref = staticmethod(
 872         _create_field_class_from_ptr_and_get_ref
 873     )
 874     _borrow_element_field_class = staticmethod(
 875         native_bt.field_class_array_borrow_element_field_class
 876     )
 877
 878
 879 class _StaticArrayFieldClassConst(_ArrayFieldClassConst):
 880     _NAME = 'Const static array'
 881
 882     @property
 883     def length(self):
 884         return native_bt.field_class_array_static_get_length(self._ptr)
 885
 886
 887 class _StaticArrayFieldClass(_StaticArrayFieldClassConst, _ArrayFieldClass):
 888     _NAME = 'Static array'
 889
 890
 891 class _DynamicArrayFieldClassConst(_ArrayFieldClassConst):
 892     _NAME = 'Const dynamic array'
 893
 894     @property
 895     def length_field_path(self):
 896         ptr = native_bt.field_class_array_dynamic_borrow_length_field_path_const(
 897             self._ptr
 898         )
 899         if ptr is None:
 900             return
 901
 902         return bt2_field_path._FieldPathConst._create_from_ptr_and_get_ref(ptr)
 903
 904
 905 class _DynamicArrayFieldClass(_DynamicArrayFieldClassConst, _ArrayFieldClass):
 906     _NAME = 'Dynamic Array'
 907
 908
 909 _FIELD_CLASS_TYPE_TO_CONST_OBJ = {
 910     native_bt.FIELD_CLASS_TYPE_BOOL: _BoolFieldClassConst,
 911     native_bt.FIELD_CLASS_TYPE_BIT_ARRAY: _BitArrayFieldClassConst,
 912     native_bt.FIELD_CLASS_TYPE_UNSIGNED_INTEGER: _UnsignedIntegerFieldClassConst,
 913     native_bt.FIELD_CLASS_TYPE_SIGNED_INTEGER: _SignedIntegerFieldClassConst,
 914     native_bt.FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL: _SinglePrecisionRealFieldClassConst,
 915     native_bt.FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL: _DoublePrecisionRealFieldClassConst,
 916     native_bt.FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION: _UnsignedEnumerationFieldClassConst,
 917     native_bt.FIELD_CLASS_TYPE_SIGNED_ENUMERATION: _SignedEnumerationFieldClassConst,
 918     native_bt.FIELD_CLASS_TYPE_STRING: _StringFieldClassConst,
 919     native_bt.FIELD_CLASS_TYPE_STRUCTURE: _StructureFieldClassConst,
 920     native_bt.FIELD_CLASS_TYPE_STATIC_ARRAY: _StaticArrayFieldClassConst,
 921     native_bt.FIELD_CLASS_TYPE_DYNAMIC_ARRAY: _DynamicArrayFieldClassConst,
 922     native_bt.FIELD_CLASS_TYPE_OPTION: _OptionFieldClassConst,
 923     native_bt.FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR: _VariantFieldClassWithoutSelectorConst,
 924     native_bt.FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_SELECTOR: _VariantFieldClassWithUnsignedSelectorConst,
 925     native_bt.FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_SELECTOR: _VariantFieldClassWithSignedSelectorConst,
 926 }
 927
 928 _FIELD_CLASS_TYPE_TO_OBJ = {
 929     native_bt.FIELD_CLASS_TYPE_BOOL: _BoolFieldClass,
 930     native_bt.FIELD_CLASS_TYPE_BIT_ARRAY: _BitArrayFieldClass,
 931     native_bt.FIELD_CLASS_TYPE_UNSIGNED_INTEGER: _UnsignedIntegerFieldClass,
 932     native_bt.FIELD_CLASS_TYPE_SIGNED_INTEGER: _SignedIntegerFieldClass,
 933     native_bt.FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL: _SinglePrecisionRealFieldClass,
 934     native_bt.FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL: _DoublePrecisionRealFieldClass,
 935     native_bt.FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION: _UnsignedEnumerationFieldClass,
 936     native_bt.FIELD_CLASS_TYPE_SIGNED_ENUMERATION: _SignedEnumerationFieldClass,
 937     native_bt.FIELD_CLASS_TYPE_STRING: _StringFieldClass,
 938     native_bt.FIELD_CLASS_TYPE_STRUCTURE: _StructureFieldClass,
 939     native_bt.FIELD_CLASS_TYPE_STATIC_ARRAY: _StaticArrayFieldClass,
 940     native_bt.FIELD_CLASS_TYPE_DYNAMIC_ARRAY: _DynamicArrayFieldClass,
 941     native_bt.FIELD_CLASS_TYPE_OPTION: _OptionFieldClass,
 942     native_bt.FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR: _VariantFieldClassWithoutSelector,
 943     native_bt.FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_SELECTOR: _VariantFieldClassWithUnsignedSelector,
 944     native_bt.FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_SELECTOR: _VariantFieldClassWithSignedSelector,
 945 }