barectf/metadata.py

   1 # The MIT License (MIT)
   2 #
   3 # Copyright (c) 2015 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 import enum
  24 import collections
  25
  26
  27 @enum.unique
  28 class ByteOrder(enum.Enum):
  29     LE = 0
  30     BE = 1
  31
  32
  33 @enum.unique
  34 class Encoding(enum.Enum):
  35     NONE = 0
  36     UTF8 = 1
  37     ASCII = 2
  38
  39
  40 class Type:
  41     @property
  42     def align(self):
  43         return None
  44
  45     @property
  46     def size(self):
  47         pass
  48
  49     @property
  50     def is_dynamic(self):
  51         return False
  52
  53
  54 class PropertyMapping:
  55     def __init__(self, object, prop):
  56         self._object = object
  57         self._prop = prop
  58
  59     @property
  60     def object(self):
  61         return self._object
  62
  63     @object.setter
  64     def object(self, value):
  65         self._object = value
  66
  67     @property
  68     def prop(self):
  69         return self.prop
  70
  71     @prop.setter
  72     def prop(self, value):
  73         self.prop = value
  74
  75
  76 class Integer(Type):
  77     def __init__(self):
  78         self.set_default_size()
  79         self.set_default_align()
  80         self.set_default_signed()
  81         self.set_default_byte_order()
  82         self.set_default_base()
  83         self.set_default_encoding()
  84         self.set_default_property_mappings()
  85
  86     def set_default_size(self):
  87         self._size = None
  88
  89     def set_default_align(self):
  90         self._align = None
  91
  92     def set_default_signed(self):
  93         self._signed = False
  94
  95     def set_default_byte_order(self):
  96         self._byte_order = None
  97
  98     def set_default_base(self):
  99         self._base = 10
 100
 101     def set_default_encoding(self):
 102         self._encoding = Encoding.NONE
 103
 104     def set_default_property_mappings(self):
 105         self._property_mappings = []
 106
 107     @property
 108     def signed(self):
 109         return self._signed
 110
 111     @signed.setter
 112     def signed(self, value):
 113         self._signed = value
 114
 115     @property
 116     def byte_order(self):
 117         return self._byte_order
 118
 119     @byte_order.setter
 120     def byte_order(self, value):
 121         self._byte_order = value
 122
 123     @property
 124     def base(self):
 125         return self._base
 126
 127     @base.setter
 128     def base(self, value):
 129         self._base = value
 130
 131     @property
 132     def encoding(self):
 133         return self._encoding
 134
 135     @encoding.setter
 136     def encoding(self, value):
 137         self._encoding = value
 138
 139     @property
 140     def align(self):
 141         if self._align is None:
 142             if self._size is None:
 143                 return
 144             else:
 145                 if self._size % 8 == 0:
 146                     return 8
 147                 else:
 148                     return 1
 149         else:
 150             return self._align
 151
 152     @align.setter
 153     def align(self, value):
 154         self._align = value
 155
 156     @property
 157     def size(self):
 158         return self._size
 159
 160     @size.setter
 161     def size(self, value):
 162         self._size = value
 163
 164     @property
 165     def property_mappings(self):
 166         return self._property_mappings
 167
 168
 169 class FloatingPoint(Type):
 170     def __init__(self):
 171         self.set_default_exp_size()
 172         self.set_default_mant_size()
 173         self.set_default_align()
 174         self.set_default_byte_order()
 175
 176     def set_default_exp_size(self):
 177         self._exp_size = None
 178
 179     def set_default_mant_size(self):
 180         self._mant_size = None
 181
 182     def set_default_align(self):
 183         self._align = 8
 184
 185     def set_default_byte_order(self):
 186         self._byte_order = None
 187
 188     @property
 189     def exp_size(self):
 190         return self._exp_size
 191
 192     @exp_size.setter
 193     def exp_size(self, value):
 194         self._exp_size = value
 195
 196     @property
 197     def mant_size(self):
 198         return self._mant_size
 199
 200     @mant_size.setter
 201     def mant_size(self, value):
 202         self._mant_size = value
 203
 204     @property
 205     def size(self):
 206         if self._exp_size is None or self._mant_size is None:
 207             return
 208
 209         return self._exp_size + self._mant_size
 210
 211     @property
 212     def byte_order(self):
 213         return self._byte_order
 214
 215     @byte_order.setter
 216     def byte_order(self, value):
 217         self._byte_order = value
 218
 219     @property
 220     def align(self):
 221         return self._align
 222
 223     @align.setter
 224     def align(self, value):
 225         self._align = value
 226
 227
 228 class Enum(Type):
 229     def __init__(self):
 230         self.set_default_value_type()
 231         self.set_default_members()
 232
 233     def set_default_value_type(self):
 234         self._value_type = None
 235
 236     def set_default_members(self):
 237         self._members = collections.OrderedDict()
 238
 239     @property
 240     def align(self):
 241         return self._value_type.align
 242
 243     @property
 244     def size(self):
 245         return self._value_type.size
 246
 247     @property
 248     def value_type(self):
 249         return self._value_type
 250
 251     @value_type.setter
 252     def value_type(self, value):
 253         self._value_type = value
 254
 255     @property
 256     def members(self):
 257         return self._members
 258
 259     @property
 260     def last_value(self):
 261         if not self._members:
 262             return
 263
 264         return list(self._members.values())[-1][1]
 265
 266     def value_of(self, label):
 267         return self._members[label]
 268
 269     def label_of(self, value):
 270         for label, vrange in self._members.items():
 271             if value >= vrange[0] and value <= vrange[1]:
 272                 return label
 273
 274     def __getitem__(self, key):
 275         if type(key) is str:
 276             return self.value_of(key)
 277         elif type(key) is int:
 278             return self.label_of(key)
 279
 280         raise TypeError('wrong subscript type')
 281
 282
 283 class String(Type):
 284     def __init__(self):
 285         self.set_default_encoding()
 286
 287     def set_default_encoding(self):
 288         self._encoding = Encoding.UTF8
 289
 290     @property
 291     def align(self):
 292         return 8
 293
 294     @property
 295     def encoding(self):
 296         return self._encoding
 297
 298     @encoding.setter
 299     def encoding(self, value):
 300         self._encoding = value
 301
 302     @property
 303     def is_dynamic(self):
 304         return True
 305
 306
 307 class Array(Type):
 308     def __init__(self):
 309         self.set_default_element_type()
 310         self.set_default_length()
 311
 312     def set_default_element_type(self):
 313         self._default_element_type = None
 314
 315     def set_default_length(self):
 316         self._default_length = None
 317
 318     @property
 319     def align(self):
 320         return self._element_type.align
 321
 322     @property
 323     def element_type(self):
 324         return self._element_type
 325
 326     @element_type.setter
 327     def element_type(self, value):
 328         self._element_type = value
 329
 330     @property
 331     def length(self):
 332         return self._length
 333
 334     @length.setter
 335     def length(self, value):
 336         self._length = value
 337
 338
 339 class Struct(Type):
 340     def __init__(self):
 341         self.set_default_min_align()
 342         self.set_default_fields()
 343
 344     def set_default_min_align(self):
 345         self._min_align = 1
 346
 347     def set_default_fields(self):
 348         self._fields = collections.OrderedDict()
 349
 350     @property
 351     def min_align(self):
 352         return self._min_align
 353
 354     @min_align.setter
 355     def min_align(self, value):
 356         self._min_align = value
 357
 358     @property
 359     def align(self):
 360         align = self.min_align
 361
 362         for field in self.fields.values():
 363             if field.align is None:
 364                 return
 365
 366             if field.align > align:
 367                 align = field.align
 368
 369         return align
 370
 371     @property
 372     def fields(self):
 373         return self._fields
 374
 375     def __getitem__(self, key):
 376         return self.fields[key]
 377
 378     def __len__(self):
 379         return len(self._fields)
 380
 381
 382 class Trace:
 383     def __init__(self):
 384         self._byte_order = None
 385         self._packet_header_type = None
 386         self._uuid = None
 387
 388     @property
 389     def uuid(self):
 390         return self._uuid
 391
 392     @uuid.setter
 393     def uuid(self, value):
 394         self._uuid = value
 395
 396     @property
 397     def byte_order(self):
 398         return self._byte_order
 399
 400     @byte_order.setter
 401     def byte_order(self, value):
 402         self._byte_order = value
 403
 404     @property
 405     def packet_header_type(self):
 406         return self._packet_header_type
 407
 408     @packet_header_type.setter
 409     def packet_header_type(self, value):
 410         self._packet_header_type = value
 411
 412
 413 class Env(collections.OrderedDict):
 414     pass
 415
 416
 417 class Clock:
 418     def __init__(self):
 419         self.set_default_name()
 420         self.set_default_uuid()
 421         self.set_default_description()
 422         self.set_default_freq()
 423         self.set_default_error_cycles()
 424         self.set_default_offset_seconds()
 425         self.set_default_offset_cycles()
 426         self.set_default_absolute()
 427         self.set_default_return_ctype()
 428
 429     def set_default_name(self):
 430         self._name = None
 431
 432     def set_default_uuid(self):
 433         self._uuid = None
 434
 435     def set_default_description(self):
 436         self._description = None
 437
 438     def set_default_freq(self):
 439         self._freq = 1000000000
 440
 441     def set_default_error_cycles(self):
 442         self._error_cycles = 0
 443
 444     def set_default_offset_seconds(self):
 445         self._offset_seconds = 0
 446
 447     def set_default_offset_cycles(self):
 448         self._offset_cycles = 0
 449
 450     def set_default_absolute(self):
 451         self._absolute = False
 452
 453     def set_default_return_ctype(self):
 454         self._return_ctype = 'uint32_t'
 455
 456     @property
 457     def name(self):
 458         return self._name
 459
 460     @name.setter
 461     def name(self, value):
 462         self._name = value
 463
 464     @property
 465     def uuid(self):
 466         return self._uuid
 467
 468     @uuid.setter
 469     def uuid(self, value):
 470         self._uuid = value
 471
 472     @property
 473     def description(self):
 474         return self._description
 475
 476     @description.setter
 477     def description(self, value):
 478         self._description = value
 479
 480     @property
 481     def error_cycles(self):
 482         return self._error_cycles
 483
 484     @error_cycles.setter
 485     def error_cycles(self, value):
 486         self._error_cycles = value
 487
 488     @property
 489     def freq(self):
 490         return self._freq
 491
 492     @freq.setter
 493     def freq(self, value):
 494         self._freq = value
 495
 496     @property
 497     def offset_seconds(self):
 498         return self._offset_seconds
 499
 500     @offset_seconds.setter
 501     def offset_seconds(self, value):
 502         self._offset_seconds = value
 503
 504     @property
 505     def offset_cycles(self):
 506         return self._offset_cycles
 507
 508     @offset_cycles.setter
 509     def offset_cycles(self, value):
 510         self._offset_cycles = value
 511
 512     @property
 513     def absolute(self):
 514         return self._absolute
 515
 516     @absolute.setter
 517     def absolute(self, value):
 518         self._absolute = value
 519
 520     @property
 521     def return_ctype(self):
 522         return self._return_ctype
 523
 524     @return_ctype.setter
 525     def return_ctype(self, value):
 526         self._return_ctype = value
 527
 528
 529 LogLevel = collections.namedtuple('LogLevel', ['name', 'value'])
 530
 531
 532 class Event:
 533     def __init__(self):
 534         self._id = None
 535         self._name = None
 536         self._log_level = None
 537         self._context_type = None
 538         self._payload_type = None
 539
 540     @property
 541     def id(self):
 542         return self._id
 543
 544     @id.setter
 545     def id(self, value):
 546         self._id = value
 547
 548     @property
 549     def name(self):
 550         return self._name
 551
 552     @name.setter
 553     def name(self, value):
 554         self._name = value
 555
 556     @property
 557     def log_level(self):
 558         return self._log_level
 559
 560     @log_level.setter
 561     def log_level(self, value):
 562         self._log_level = value
 563
 564     @property
 565     def context_type(self):
 566         return self._context_type
 567
 568     @context_type.setter
 569     def context_type(self, value):
 570         self._context_type = value
 571
 572     @property
 573     def payload_type(self):
 574         return self._payload_type
 575
 576     @payload_type.setter
 577     def payload_type(self, value):
 578         self._payload_type = value
 579
 580     def __getitem__(self, key):
 581         assert(type(self.payload_type) is Struct)
 582         return self.payload_type[key]
 583
 584
 585 class Stream:
 586     def __init__(self):
 587         self._id = 0
 588         self._name = None
 589         self._packet_context_type = None
 590         self._event_header_type = None
 591         self._event_context_type = None
 592         self._events = collections.OrderedDict()
 593
 594     @property
 595     def name(self):
 596         return self._name
 597
 598     @name.setter
 599     def name(self, value):
 600         self._name = value
 601
 602     @property
 603     def id(self):
 604         return self._id
 605
 606     @id.setter
 607     def id(self, value):
 608         self._id = value
 609
 610     @property
 611     def packet_context_type(self):
 612         return self._packet_context_type
 613
 614     @packet_context_type.setter
 615     def packet_context_type(self, value):
 616         self._packet_context_type = value
 617
 618     @property
 619     def event_header_type(self):
 620         return self._event_header_type
 621
 622     @event_header_type.setter
 623     def event_header_type(self, value):
 624         self._event_header_type = value
 625
 626     @property
 627     def event_context_type(self):
 628         return self._event_context_type
 629
 630     @event_context_type.setter
 631     def event_context_type(self, value):
 632         self._event_context_type = value
 633
 634     @property
 635     def events(self):
 636         return self._events
 637
 638     def is_event_empty(self, event):
 639         total_fields = 0
 640
 641         if self.event_header_type:
 642             total_fields += len(self.event_header_type)
 643
 644         if self.event_context_type:
 645             total_fields += len(self.event_context_type)
 646
 647         if event.context_type:
 648             total_fields += len(event.context_type)
 649
 650         if event.payload_type:
 651             total_fields += len(event.payload_type)
 652
 653         return total_fields == 0
 654
 655
 656 class Metadata:
 657     def __init__(self):
 658         self._trace = None
 659         self._env = collections.OrderedDict()
 660         self._clocks = collections.OrderedDict()
 661         self._streams = collections.OrderedDict()
 662         self._default_stream_name = None
 663
 664     @property
 665     def trace(self):
 666         return self._trace
 667
 668     @trace.setter
 669     def trace(self, value):
 670         self._trace = value
 671
 672     @property
 673     def env(self):
 674         return self._env
 675
 676     @env.setter
 677     def env(self, value):
 678         self._env = value
 679
 680     @property
 681     def clocks(self):
 682         return self._clocks
 683
 684     @clocks.setter
 685     def clocks(self, value):
 686         self._clocks = value
 687
 688     @property
 689     def streams(self):
 690         return self._streams
 691
 692     @streams.setter
 693     def streams(self, value):
 694         self._streams = value
 695
 696     @property
 697     def default_stream_name(self):
 698         return self._default_stream_name
 699
 700     @default_stream_name.setter
 701     def default_stream_name(self, value):
 702         self._default_stream_name = value
 703
 704     @property
 705     def default_stream(self):
 706         if self._default_stream_name in self._streams:
 707             return self._streams[self._default_stream_name]