bindings/python/bt2/bt2/fields.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 bt2.field_types
  25 import collections.abc
  26 import functools
  27 import numbers
  28 import math
  29 import abc
  30 import bt2
  31
  32
  33 def _get_leaf_field(obj):
  34     if type(obj) is not _VariantField:
  35         return obj
  36
  37     return _get_leaf_field(obj.selected_field)
  38
  39
  40 def _create_from_ptr(ptr):
  41     # recreate the field type wrapper of this field's type (the identity
  42     # could be different, but the underlying address should be the
  43     # same)
  44     field_type_ptr = native_bt.field_get_type(ptr)
  45     utils._handle_ptr(field_type_ptr, "cannot get field object's type")
  46     field_type = bt2.field_types._create_from_ptr(field_type_ptr)
  47     typeid = native_bt.field_type_get_type_id(field_type._ptr)
  48     field = _TYPE_ID_TO_OBJ[typeid]._create_from_ptr(ptr)
  49     field._field_type = field_type
  50     return field
  51
  52
  53 class _Field(object._Object, metaclass=abc.ABCMeta):
  54     def __copy__(self):
  55         ptr = native_bt.field_copy(self._ptr)
  56         utils._handle_ptr(ptr, 'cannot copy {} field object'.format(self._NAME.lower()))
  57         return _create_from_ptr(ptr)
  58
  59     def __deepcopy__(self, memo):
  60         cpy = self.__copy__()
  61         memo[id(self)] = cpy
  62         return cpy
  63
  64     def __eq__(self, other):
  65         # special case: two unset fields with the same field type are equal
  66         if isinstance(other, _Field):
  67             if not self.is_set or not other.is_set:
  68                 if not self.is_set and not other.is_set and self.field_type == other.field_type:
  69                     return True
  70                 return False
  71
  72         other = _get_leaf_field(other)
  73         return self._spec_eq(other)
  74
  75     @property
  76     def field_type(self):
  77         return self._field_type
  78
  79     @property
  80     def is_set(self):
  81         is_set = native_bt.field_is_set(self._ptr)
  82         return is_set > 0
  83
  84     def reset(self):
  85         ret = native_bt.field_reset(self._ptr)
  86         utils._handle_ret(ret, "cannot reset field object's value")
  87
  88
  89 @functools.total_ordering
  90 class _NumericField(_Field):
  91     @staticmethod
  92     def _extract_value(other):
  93         if other is True or other is False:
  94             return other
  95
  96         if isinstance(other, numbers.Integral):
  97             return int(other)
  98
  99         if isinstance(other, numbers.Real):
 100             return float(other)
 101
 102         if isinstance(other, numbers.Complex):
 103             return complex(other)
 104
 105         raise TypeError("'{}' object is not a number object".format(other.__class__.__name__))
 106
 107     def __int__(self):
 108         return int(self._value)
 109
 110     def __float__(self):
 111         return float(self._value)
 112
 113     def __str__(self):
 114         return str(self._value)
 115
 116     def __lt__(self, other):
 117         if not isinstance(other, numbers.Number):
 118             raise TypeError('unorderable types: {}() < {}()'.format(self.__class__.__name__,
 119                                                                     other.__class__.__name__))
 120
 121         return self._value < float(other)
 122
 123     def __le__(self, other):
 124         if not isinstance(other, numbers.Number):
 125             raise TypeError('unorderable types: {}() <= {}()'.format(self.__class__.__name__,
 126                                                                      other.__class__.__name__))
 127
 128         return self._value <= float(other)
 129
 130     def _spec_eq(self, other):
 131         if not isinstance(other, numbers.Number):
 132             return False
 133
 134         return self._value == complex(other)
 135
 136     def __rmod__(self, other):
 137         return self._extract_value(other) % self._value
 138
 139     def __mod__(self, other):
 140         return self._value % self._extract_value(other)
 141
 142     def __rfloordiv__(self, other):
 143         return self._extract_value(other) // self._value
 144
 145     def __floordiv__(self, other):
 146         return self._value // self._extract_value(other)
 147
 148     def __round__(self, ndigits=None):
 149         if ndigits is None:
 150             return round(self._value)
 151         else:
 152             return round(self._value, ndigits)
 153
 154     def __ceil__(self):
 155         return math.ceil(self._value)
 156
 157     def __floor__(self):
 158         return math.floor(self._value)
 159
 160     def __trunc__(self):
 161         return int(self._value)
 162
 163     def __abs__(self):
 164         return abs(self._value)
 165
 166     def __add__(self, other):
 167         return self._value + self._extract_value(other)
 168
 169     def __radd__(self, other):
 170         return self.__add__(other)
 171
 172     def __neg__(self):
 173         return -self._value
 174
 175     def __pos__(self):
 176         return +self._value
 177
 178     def __mul__(self, other):
 179         return self._value * self._extract_value(other)
 180
 181     def __rmul__(self, other):
 182         return self.__mul__(other)
 183
 184     def __truediv__(self, other):
 185         return self._value / self._extract_value(other)
 186
 187     def __rtruediv__(self, other):
 188         return self._extract_value(other) / self._value
 189
 190     def __pow__(self, exponent):
 191         return self._value ** self._extract_value(exponent)
 192
 193     def __rpow__(self, base):
 194         return self._extract_value(base) ** self._value
 195
 196     def __iadd__(self, other):
 197         self.value = self + other
 198         return self
 199
 200     def __isub__(self, other):
 201         self.value = self - other
 202         return self
 203
 204     def __imul__(self, other):
 205         self.value = self * other
 206         return self
 207
 208     def __itruediv__(self, other):
 209         self.value = self / other
 210         return self
 211
 212     def __ifloordiv__(self, other):
 213         self.value = self // other
 214         return self
 215
 216     def __imod__(self, other):
 217         self.value = self % other
 218         return self
 219
 220     def __ipow__(self, other):
 221         self.value = self ** other
 222         return self
 223
 224
 225 class _IntegralField(_NumericField, numbers.Integral):
 226     def __lshift__(self, other):
 227         return self._value << self._extract_value(other)
 228
 229     def __rlshift__(self, other):
 230         return self._extract_value(other) << self._value
 231
 232     def __rshift__(self, other):
 233         return self._value >> self._extract_value(other)
 234
 235     def __rrshift__(self, other):
 236         return self._extract_value(other) >> self._value
 237
 238     def __and__(self, other):
 239         return self._value & self._extract_value(other)
 240
 241     def __rand__(self, other):
 242         return self._extract_value(other) & self._value
 243
 244     def __xor__(self, other):
 245         return self._value ^ self._extract_value(other)
 246
 247     def __rxor__(self, other):
 248         return self._extract_value(other) ^ self._value
 249
 250     def __or__(self, other):
 251         return self._value | self._extract_value(other)
 252
 253     def __ror__(self, other):
 254         return self._extract_value(other) | self._value
 255
 256     def __invert__(self):
 257         return ~self._value
 258
 259     def __ilshift__(self, other):
 260         self.value = self << other
 261         return self
 262
 263     def __irshift__(self, other):
 264         self.value = self >> other
 265         return self
 266
 267     def __iand__(self, other):
 268         self.value = self & other
 269         return self
 270
 271     def __ixor__(self, other):
 272         self.value = self ^ other
 273         return self
 274
 275     def __ior__(self, other):
 276         self.value = self | other
 277         return self
 278
 279
 280 class _RealField(_NumericField, numbers.Real):
 281     pass
 282
 283
 284 class _IntegerField(_IntegralField):
 285     _NAME = 'Integer'
 286
 287     def _value_to_int(self, value):
 288         if not isinstance(value, numbers.Real):
 289             raise TypeError('expecting a real number object')
 290
 291         value = int(value)
 292
 293         if self.field_type.is_signed:
 294             utils._check_int64(value)
 295         else:
 296             utils._check_uint64(value)
 297
 298         return value
 299
 300     @property
 301     def _value(self):
 302         if self.field_type.is_signed:
 303             ret, value = native_bt.field_signed_integer_get_value(self._ptr)
 304         else:
 305             ret, value = native_bt.field_unsigned_integer_get_value(self._ptr)
 306
 307         if ret < 0:
 308             if not self.is_set:
 309                 return
 310
 311             utils._handle_ret(ret, "cannot get integer field's value")
 312
 313         return value
 314
 315     def _set_value(self, value):
 316         value = self._value_to_int(value)
 317
 318         if self.field_type.is_signed:
 319             ret = native_bt.field_signed_integer_set_value(self._ptr, value)
 320         else:
 321             ret = native_bt.field_unsigned_integer_set_value(self._ptr, value)
 322
 323         utils._handle_ret(ret, "cannot set integer field object's value")
 324
 325     value = property(fset=_set_value)
 326
 327
 328 class _FloatingPointNumberField(_RealField):
 329     _NAME = 'Floating point number'
 330
 331     def _value_to_float(self, value):
 332         if not isinstance(value, numbers.Real):
 333             raise TypeError("expecting a real number object")
 334
 335         return float(value)
 336
 337     @property
 338     def _value(self):
 339         ret, value = native_bt.field_floating_point_get_value(self._ptr)
 340
 341         if ret < 0:
 342             if not self.is_set:
 343                 return
 344
 345             utils._handle_ret(ret, "cannot get floating point number field's value")
 346
 347         return value
 348
 349     def _set_value(self, value):
 350         value = self._value_to_float(value)
 351         ret = native_bt.field_floating_point_set_value(self._ptr, value)
 352         utils._handle_ret(ret, "cannot set floating point number field object's value")
 353
 354     value = property(fset=_set_value)
 355
 356
 357 class _EnumerationField(_IntegerField):
 358     _NAME = 'Enumeration'
 359
 360     @property
 361     def integer_field(self):
 362         int_field_ptr = native_bt.field_enumeration_get_container(self._ptr)
 363         assert(int_field_ptr)
 364         return _create_from_ptr(int_field_ptr)
 365
 366     def _set_value(self, value):
 367         self.integer_field.value = value
 368
 369     value = property(fset=_set_value)
 370
 371     @property
 372     def _value(self):
 373         return self.integer_field._value
 374
 375     @property
 376     def mappings(self):
 377         iter_ptr = native_bt.field_enumeration_get_mappings(self._ptr)
 378         assert(iter_ptr)
 379         return bt2.field_types._EnumerationFieldTypeMappingIterator(iter_ptr,
 380                                                                     self.field_type.is_signed)
 381
 382
 383 @functools.total_ordering
 384 class _StringField(_Field, collections.abc.Sequence):
 385     _NAME = 'String'
 386
 387     def _value_to_str(self, value):
 388         if isinstance(value, self.__class__):
 389             value = value._value
 390
 391         if not isinstance(value, str):
 392             raise TypeError("expecting a 'str' object")
 393
 394         return value
 395
 396     @property
 397     def _value(self):
 398         value = native_bt.field_string_get_value(self._ptr)
 399         return value
 400
 401     def _set_value(self, value):
 402         value = self._value_to_str(value)
 403         ret = native_bt.field_string_set_value(self._ptr, value)
 404         utils._handle_ret(ret, "cannot set string field object's value")
 405
 406     value = property(fset=_set_value)
 407
 408     def _spec_eq(self, other):
 409         try:
 410             other = self._value_to_str(other)
 411         except:
 412             return False
 413
 414         return self._value == other
 415
 416     def __le__(self, other):
 417         return self._value <= self._value_to_str(other)
 418
 419     def __lt__(self, other):
 420         return self._value < self._value_to_str(other)
 421
 422     def __bool__(self):
 423         return bool(self._value)
 424
 425     def __str__(self):
 426         return self._value
 427
 428     def __getitem__(self, index):
 429         return self._value[index]
 430
 431     def __len__(self):
 432         return len(self._value)
 433
 434     def __iadd__(self, value):
 435         value = self._value_to_str(value)
 436         ret = native_bt.field_string_append(self._ptr, value)
 437         utils._handle_ret(ret, "cannot append to string field object's value")
 438         return self
 439
 440
 441 class _ContainerField(_Field):
 442     def __bool__(self):
 443         return len(self) != 0
 444
 445     def __len__(self):
 446         count = self._count()
 447         assert(count >= 0)
 448         return count
 449
 450     def __delitem__(self, index):
 451         raise NotImplementedError
 452
 453
 454 class _StructureField(_ContainerField, collections.abc.MutableMapping):
 455     _NAME = 'Structure'
 456
 457     def _count(self):
 458         return len(self.field_type)
 459
 460     def __getitem__(self, key):
 461         utils._check_str(key)
 462         ptr = native_bt.field_structure_get_field_by_name(self._ptr, key)
 463
 464         if ptr is None:
 465             raise KeyError(key)
 466
 467         return _create_from_ptr(ptr)
 468
 469     def __setitem__(self, key, value):
 470         # raises if key is somehow invalid
 471         field = self[key]
 472
 473         # the field's property does the appropriate conversion or raises
 474         # the appropriate exception
 475         field.value = value
 476
 477     def at_index(self, index):
 478         utils._check_uint64(index)
 479
 480         if index >= len(self):
 481             raise IndexError
 482
 483         field_ptr = native_bt.field_structure_get_field_by_index(self._ptr, index)
 484         assert(field_ptr)
 485         return _create_from_ptr(field_ptr)
 486
 487     def __iter__(self):
 488         # same name iterator
 489         return iter(self.field_type)
 490
 491     def _spec_eq(self, other):
 492         try:
 493             if len(self) != len(other):
 494                 return False
 495
 496             for self_key, self_value in self.items():
 497                 if self_key not in other:
 498                     return False
 499
 500                 other_value = other[self_key]
 501
 502                 if self_value != other_value:
 503                     return False
 504
 505             return True
 506         except:
 507             return False
 508
 509     @property
 510     def _value(self):
 511         return {key: value._value for key, value in self.items()}
 512
 513     def _set_value(self, values):
 514         original_values = self._value
 515
 516         try:
 517             for key, value in values.items():
 518                 self[key].value = value
 519         except:
 520             self.value = original_values
 521             raise
 522
 523     value = property(fset=_set_value)
 524
 525
 526 class _VariantField(_Field):
 527     _NAME = 'Variant'
 528
 529     @property
 530     def tag_field(self):
 531         field_ptr = native_bt.field_variant_get_tag(self._ptr)
 532
 533         if field_ptr is None:
 534             return
 535
 536         return _create_from_ptr(field_ptr)
 537
 538     @property
 539     def selected_field(self):
 540         return self.field()
 541
 542     def field(self, tag_field=None):
 543         if tag_field is None:
 544             field_ptr = native_bt.field_variant_get_current_field(self._ptr)
 545
 546             if field_ptr is None:
 547                 return
 548         else:
 549             utils._check_type(tag_field, _EnumerationField)
 550             field_ptr = native_bt.field_variant_get_field(self._ptr, tag_field._ptr)
 551             utils._handle_ptr(field_ptr, "cannot select variant field object's field")
 552
 553         return _create_from_ptr(field_ptr)
 554
 555     def _spec_eq(self, other):
 556         return _get_leaf_field(self) == other
 557
 558     def __bool__(self):
 559         return bool(self.selected_field)
 560
 561     @property
 562     def _value(self):
 563         if self.selected_field is not None:
 564             return self.selected_field._value
 565
 566     def _set_value(self, value):
 567         self.selected_field.value = value
 568
 569     value = property(fset=_set_value)
 570
 571
 572 class _ArraySequenceField(_ContainerField, collections.abc.MutableSequence):
 573     def __getitem__(self, index):
 574         if not isinstance(index, numbers.Integral):
 575             raise TypeError("'{}' is not an integral number object: invalid index".format(index.__class__.__name__))
 576
 577         index = int(index)
 578
 579         if index < 0 or index >= len(self):
 580             raise IndexError('{} field object index is out of range'.format(self._NAME))
 581
 582         field_ptr = self._get_field_ptr_at_index(index)
 583         assert(field_ptr)
 584         return _create_from_ptr(field_ptr)
 585
 586     def __setitem__(self, index, value):
 587         # we can only set numbers and strings
 588         if not isinstance(value, (numbers.Number, _StringField, str)):
 589             raise TypeError('expecting number or string object')
 590
 591         # raises if index is somehow invalid
 592         field = self[index]
 593
 594         if not isinstance(field, (_NumericField, _StringField)):
 595             raise TypeError('can only set the value of a number or string field')
 596
 597         # the field's property does the appropriate conversion or raises
 598         # the appropriate exception
 599         field.value = value
 600
 601     def insert(self, index, value):
 602         raise NotImplementedError
 603
 604     def _spec_eq(self, other):
 605         try:
 606             if len(self) != len(other):
 607                 return False
 608
 609             for self_field, other_field in zip(self, other):
 610                 if self_field != other_field:
 611                     return False
 612
 613             return True
 614         except:
 615             return False
 616
 617     @property
 618     def _value(self):
 619         return [field._value for field in self]
 620
 621
 622 class _ArrayField(_ArraySequenceField):
 623     _NAME = 'Array'
 624
 625     def _count(self):
 626         return self.field_type.length
 627
 628     def _get_field_ptr_at_index(self, index):
 629         return native_bt.field_array_get_field(self._ptr, index)
 630
 631     def _set_value(self, values):
 632         if len(self) != len(values):
 633             raise ValueError(
 634                 'expected length of value and array field to match')
 635
 636         original_values = self._value
 637         try:
 638             for index, value in enumerate(values):
 639                 if value is not None:
 640                     self[index].value = value
 641                 else:
 642                     self[index].reset()
 643         except:
 644             self.value = original_values
 645             raise
 646
 647     value = property(fset=_set_value)
 648
 649
 650 class _SequenceField(_ArraySequenceField):
 651     _NAME = 'Sequence'
 652
 653     def _count(self):
 654         return int(self.length_field)
 655
 656     @property
 657     def length_field(self):
 658         field_ptr = native_bt.field_sequence_get_length(self._ptr)
 659         if field_ptr is None:
 660             return
 661         return _create_from_ptr(field_ptr)
 662
 663     @length_field.setter
 664     def length_field(self, length_field):
 665         utils._check_type(length_field, _IntegerField)
 666         ret = native_bt.field_sequence_set_length(self._ptr, length_field._ptr)
 667         utils._handle_ret(ret, "cannot set sequence field object's length field")
 668
 669     def _get_field_ptr_at_index(self, index):
 670         return native_bt.field_sequence_get_field(self._ptr, index)
 671
 672     def _set_value(self, values):
 673         original_length_field = self.length_field
 674         if original_length_field is not None:
 675             original_values = self._value
 676
 677         if len(values) != self.length_field:
 678             if self.length_field is not None:
 679                 length_ft = self.length_field.field_type
 680             else:
 681                 length_ft = bt2.IntegerFieldType(size=64, is_signed=False)
 682             self.length_field = length_ft(len(values))
 683
 684         try:
 685             for index, value in enumerate(values):
 686                 if value is not None:
 687                     self[index].value = value
 688                 else:
 689                     self[index].reset()
 690         except:
 691             if original_length_field is not None:
 692                 self.length_field = original_length_field
 693                 self.value = original_values
 694             else:
 695                 self.reset()
 696             raise
 697
 698     value = property(fset=_set_value)
 699
 700
 701 _TYPE_ID_TO_OBJ = {
 702     native_bt.FIELD_TYPE_ID_INTEGER: _IntegerField,
 703     native_bt.FIELD_TYPE_ID_FLOAT: _FloatingPointNumberField,
 704     native_bt.FIELD_TYPE_ID_ENUM: _EnumerationField,
 705     native_bt.FIELD_TYPE_ID_STRING: _StringField,
 706     native_bt.FIELD_TYPE_ID_STRUCT: _StructureField,
 707     native_bt.FIELD_TYPE_ID_ARRAY: _ArrayField,
 708     native_bt.FIELD_TYPE_ID_SEQUENCE: _SequenceField,
 709     native_bt.FIELD_TYPE_ID_VARIANT: _VariantField,
 710 }