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 import bt2.field
  26 import bt2.field_path
  27 import bt2
  28
  29
  30 def _create_field_class_from_ptr_and_get_ref(ptr):
  31     typeid = native_bt.field_class_get_type(ptr)
  32     return _FIELD_CLASS_TYPE_TO_OBJ[typeid]._create_from_ptr_and_get_ref(ptr)
  33
  34
  35 class IntegerDisplayBase:
  36     BINARY = native_bt.FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_BINARY
  37     OCTAL = native_bt.FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_OCTAL
  38     DECIMAL = native_bt.FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL
  39     HEXADECIMAL = native_bt.FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL
  40
  41
  42 class _FieldClass(object._SharedObject):
  43     _get_ref = staticmethod(native_bt.field_class_get_ref)
  44     _put_ref = staticmethod(native_bt.field_class_put_ref)
  45
  46     def _check_create_status(self, ptr):
  47         if ptr is None:
  48             raise bt2.CreationError('cannot create {} field class object'.format(self._NAME.lower()))
  49
  50
  51 class _IntegerFieldClass(_FieldClass):
  52     @property
  53     def field_value_range(self):
  54         size = native_bt.field_class_integer_get_field_value_range(self._ptr)
  55         assert(size >= 1)
  56         return size
  57
  58     def _field_value_range(self, size):
  59         if size < 1 or size > 64:
  60             raise ValueError("Value is outside valid range [1, 64] ({})".format(size))
  61         native_bt.field_class_integer_set_field_value_range(self._ptr, size)
  62
  63     _field_value_range = property(fset=_field_value_range)
  64
  65     @property
  66     def preferred_display_base(self):
  67         base = native_bt.field_class_integer_get_preferred_display_base(
  68             self._ptr)
  69         assert(base >= 0)
  70         return base
  71
  72     def _preferred_display_base(self, base):
  73         utils._check_uint64(base)
  74
  75         if base not in (IntegerDisplayBase.BINARY,
  76                         IntegerDisplayBase.OCTAL,
  77                         IntegerDisplayBase.DECIMAL,
  78                         IntegerDisplayBase.HEXADECIMAL):
  79             raise ValueError("Display base is not a valid IntegerDisplayBase value")
  80
  81         native_bt.field_class_integer_set_preferred_display_base(
  82             self._ptr, base)
  83
  84     _preferred_display_base = property(fset=_preferred_display_base)
  85
  86
  87 class _UnsignedIntegerFieldClass(_IntegerFieldClass):
  88     _NAME = 'Unsigned integer'
  89
  90
  91 class _SignedIntegerFieldClass(_IntegerFieldClass):
  92     _NAME = 'Signed integer'
  93
  94
  95 class _RealFieldClass(_FieldClass):
  96     _NAME = 'Real'
  97
  98     @property
  99     def is_single_precision(self):
 100         return native_bt.field_class_real_is_single_precision(self._ptr)
 101
 102     def _is_single_precision(self, is_single_precision):
 103         utils._check_bool(is_single_precision)
 104         native_bt.field_class_real_set_is_single_precision(
 105             self._ptr, is_single_precision)
 106
 107     _is_single_precision = property(fset=_is_single_precision)
 108
 109
 110 class _EnumerationFieldClassMappingRange:
 111     def __init__(self, lower, upper):
 112         self._lower = lower
 113         self._upper = upper
 114
 115     @property
 116     def lower(self):
 117         return self._lower
 118
 119     @property
 120     def upper(self):
 121         return self._upper
 122
 123     def __eq__(self, other):
 124         return self.lower == other.lower and self.upper == other.upper
 125
 126
 127 class _EnumerationFieldClassMapping(collections.abc.Set):
 128     def __init__(self, mapping_ptr):
 129         self._mapping_ptr = mapping_ptr
 130
 131     @property
 132     def label(self):
 133         mapping_ptr = self._as_enumeration_field_class_mapping_ptr(self._mapping_ptr)
 134         label = native_bt.field_class_enumeration_mapping_get_label(mapping_ptr)
 135         assert label is not None
 136         return label
 137
 138     def __len__(self):
 139         mapping_ptr = self._as_enumeration_field_class_mapping_ptr(self._mapping_ptr)
 140         return native_bt.field_class_enumeration_mapping_get_range_count(mapping_ptr)
 141
 142     def __contains__(self, other_range):
 143         for curr_range in self:
 144             if curr_range == other_range:
 145                 return True
 146         return False
 147
 148     def __iter__(self):
 149         for idx in range(len(self)):
 150             lower, upper = self._get_range_by_index(self._mapping_ptr, idx)
 151             yield _EnumerationFieldClassMappingRange(lower, upper)
 152
 153
 154 class _UnsignedEnumerationFieldClassMapping(_EnumerationFieldClassMapping):
 155     _as_enumeration_field_class_mapping_ptr = staticmethod(native_bt.field_class_unsigned_enumeration_mapping_as_mapping_const)
 156     _get_range_by_index = staticmethod(native_bt.field_class_unsigned_enumeration_mapping_get_range_by_index)
 157
 158
 159 class _SignedEnumerationFieldClassMapping(_EnumerationFieldClassMapping):
 160     _as_enumeration_field_class_mapping_ptr = staticmethod(native_bt.field_class_signed_enumeration_mapping_as_mapping_const)
 161     _get_range_by_index = staticmethod(native_bt.field_class_signed_enumeration_mapping_get_range_by_index)
 162
 163
 164 class _EnumerationFieldClass(_IntegerFieldClass, collections.abc.Mapping):
 165     def __len__(self):
 166         count = native_bt.field_class_enumeration_get_mapping_count(self._ptr)
 167         assert(count >= 0)
 168         return count
 169
 170     def map_range(self, label, lower, upper=None):
 171         utils._check_str(label)
 172
 173         if upper is None:
 174             upper = lower
 175
 176         status = self._map_range(self._ptr, label, lower, upper)
 177         utils._handle_func_status(status,
 178                                   "cannot add mapping to enumeration field class object")
 179
 180     def labels_by_value(self, value):
 181         status, labels = self._get_mapping_labels_by_value(self._ptr, value)
 182         utils._handle_func_status(status, "cannot get mapping labels")
 183         return labels
 184
 185     def __iter__(self):
 186         for idx in range(len(self)):
 187             mapping = self._get_mapping_by_index(self._ptr, idx)
 188             yield mapping.label
 189
 190     def __getitem__(self, key):
 191         utils._check_str(key)
 192         for idx in range(len(self)):
 193             mapping = self._get_mapping_by_index(self._ptr, idx)
 194             if mapping.label == key:
 195                 return mapping
 196
 197         raise KeyError(key)
 198
 199     def __iadd__(self, mappings):
 200         for mapping in mappings.values():
 201             for range in mapping:
 202                 self.map_range(mapping.label, range.lower, range.upper)
 203
 204         return self
 205
 206
 207 class _UnsignedEnumerationFieldClass(_EnumerationFieldClass, _UnsignedIntegerFieldClass):
 208     _NAME = 'Unsigned enumeration'
 209
 210     @staticmethod
 211     def _get_mapping_by_index(enum_ptr, index):
 212         mapping_ptr = native_bt.field_class_unsigned_enumeration_borrow_mapping_by_index_const(enum_ptr, index)
 213         assert mapping_ptr is not None
 214         return _UnsignedEnumerationFieldClassMapping(mapping_ptr)
 215
 216     @staticmethod
 217     def _map_range(enum_ptr, label, lower, upper):
 218         utils._check_uint64(lower)
 219         utils._check_uint64(upper)
 220         return native_bt.field_class_unsigned_enumeration_map_range(enum_ptr, label, lower, upper)
 221
 222     @staticmethod
 223     def _get_mapping_labels_by_value(enum_ptr, value):
 224         utils._check_uint64(value)
 225         return native_bt.field_class_unsigned_enumeration_get_mapping_labels_by_value(enum_ptr, value)
 226
 227
 228 class _SignedEnumerationFieldClass(_EnumerationFieldClass, _SignedIntegerFieldClass):
 229     _NAME = 'Signed enumeration'
 230
 231     @staticmethod
 232     def _get_mapping_by_index(enum_ptr, index):
 233         mapping_ptr = native_bt.field_class_signed_enumeration_borrow_mapping_by_index_const(enum_ptr, index)
 234         assert mapping_ptr is not None
 235         return _SignedEnumerationFieldClassMapping(mapping_ptr)
 236
 237     @staticmethod
 238     def _map_range(enum_ptr, label, lower, upper):
 239         utils._check_int64(lower)
 240         utils._check_int64(upper)
 241         return native_bt.field_class_signed_enumeration_map_range(enum_ptr, label, lower, upper)
 242
 243     @staticmethod
 244     def _get_mapping_labels_by_value(enum_ptr, value):
 245         utils._check_int64(value)
 246         return native_bt.field_class_signed_enumeration_get_mapping_labels_by_value(enum_ptr, value)
 247
 248
 249 class _StringFieldClass(_FieldClass):
 250     _NAME = 'String'
 251
 252
 253 class _FieldContainer(collections.abc.Mapping):
 254     def __len__(self):
 255         count = self._get_element_count(self._ptr)
 256         assert count >= 0
 257         return count
 258
 259     def __getitem__(self, key):
 260         if not isinstance(key, str):
 261             raise TypeError("key should be a 'str' object, got {}".format(key.__class__.__name__))
 262
 263         ptr = self._borrow_field_class_ptr_by_name(key)
 264
 265         if ptr is None:
 266             raise KeyError(key)
 267
 268         return _create_field_class_from_ptr_and_get_ref(ptr)
 269
 270     def _borrow_field_class_ptr_by_name(self, key):
 271         element_ptr = self._borrow_element_by_name(self._ptr, key)
 272         if element_ptr is None:
 273             return
 274
 275         return self._element_borrow_field_class(element_ptr)
 276
 277     def __iter__(self):
 278         for idx in range(len(self)):
 279             element_ptr = self._borrow_element_by_index(self._ptr, idx)
 280             assert element_ptr is not None
 281
 282             yield self._element_get_name(element_ptr)
 283
 284     def _append_element_common(self, name, field_class):
 285         utils._check_str(name)
 286         utils._check_type(field_class, _FieldClass)
 287         status = self._append_element(self._ptr, name, field_class._ptr)
 288         utils._handle_func_status(status,
 289                                   "cannot add field to {} field class object".format(self._NAME.lower()))
 290
 291     def __iadd__(self, fields):
 292         for name, field_class in fields.items():
 293             self._append_element_common(name, field_class)
 294
 295         return self
 296
 297     def _at_index(self, index):
 298         utils._check_uint64(index)
 299
 300         if index < 0 or index >= len(self):
 301             raise IndexError
 302
 303         element_ptr = self._borrow_element_by_index(self._ptr, index)
 304         assert element_ptr is not None
 305
 306         field_class_ptr = self._element_borrow_field_class(element_ptr)
 307
 308         return _create_field_class_from_ptr_and_get_ref(field_class_ptr)
 309
 310
 311 class _StructureFieldClass(_FieldClass, _FieldContainer):
 312     _NAME = 'Structure'
 313     _borrow_element_by_index = staticmethod(native_bt.field_class_structure_borrow_member_by_index_const)
 314     _borrow_element_by_name = staticmethod(native_bt.field_class_structure_borrow_member_by_name_const)
 315     _element_get_name = staticmethod(native_bt.field_class_structure_member_get_name)
 316     _element_borrow_field_class = staticmethod(native_bt.field_class_structure_member_borrow_field_class_const)
 317     _get_element_count = staticmethod(native_bt.field_class_structure_get_member_count)
 318     _append_element = staticmethod(native_bt.field_class_structure_append_member)
 319
 320     def append_member(self, name, field_class):
 321         return self._append_element_common(name, field_class)
 322
 323     def member_at_index(self, index):
 324         return self._at_index(index)
 325
 326
 327 class _VariantFieldClass(_FieldClass, _FieldContainer):
 328     _NAME = 'Variant'
 329     _borrow_element_by_index = staticmethod(native_bt.field_class_variant_borrow_option_by_index_const)
 330     _borrow_element_by_name = staticmethod(native_bt.field_class_variant_borrow_option_by_name_const)
 331     _element_get_name = staticmethod(native_bt.field_class_variant_option_get_name)
 332     _element_borrow_field_class = staticmethod(native_bt.field_class_variant_option_borrow_field_class_const)
 333     _get_element_count = staticmethod(native_bt.field_class_variant_get_option_count)
 334     _append_element = staticmethod(native_bt.field_class_variant_append_option)
 335
 336     def append_option(self, name, field_class):
 337         return self._append_element_common(name, field_class)
 338
 339     def option_at_index(self, index):
 340         return self._at_index(index)
 341
 342     @property
 343     def selector_field_path(self):
 344         ptr = native_bt.field_class_variant_borrow_selector_field_path_const(self._ptr)
 345         if ptr is None:
 346             return
 347
 348         return bt2.field_path._FieldPath._create_from_ptr_and_get_ref(ptr)
 349
 350     def _set_selector_field_class(self, selector_fc):
 351         utils._check_type(selector_fc, bt2.field_class._EnumerationFieldClass)
 352         status = native_bt.field_class_variant_set_selector_field_class(self._ptr, selector_fc._ptr)
 353         utils._handle_func_status(status,
 354                                   "cannot set variant selector field type")
 355
 356     _selector_field_class = property(fset=_set_selector_field_class)
 357
 358
 359 class _ArrayFieldClass(_FieldClass):
 360     @property
 361     def element_field_class(self):
 362         elem_fc_ptr = native_bt.field_class_array_borrow_element_field_class_const(self._ptr)
 363         return _create_field_class_from_ptr_and_get_ref(elem_fc_ptr)
 364
 365
 366 class _StaticArrayFieldClass(_ArrayFieldClass):
 367     @property
 368     def length(self):
 369         return native_bt.field_class_static_array_get_length(self._ptr)
 370
 371
 372 class _DynamicArrayFieldClass(_ArrayFieldClass):
 373     @property
 374     def length_field_path(self):
 375         ptr = native_bt.field_class_dynamic_array_borrow_length_field_path_const(self._ptr)
 376         if ptr is None:
 377             return
 378
 379         return bt2.field_path._FieldPath._create_from_ptr_and_get_ref(ptr)
 380
 381     def _set_length_field_class(self, length_fc):
 382         utils._check_type(length_fc, _UnsignedIntegerFieldClass)
 383         status = native_bt.field_class_dynamic_array_set_length_field_class(self._ptr, length_fc._ptr)
 384         utils._handle_func_status(status,
 385                                   "cannot set dynamic array length field type")
 386
 387     _length_field_class = property(fset=_set_length_field_class)
 388
 389
 390 _FIELD_CLASS_TYPE_TO_OBJ = {
 391     native_bt.FIELD_CLASS_TYPE_UNSIGNED_INTEGER: _UnsignedIntegerFieldClass,
 392     native_bt.FIELD_CLASS_TYPE_SIGNED_INTEGER: _SignedIntegerFieldClass,
 393     native_bt.FIELD_CLASS_TYPE_REAL: _RealFieldClass,
 394     native_bt.FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION: _UnsignedEnumerationFieldClass,
 395     native_bt.FIELD_CLASS_TYPE_SIGNED_ENUMERATION: _SignedEnumerationFieldClass,
 396     native_bt.FIELD_CLASS_TYPE_STRING: _StringFieldClass,
 397     native_bt.FIELD_CLASS_TYPE_STRUCTURE: _StructureFieldClass,
 398     native_bt.FIELD_CLASS_TYPE_STATIC_ARRAY: _StaticArrayFieldClass,
 399     native_bt.FIELD_CLASS_TYPE_DYNAMIC_ARRAY: _DynamicArrayFieldClass,
 400     native_bt.FIELD_CLASS_TYPE_VARIANT: _VariantFieldClass,
 401 }