Gitiles
Code Review Sign In
gerrit.opencord.org / voltha / 0402dc52f1b9ec40a2b77ead9bab1e062cd344e2 / . / ofagent / loxi / of12 / oxm.py
blob: f2d6dfec6630a8adfe8a2d55c978a41e3139b136 [file] [log] [blame]
Zack Williams41513bf2018-07-07 20:08:35 -0700[diff] [blame]1# Copyright 2017-present Open Networking Foundation
2#
3# Licensed under the Apache License, Version 2.0 (the "License");
4# you may not use this file except in compliance with the License.
5# You may obtain a copy of the License at
6#
7# http://www.apache.org/licenses/LICENSE-2.0
8#
9# Unless required by applicable law or agreed to in writing, software
10# distributed under the License is distributed on an "AS IS" BASIS,
11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12# See the License for the specific language governing permissions and
13# limitations under the License.
Nathan Knuth418fdc82016-09-16 22:51:15 -0700[diff] [blame]14# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
15# Copyright (c) 2011, 2012 Open Networking Foundation
16# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
17# See the file LICENSE.pyloxi which should have been included in the source distribution
18
19# Automatically generated by LOXI from template module.py
20# Do not modify
21
22import struct
23import loxi
24import util
25import loxi.generic_util
26
27import sys
28ofp = sys.modules['loxi.of12']
29
30class oxm(loxi.OFObject):
31 subtypes = {}
32
33
34 def __init__(self, type_len=None):
35 if type_len != None:
36 self.type_len = type_len
37 else:
38 self.type_len = 0
39 return
40
41 def pack(self):
42 packed = []
43 packed.append(struct.pack("!L", self.type_len))
44 return ''.join(packed)
45
46 @staticmethod
47 def unpack(reader):
48 subtype, = reader.peek('!L', 0)
49 subclass = oxm.subtypes.get(subtype)
50 if subclass:
51 return subclass.unpack(reader)
52
53 obj = oxm()
54 obj.type_len = reader.read("!L")[0]
55 return obj
56
57 def __eq__(self, other):
58 if type(self) != type(other): return False
59 if self.type_len != other.type_len: return False
60 return True
61
62 def pretty_print(self, q):
63 q.text("oxm {")
64 with q.group():
65 with q.indent(2):
66 q.breakable()
67 q.breakable()
68 q.text('}')
69
70
71class arp_op(oxm):
72 type_len = 2147494402
73
74 def __init__(self, value=None):
75 if value != None:
76 self.value = value
77 else:
78 self.value = 0
79 return
80
81 def pack(self):
82 packed = []
83 packed.append(struct.pack("!L", self.type_len))
84 packed.append(struct.pack("!H", self.value))
85 return ''.join(packed)
86
87 @staticmethod
88 def unpack(reader):
89 obj = arp_op()
90 _type_len = reader.read("!L")[0]
91 assert(_type_len == 2147494402)
92 obj.value = reader.read("!H")[0]
93 return obj
94
95 def __eq__(self, other):
96 if type(self) != type(other): return False
97 if self.value != other.value: return False
98 return True
99
100 def pretty_print(self, q):
101 q.text("arp_op {")
102 with q.group():
103 with q.indent(2):
104 q.breakable()
105 q.text("value = ");
106 q.text("%#x" % self.value)
107 q.breakable()
108 q.text('}')
109
110oxm.subtypes[2147494402] = arp_op
111
112class arp_op_masked(oxm):
113 type_len = 2147494660
114
115 def __init__(self, value=None, value_mask=None):
116 if value != None:
117 self.value = value
118 else:
119 self.value = 0
120 if value_mask != None:
121 self.value_mask = value_mask
122 else:
123 self.value_mask = 0
124 return
125
126 def pack(self):
127 packed = []
128 packed.append(struct.pack("!L", self.type_len))
129 packed.append(struct.pack("!H", self.value))
130 packed.append(struct.pack("!H", self.value_mask))
131 return ''.join(packed)
132
133 @staticmethod
134 def unpack(reader):
135 obj = arp_op_masked()
136 _type_len = reader.read("!L")[0]
137 assert(_type_len == 2147494660)
138 obj.value = reader.read("!H")[0]
139 obj.value_mask = reader.read("!H")[0]
140 return obj
141
142 def __eq__(self, other):
143 if type(self) != type(other): return False
144 if self.value != other.value: return False
145 if self.value_mask != other.value_mask: return False
146 return True
147
148 def pretty_print(self, q):
149 q.text("arp_op_masked {")
150 with q.group():
151 with q.indent(2):
152 q.breakable()
153 q.text("value = ");
154 q.text("%#x" % self.value)
155 q.text(","); q.breakable()
156 q.text("value_mask = ");
157 q.text("%#x" % self.value_mask)
158 q.breakable()
159 q.text('}')
160
161oxm.subtypes[2147494660] = arp_op_masked
162
163class arp_sha(oxm):
164 type_len = 2147495942
165
166 def __init__(self, value=None):
167 if value != None:
168 self.value = value
169 else:
170 self.value = [0,0,0,0,0,0]
171 return
172
173 def pack(self):
174 packed = []
175 packed.append(struct.pack("!L", self.type_len))
176 packed.append(struct.pack("!6B", *self.value))
177 return ''.join(packed)
178
179 @staticmethod
180 def unpack(reader):
181 obj = arp_sha()
182 _type_len = reader.read("!L")[0]
183 assert(_type_len == 2147495942)
184 obj.value = list(reader.read('!6B'))
185 return obj
186
187 def __eq__(self, other):
188 if type(self) != type(other): return False
189 if self.value != other.value: return False
190 return True
191
192 def pretty_print(self, q):
193 q.text("arp_sha {")
194 with q.group():
195 with q.indent(2):
196 q.breakable()
197 q.text("value = ");
198 q.text(util.pretty_mac(self.value))
199 q.breakable()
200 q.text('}')
201
202oxm.subtypes[2147495942] = arp_sha
203
204class arp_sha_masked(oxm):
205 type_len = 2147496204
206
207 def __init__(self, value=None, value_mask=None):
208 if value != None:
209 self.value = value
210 else:
211 self.value = [0,0,0,0,0,0]
212 if value_mask != None:
213 self.value_mask = value_mask
214 else:
215 self.value_mask = [0,0,0,0,0,0]
216 return
217
218 def pack(self):
219 packed = []
220 packed.append(struct.pack("!L", self.type_len))
221 packed.append(struct.pack("!6B", *self.value))
222 packed.append(struct.pack("!6B", *self.value_mask))
223 return ''.join(packed)
224
225 @staticmethod
226 def unpack(reader):
227 obj = arp_sha_masked()
228 _type_len = reader.read("!L")[0]
229 assert(_type_len == 2147496204)
230 obj.value = list(reader.read('!6B'))
231 obj.value_mask = list(reader.read('!6B'))
232 return obj
233
234 def __eq__(self, other):
235 if type(self) != type(other): return False
236 if self.value != other.value: return False
237 if self.value_mask != other.value_mask: return False
238 return True
239
240 def pretty_print(self, q):
241 q.text("arp_sha_masked {")
242 with q.group():
243 with q.indent(2):
244 q.breakable()
245 q.text("value = ");
246 q.text(util.pretty_mac(self.value))
247 q.text(","); q.breakable()
248 q.text("value_mask = ");
249 q.text(util.pretty_mac(self.value_mask))
250 q.breakable()
251 q.text('}')
252
253oxm.subtypes[2147496204] = arp_sha_masked
254
255class arp_spa(oxm):
256 type_len = 2147494916
257
258 def __init__(self, value=None):
259 if value != None:
260 self.value = value
261 else:
262 self.value = 0
263 return
264
265 def pack(self):
266 packed = []
267 packed.append(struct.pack("!L", self.type_len))
268 packed.append(struct.pack("!L", self.value))
269 return ''.join(packed)
270
271 @staticmethod
272 def unpack(reader):
273 obj = arp_spa()
274 _type_len = reader.read("!L")[0]
275 assert(_type_len == 2147494916)
276 obj.value = reader.read("!L")[0]
277 return obj
278
279 def __eq__(self, other):
280 if type(self) != type(other): return False
281 if self.value != other.value: return False
282 return True
283
284 def pretty_print(self, q):
285 q.text("arp_spa {")
286 with q.group():
287 with q.indent(2):
288 q.breakable()
289 q.text("value = ");
290 q.text("%#x" % self.value)
291 q.breakable()
292 q.text('}')
293
294oxm.subtypes[2147494916] = arp_spa
295
296class arp_spa_masked(oxm):
297 type_len = 2147495176
298
299 def __init__(self, value=None, value_mask=None):
300 if value != None:
301 self.value = value
302 else:
303 self.value = 0
304 if value_mask != None:
305 self.value_mask = value_mask
306 else:
307 self.value_mask = 0
308 return
309
310 def pack(self):
311 packed = []
312 packed.append(struct.pack("!L", self.type_len))
313 packed.append(struct.pack("!L", self.value))
314 packed.append(struct.pack("!L", self.value_mask))
315 return ''.join(packed)
316
317 @staticmethod
318 def unpack(reader):
319 obj = arp_spa_masked()
320 _type_len = reader.read("!L")[0]
321 assert(_type_len == 2147495176)
322 obj.value = reader.read("!L")[0]
323 obj.value_mask = reader.read("!L")[0]
324 return obj
325
326 def __eq__(self, other):
327 if type(self) != type(other): return False
328 if self.value != other.value: return False
329 if self.value_mask != other.value_mask: return False
330 return True
331
332 def pretty_print(self, q):
333 q.text("arp_spa_masked {")
334 with q.group():
335 with q.indent(2):
336 q.breakable()
337 q.text("value = ");
338 q.text("%#x" % self.value)
339 q.text(","); q.breakable()
340 q.text("value_mask = ");
341 q.text("%#x" % self.value_mask)
342 q.breakable()
343 q.text('}')
344
345oxm.subtypes[2147495176] = arp_spa_masked
346
347class arp_tha(oxm):
348 type_len = 2147496454
349
350 def __init__(self, value=None):
351 if value != None:
352 self.value = value
353 else:
354 self.value = [0,0,0,0,0,0]
355 return
356
357 def pack(self):
358 packed = []
359 packed.append(struct.pack("!L", self.type_len))
360 packed.append(struct.pack("!6B", *self.value))
361 return ''.join(packed)
362
363 @staticmethod
364 def unpack(reader):
365 obj = arp_tha()
366 _type_len = reader.read("!L")[0]
367 assert(_type_len == 2147496454)
368 obj.value = list(reader.read('!6B'))
369 return obj
370
371 def __eq__(self, other):
372 if type(self) != type(other): return False
373 if self.value != other.value: return False
374 return True
375
376 def pretty_print(self, q):
377 q.text("arp_tha {")
378 with q.group():
379 with q.indent(2):
380 q.breakable()
381 q.text("value = ");
382 q.text(util.pretty_mac(self.value))
383 q.breakable()
384 q.text('}')
385
386oxm.subtypes[2147496454] = arp_tha
387
388class arp_tha_masked(oxm):
389 type_len = 2147496716
390
391 def __init__(self, value=None, value_mask=None):
392 if value != None:
393 self.value = value
394 else:
395 self.value = [0,0,0,0,0,0]
396 if value_mask != None:
397 self.value_mask = value_mask
398 else:
399 self.value_mask = [0,0,0,0,0,0]
400 return
401
402 def pack(self):
403 packed = []
404 packed.append(struct.pack("!L", self.type_len))
405 packed.append(struct.pack("!6B", *self.value))
406 packed.append(struct.pack("!6B", *self.value_mask))
407 return ''.join(packed)
408
409 @staticmethod
410 def unpack(reader):
411 obj = arp_tha_masked()
412 _type_len = reader.read("!L")[0]
413 assert(_type_len == 2147496716)
414 obj.value = list(reader.read('!6B'))
415 obj.value_mask = list(reader.read('!6B'))
416 return obj
417
418 def __eq__(self, other):
419 if type(self) != type(other): return False
420 if self.value != other.value: return False
421 if self.value_mask != other.value_mask: return False
422 return True
423
424 def pretty_print(self, q):
425 q.text("arp_tha_masked {")
426 with q.group():
427 with q.indent(2):
428 q.breakable()
429 q.text("value = ");
430 q.text(util.pretty_mac(self.value))
431 q.text(","); q.breakable()
432 q.text("value_mask = ");
433 q.text(util.pretty_mac(self.value_mask))
434 q.breakable()
435 q.text('}')
436
437oxm.subtypes[2147496716] = arp_tha_masked
438
439class arp_tpa(oxm):
440 type_len = 2147495428
441
442 def __init__(self, value=None):
443 if value != None:
444 self.value = value
445 else:
446 self.value = 0
447 return
448
449 def pack(self):
450 packed = []
451 packed.append(struct.pack("!L", self.type_len))
452 packed.append(struct.pack("!L", self.value))
453 return ''.join(packed)
454
455 @staticmethod
456 def unpack(reader):
457 obj = arp_tpa()
458 _type_len = reader.read("!L")[0]
459 assert(_type_len == 2147495428)
460 obj.value = reader.read("!L")[0]
461 return obj
462
463 def __eq__(self, other):
464 if type(self) != type(other): return False
465 if self.value != other.value: return False
466 return True
467
468 def pretty_print(self, q):
469 q.text("arp_tpa {")
470 with q.group():
471 with q.indent(2):
472 q.breakable()
473 q.text("value = ");
474 q.text("%#x" % self.value)
475 q.breakable()
476 q.text('}')
477
478oxm.subtypes[2147495428] = arp_tpa
479
480class arp_tpa_masked(oxm):
481 type_len = 2147495688
482
483 def __init__(self, value=None, value_mask=None):
484 if value != None:
485 self.value = value
486 else:
487 self.value = 0
488 if value_mask != None:
489 self.value_mask = value_mask
490 else:
491 self.value_mask = 0
492 return
493
494 def pack(self):
495 packed = []
496 packed.append(struct.pack("!L", self.type_len))
497 packed.append(struct.pack("!L", self.value))
498 packed.append(struct.pack("!L", self.value_mask))
499 return ''.join(packed)
500
501 @staticmethod
502 def unpack(reader):
503 obj = arp_tpa_masked()
504 _type_len = reader.read("!L")[0]
505 assert(_type_len == 2147495688)
506 obj.value = reader.read("!L")[0]
507 obj.value_mask = reader.read("!L")[0]
508 return obj
509
510 def __eq__(self, other):
511 if type(self) != type(other): return False
512 if self.value != other.value: return False
513 if self.value_mask != other.value_mask: return False
514 return True
515
516 def pretty_print(self, q):
517 q.text("arp_tpa_masked {")
518 with q.group():
519 with q.indent(2):
520 q.breakable()
521 q.text("value = ");
522 q.text("%#x" % self.value)
523 q.text(","); q.breakable()
524 q.text("value_mask = ");
525 q.text("%#x" % self.value_mask)
526 q.breakable()
527 q.text('}')
528
529oxm.subtypes[2147495688] = arp_tpa_masked
530
531class bsn_egr_port_group_id(oxm):
532 type_len = 200196
533
534 def __init__(self, value=None):
535 if value != None:
536 self.value = value
537 else:
538 self.value = 0
539 return
540
541 def pack(self):
542 packed = []
543 packed.append(struct.pack("!L", self.type_len))
544 packed.append(struct.pack("!L", self.value))
545 return ''.join(packed)
546
547 @staticmethod
548 def unpack(reader):
549 obj = bsn_egr_port_group_id()
550 _type_len = reader.read("!L")[0]
551 assert(_type_len == 200196)
552 obj.value = reader.read("!L")[0]
553 return obj
554
555 def __eq__(self, other):
556 if type(self) != type(other): return False
557 if self.value != other.value: return False
558 return True
559
560 def pretty_print(self, q):
561 q.text("bsn_egr_port_group_id {")
562 with q.group():
563 with q.indent(2):
564 q.breakable()
565 q.text("value = ");
566 q.text("%#x" % self.value)
567 q.breakable()
568 q.text('}')
569
570oxm.subtypes[200196] = bsn_egr_port_group_id
571
572class bsn_egr_port_group_id_masked(oxm):
573 type_len = 200456
574
575 def __init__(self, value=None, value_mask=None):
576 if value != None:
577 self.value = value
578 else:
579 self.value = 0
580 if value_mask != None:
581 self.value_mask = value_mask
582 else:
583 self.value_mask = 0
584 return
585
586 def pack(self):
587 packed = []
588 packed.append(struct.pack("!L", self.type_len))
589 packed.append(struct.pack("!L", self.value))
590 packed.append(struct.pack("!L", self.value_mask))
591 return ''.join(packed)
592
593 @staticmethod
594 def unpack(reader):
595 obj = bsn_egr_port_group_id_masked()
596 _type_len = reader.read("!L")[0]
597 assert(_type_len == 200456)
598 obj.value = reader.read("!L")[0]
599 obj.value_mask = reader.read("!L")[0]
600 return obj
601
602 def __eq__(self, other):
603 if type(self) != type(other): return False
604 if self.value != other.value: return False
605 if self.value_mask != other.value_mask: return False
606 return True
607
608 def pretty_print(self, q):
609 q.text("bsn_egr_port_group_id_masked {")
610 with q.group():
611 with q.indent(2):
612 q.breakable()
613 q.text("value = ");
614 q.text("%#x" % self.value)
615 q.text(","); q.breakable()
616 q.text("value_mask = ");
617 q.text("%#x" % self.value_mask)
618 q.breakable()
619 q.text('}')
620
621oxm.subtypes[200456] = bsn_egr_port_group_id_masked
622
623class bsn_global_vrf_allowed(oxm):
624 type_len = 198145
625
626 def __init__(self, value=None):
627 if value != None:
628 self.value = value
629 else:
630 self.value = 0
631 return
632
633 def pack(self):
634 packed = []
635 packed.append(struct.pack("!L", self.type_len))
636 packed.append(struct.pack("!B", self.value))
637 return ''.join(packed)
638
639 @staticmethod
640 def unpack(reader):
641 obj = bsn_global_vrf_allowed()
642 _type_len = reader.read("!L")[0]
643 assert(_type_len == 198145)
644 obj.value = reader.read("!B")[0]
645 return obj
646
647 def __eq__(self, other):
648 if type(self) != type(other): return False
649 if self.value != other.value: return False
650 return True
651
652 def pretty_print(self, q):
653 q.text("bsn_global_vrf_allowed {")
654 with q.group():
655 with q.indent(2):
656 q.breakable()
657 q.text("value = ");
658 q.text("%#x" % self.value)
659 q.breakable()
660 q.text('}')
661
662oxm.subtypes[198145] = bsn_global_vrf_allowed
663
664class bsn_global_vrf_allowed_masked(oxm):
665 type_len = 198402
666
667 def __init__(self, value=None, value_mask=None):
668 if value != None:
669 self.value = value
670 else:
671 self.value = 0
672 if value_mask != None:
673 self.value_mask = value_mask
674 else:
675 self.value_mask = 0
676 return
677
678 def pack(self):
679 packed = []
680 packed.append(struct.pack("!L", self.type_len))
681 packed.append(struct.pack("!B", self.value))
682 packed.append(struct.pack("!B", self.value_mask))
683 return ''.join(packed)
684
685 @staticmethod
686 def unpack(reader):
687 obj = bsn_global_vrf_allowed_masked()
688 _type_len = reader.read("!L")[0]
689 assert(_type_len == 198402)
690 obj.value = reader.read("!B")[0]
691 obj.value_mask = reader.read("!B")[0]
692 return obj
693
694 def __eq__(self, other):
695 if type(self) != type(other): return False
696 if self.value != other.value: return False
697 if self.value_mask != other.value_mask: return False
698 return True
699
700 def pretty_print(self, q):
701 q.text("bsn_global_vrf_allowed_masked {")
702 with q.group():
703 with q.indent(2):
704 q.breakable()
705 q.text("value = ");
706 q.text("%#x" % self.value)
707 q.text(","); q.breakable()
708 q.text("value_mask = ");
709 q.text("%#x" % self.value_mask)
710 q.breakable()
711 q.text('}')
712
713oxm.subtypes[198402] = bsn_global_vrf_allowed_masked
714
715class bsn_in_ports_128(oxm):
716 type_len = 196624
717
718 def __init__(self, value=None):
719 if value != None:
720 self.value = value
721 else:
722 self.value = set()
723 return
724
725 def pack(self):
726 packed = []
727 packed.append(struct.pack("!L", self.type_len))
728 packed.append(util.pack_bitmap_128(self.value))
729 return ''.join(packed)
730
731 @staticmethod
732 def unpack(reader):
733 obj = bsn_in_ports_128()
734 _type_len = reader.read("!L")[0]
735 assert(_type_len == 196624)
736 obj.value = util.unpack_bitmap_128(reader)
737 return obj
738
739 def __eq__(self, other):
740 if type(self) != type(other): return False
741 if self.value != other.value: return False
742 return True
743
744 def pretty_print(self, q):
745 q.text("bsn_in_ports_128 {")
746 with q.group():
747 with q.indent(2):
748 q.breakable()
749 q.text("value = ");
750 q.pp(self.value)
751 q.breakable()
752 q.text('}')
753
754oxm.subtypes[196624] = bsn_in_ports_128
755
756class bsn_in_ports_128_masked(oxm):
757 type_len = 196896
758
759 def __init__(self, value=None, value_mask=None):
760 if value != None:
761 self.value = value
762 else:
763 self.value = set()
764 if value_mask != None:
765 self.value_mask = value_mask
766 else:
767 self.value_mask = set()
768 return
769
770 def pack(self):
771 packed = []
772 packed.append(struct.pack("!L", self.type_len))
773 packed.append(util.pack_bitmap_128(self.value))
774 packed.append(util.pack_bitmap_128(self.value_mask))
775 return ''.join(packed)
776
777 @staticmethod
778 def unpack(reader):
779 obj = bsn_in_ports_128_masked()
780 _type_len = reader.read("!L")[0]
781 assert(_type_len == 196896)
782 obj.value = util.unpack_bitmap_128(reader)
783 obj.value_mask = util.unpack_bitmap_128(reader)
784 return obj
785
786 def __eq__(self, other):
787 if type(self) != type(other): return False
788 if self.value != other.value: return False
789 if self.value_mask != other.value_mask: return False
790 return True
791
792 def pretty_print(self, q):
793 q.text("bsn_in_ports_128_masked {")
794 with q.group():
795 with q.indent(2):
796 q.breakable()
797 q.text("value = ");
798 q.pp(self.value)
799 q.text(","); q.breakable()
800 q.text("value_mask = ");
801 q.pp(self.value_mask)
802 q.breakable()
803 q.text('}')
804
805oxm.subtypes[196896] = bsn_in_ports_128_masked
806
807class bsn_in_ports_512(oxm):
808 type_len = 206400
809
810 def __init__(self, value=None):
811 if value != None:
812 self.value = value
813 else:
814 self.value = set()
815 return
816
817 def pack(self):
818 packed = []
819 packed.append(struct.pack("!L", self.type_len))
820 packed.append(util.pack_bitmap_512(self.value))
821 return ''.join(packed)
822
823 @staticmethod
824 def unpack(reader):
825 obj = bsn_in_ports_512()
826 _type_len = reader.read("!L")[0]
827 assert(_type_len == 206400)
828 obj.value = util.unpack_bitmap_512(reader)
829 return obj
830
831 def __eq__(self, other):
832 if type(self) != type(other): return False
833 if self.value != other.value: return False
834 return True
835
836 def pretty_print(self, q):
837 q.text("bsn_in_ports_512 {")
838 with q.group():
839 with q.indent(2):
840 q.breakable()
841 q.text("value = ");
842 q.pp(self.value)
843 q.breakable()
844 q.text('}')
845
846oxm.subtypes[206400] = bsn_in_ports_512
847
848class bsn_in_ports_512_masked(oxm):
849 type_len = 206720
850
851 def __init__(self, value=None, value_mask=None):
852 if value != None:
853 self.value = value
854 else:
855 self.value = set()
856 if value_mask != None:
857 self.value_mask = value_mask
858 else:
859 self.value_mask = set()
860 return
861
862 def pack(self):
863 packed = []
864 packed.append(struct.pack("!L", self.type_len))
865 packed.append(util.pack_bitmap_512(self.value))
866 packed.append(util.pack_bitmap_512(self.value_mask))
867 return ''.join(packed)
868
869 @staticmethod
870 def unpack(reader):
871 obj = bsn_in_ports_512_masked()
872 _type_len = reader.read("!L")[0]
873 assert(_type_len == 206720)
874 obj.value = util.unpack_bitmap_512(reader)
875 obj.value_mask = util.unpack_bitmap_512(reader)
876 return obj
877
878 def __eq__(self, other):
879 if type(self) != type(other): return False
880 if self.value != other.value: return False
881 if self.value_mask != other.value_mask: return False
882 return True
883
884 def pretty_print(self, q):
885 q.text("bsn_in_ports_512_masked {")
886 with q.group():
887 with q.indent(2):
888 q.breakable()
889 q.text("value = ");
890 q.pp(self.value)
891 q.text(","); q.breakable()
892 q.text("value_mask = ");
893 q.pp(self.value_mask)
894 q.breakable()
895 q.text('}')
896
897oxm.subtypes[206720] = bsn_in_ports_512_masked
898
899class bsn_ingress_port_group_id(oxm):
900 type_len = 206852
901
902 def __init__(self, value=None):
903 if value != None:
904 self.value = value
905 else:
906 self.value = 0
907 return
908
909 def pack(self):
910 packed = []
911 packed.append(struct.pack("!L", self.type_len))
912 packed.append(struct.pack("!L", self.value))
913 return ''.join(packed)
914
915 @staticmethod
916 def unpack(reader):
917 obj = bsn_ingress_port_group_id()
918 _type_len = reader.read("!L")[0]
919 assert(_type_len == 206852)
920 obj.value = reader.read("!L")[0]
921 return obj
922
923 def __eq__(self, other):
924 if type(self) != type(other): return False
925 if self.value != other.value: return False
926 return True
927
928 def pretty_print(self, q):
929 q.text("bsn_ingress_port_group_id {")
930 with q.group():
931 with q.indent(2):
932 q.breakable()
933 q.text("value = ");
934 q.text("%#x" % self.value)
935 q.breakable()
936 q.text('}')
937
938oxm.subtypes[206852] = bsn_ingress_port_group_id
939
940class bsn_ingress_port_group_id_masked(oxm):
941 type_len = 207112
942
943 def __init__(self, value=None, value_mask=None):
944 if value != None:
945 self.value = value
946 else:
947 self.value = 0
948 if value_mask != None:
949 self.value_mask = value_mask
950 else:
951 self.value_mask = 0
952 return
953
954 def pack(self):
955 packed = []
956 packed.append(struct.pack("!L", self.type_len))
957 packed.append(struct.pack("!L", self.value))
958 packed.append(struct.pack("!L", self.value_mask))
959 return ''.join(packed)
960
961 @staticmethod
962 def unpack(reader):
963 obj = bsn_ingress_port_group_id_masked()
964 _type_len = reader.read("!L")[0]
965 assert(_type_len == 207112)
966 obj.value = reader.read("!L")[0]
967 obj.value_mask = reader.read("!L")[0]
968 return obj
969
970 def __eq__(self, other):
971 if type(self) != type(other): return False
972 if self.value != other.value: return False
973 if self.value_mask != other.value_mask: return False
974 return True
975
976 def pretty_print(self, q):
977 q.text("bsn_ingress_port_group_id_masked {")
978 with q.group():
979 with q.indent(2):
980 q.breakable()
981 q.text("value = ");
982 q.text("%#x" % self.value)
983 q.text(","); q.breakable()
984 q.text("value_mask = ");
985 q.text("%#x" % self.value_mask)
986 q.breakable()
987 q.text('}')
988
989oxm.subtypes[207112] = bsn_ingress_port_group_id_masked
990
991class bsn_l2_cache_hit(oxm):
992 type_len = 205825
993
994 def __init__(self, value=None):
995 if value != None:
996 self.value = value
997 else:
998 self.value = 0
999 return
1000
1001 def pack(self):
1002 packed = []
1003 packed.append(struct.pack("!L", self.type_len))
1004 packed.append(struct.pack("!B", self.value))
1005 return ''.join(packed)
1006
1007 @staticmethod
1008 def unpack(reader):
1009 obj = bsn_l2_cache_hit()
1010 _type_len = reader.read("!L")[0]
1011 assert(_type_len == 205825)
1012 obj.value = reader.read("!B")[0]
1013 return obj
1014
1015 def __eq__(self, other):
1016 if type(self) != type(other): return False
1017 if self.value != other.value: return False
1018 return True
1019
1020 def pretty_print(self, q):
1021 q.text("bsn_l2_cache_hit {")
1022 with q.group():
1023 with q.indent(2):
1024 q.breakable()
1025 q.text("value = ");
1026 q.text("%#x" % self.value)
1027 q.breakable()
1028 q.text('}')
1029
1030oxm.subtypes[205825] = bsn_l2_cache_hit
1031
1032class bsn_l2_cache_hit_masked(oxm):
1033 type_len = 206082
1034
1035 def __init__(self, value=None, value_mask=None):
1036 if value != None:
1037 self.value = value
1038 else:
1039 self.value = 0
1040 if value_mask != None:
1041 self.value_mask = value_mask
1042 else:
1043 self.value_mask = 0
1044 return
1045
1046 def pack(self):
1047 packed = []
1048 packed.append(struct.pack("!L", self.type_len))
1049 packed.append(struct.pack("!B", self.value))
1050 packed.append(struct.pack("!B", self.value_mask))
1051 return ''.join(packed)
1052
1053 @staticmethod
1054 def unpack(reader):
1055 obj = bsn_l2_cache_hit_masked()
1056 _type_len = reader.read("!L")[0]
1057 assert(_type_len == 206082)
1058 obj.value = reader.read("!B")[0]
1059 obj.value_mask = reader.read("!B")[0]
1060 return obj
1061
1062 def __eq__(self, other):
1063 if type(self) != type(other): return False
1064 if self.value != other.value: return False
1065 if self.value_mask != other.value_mask: return False
1066 return True
1067
1068 def pretty_print(self, q):
1069 q.text("bsn_l2_cache_hit_masked {")
1070 with q.group():
1071 with q.indent(2):
1072 q.breakable()
1073 q.text("value = ");
1074 q.text("%#x" % self.value)
1075 q.text(","); q.breakable()
1076 q.text("value_mask = ");
1077 q.text("%#x" % self.value_mask)
1078 q.breakable()
1079 q.text('}')
1080
1081oxm.subtypes[206082] = bsn_l2_cache_hit_masked
1082
1083class bsn_l3_dst_class_id(oxm):
1084 type_len = 199684
1085
1086 def __init__(self, value=None):
1087 if value != None:
1088 self.value = value
1089 else:
1090 self.value = 0
1091 return
1092
1093 def pack(self):
1094 packed = []
1095 packed.append(struct.pack("!L", self.type_len))
1096 packed.append(struct.pack("!L", self.value))
1097 return ''.join(packed)
1098
1099 @staticmethod
1100 def unpack(reader):
1101 obj = bsn_l3_dst_class_id()
1102 _type_len = reader.read("!L")[0]
1103 assert(_type_len == 199684)
1104 obj.value = reader.read("!L")[0]
1105 return obj
1106
1107 def __eq__(self, other):
1108 if type(self) != type(other): return False
1109 if self.value != other.value: return False
1110 return True
1111
1112 def pretty_print(self, q):
1113 q.text("bsn_l3_dst_class_id {")
1114 with q.group():
1115 with q.indent(2):
1116 q.breakable()
1117 q.text("value = ");
1118 q.text("%#x" % self.value)
1119 q.breakable()
1120 q.text('}')
1121
1122oxm.subtypes[199684] = bsn_l3_dst_class_id
1123
1124class bsn_l3_dst_class_id_masked(oxm):
1125 type_len = 199944
1126
1127 def __init__(self, value=None, value_mask=None):
1128 if value != None:
1129 self.value = value
1130 else:
1131 self.value = 0
1132 if value_mask != None:
1133 self.value_mask = value_mask
1134 else:
1135 self.value_mask = 0
1136 return
1137
1138 def pack(self):
1139 packed = []
1140 packed.append(struct.pack("!L", self.type_len))
1141 packed.append(struct.pack("!L", self.value))
1142 packed.append(struct.pack("!L", self.value_mask))
1143 return ''.join(packed)
1144
1145 @staticmethod
1146 def unpack(reader):
1147 obj = bsn_l3_dst_class_id_masked()
1148 _type_len = reader.read("!L")[0]
1149 assert(_type_len == 199944)
1150 obj.value = reader.read("!L")[0]
1151 obj.value_mask = reader.read("!L")[0]
1152 return obj
1153
1154 def __eq__(self, other):
1155 if type(self) != type(other): return False
1156 if self.value != other.value: return False
1157 if self.value_mask != other.value_mask: return False
1158 return True
1159
1160 def pretty_print(self, q):
1161 q.text("bsn_l3_dst_class_id_masked {")
1162 with q.group():
1163 with q.indent(2):
1164 q.breakable()
1165 q.text("value = ");
1166 q.text("%#x" % self.value)
1167 q.text(","); q.breakable()
1168 q.text("value_mask = ");
1169 q.text("%#x" % self.value_mask)
1170 q.breakable()
1171 q.text('}')
1172
1173oxm.subtypes[199944] = bsn_l3_dst_class_id_masked
1174
1175class bsn_l3_interface_class_id(oxm):
1176 type_len = 198660
1177
1178 def __init__(self, value=None):
1179 if value != None:
1180 self.value = value
1181 else:
1182 self.value = 0
1183 return
1184
1185 def pack(self):
1186 packed = []
1187 packed.append(struct.pack("!L", self.type_len))
1188 packed.append(struct.pack("!L", self.value))
1189 return ''.join(packed)
1190
1191 @staticmethod
1192 def unpack(reader):
1193 obj = bsn_l3_interface_class_id()
1194 _type_len = reader.read("!L")[0]
1195 assert(_type_len == 198660)
1196 obj.value = reader.read("!L")[0]
1197 return obj
1198
1199 def __eq__(self, other):
1200 if type(self) != type(other): return False
1201 if self.value != other.value: return False
1202 return True
1203
1204 def pretty_print(self, q):
1205 q.text("bsn_l3_interface_class_id {")
1206 with q.group():
1207 with q.indent(2):
1208 q.breakable()
1209 q.text("value = ");
1210 q.text("%#x" % self.value)
1211 q.breakable()
1212 q.text('}')
1213
1214oxm.subtypes[198660] = bsn_l3_interface_class_id
1215
1216class bsn_l3_interface_class_id_masked(oxm):
1217 type_len = 198920
1218
1219 def __init__(self, value=None, value_mask=None):
1220 if value != None:
1221 self.value = value
1222 else:
1223 self.value = 0
1224 if value_mask != None:
1225 self.value_mask = value_mask
1226 else:
1227 self.value_mask = 0
1228 return
1229
1230 def pack(self):
1231 packed = []
1232 packed.append(struct.pack("!L", self.type_len))
1233 packed.append(struct.pack("!L", self.value))
1234 packed.append(struct.pack("!L", self.value_mask))
1235 return ''.join(packed)
1236
1237 @staticmethod
1238 def unpack(reader):
1239 obj = bsn_l3_interface_class_id_masked()
1240 _type_len = reader.read("!L")[0]
1241 assert(_type_len == 198920)
1242 obj.value = reader.read("!L")[0]
1243 obj.value_mask = reader.read("!L")[0]
1244 return obj
1245
1246 def __eq__(self, other):
1247 if type(self) != type(other): return False
1248 if self.value != other.value: return False
1249 if self.value_mask != other.value_mask: return False
1250 return True
1251
1252 def pretty_print(self, q):
1253 q.text("bsn_l3_interface_class_id_masked {")
1254 with q.group():
1255 with q.indent(2):
1256 q.breakable()
1257 q.text("value = ");
1258 q.text("%#x" % self.value)
1259 q.text(","); q.breakable()
1260 q.text("value_mask = ");
1261 q.text("%#x" % self.value_mask)
1262 q.breakable()
1263 q.text('}')
1264
1265oxm.subtypes[198920] = bsn_l3_interface_class_id_masked
1266
1267class bsn_l3_src_class_id(oxm):
1268 type_len = 199172
1269
1270 def __init__(self, value=None):
1271 if value != None:
1272 self.value = value
1273 else:
1274 self.value = 0
1275 return
1276
1277 def pack(self):
1278 packed = []
1279 packed.append(struct.pack("!L", self.type_len))
1280 packed.append(struct.pack("!L", self.value))
1281 return ''.join(packed)
1282
1283 @staticmethod
1284 def unpack(reader):
1285 obj = bsn_l3_src_class_id()
1286 _type_len = reader.read("!L")[0]
1287 assert(_type_len == 199172)
1288 obj.value = reader.read("!L")[0]
1289 return obj
1290
1291 def __eq__(self, other):
1292 if type(self) != type(other): return False
1293 if self.value != other.value: return False
1294 return True
1295
1296 def pretty_print(self, q):
1297 q.text("bsn_l3_src_class_id {")
1298 with q.group():
1299 with q.indent(2):
1300 q.breakable()
1301 q.text("value = ");
1302 q.text("%#x" % self.value)
1303 q.breakable()
1304 q.text('}')
1305
1306oxm.subtypes[199172] = bsn_l3_src_class_id
1307
1308class bsn_l3_src_class_id_masked(oxm):
1309 type_len = 199432
1310
1311 def __init__(self, value=None, value_mask=None):
1312 if value != None:
1313 self.value = value
1314 else:
1315 self.value = 0
1316 if value_mask != None:
1317 self.value_mask = value_mask
1318 else:
1319 self.value_mask = 0
1320 return
1321
1322 def pack(self):
1323 packed = []
1324 packed.append(struct.pack("!L", self.type_len))
1325 packed.append(struct.pack("!L", self.value))
1326 packed.append(struct.pack("!L", self.value_mask))
1327 return ''.join(packed)
1328
1329 @staticmethod
1330 def unpack(reader):
1331 obj = bsn_l3_src_class_id_masked()
1332 _type_len = reader.read("!L")[0]
1333 assert(_type_len == 199432)
1334 obj.value = reader.read("!L")[0]
1335 obj.value_mask = reader.read("!L")[0]
1336 return obj
1337
1338 def __eq__(self, other):
1339 if type(self) != type(other): return False
1340 if self.value != other.value: return False
1341 if self.value_mask != other.value_mask: return False
1342 return True
1343
1344 def pretty_print(self, q):
1345 q.text("bsn_l3_src_class_id_masked {")
1346 with q.group():
1347 with q.indent(2):
1348 q.breakable()
1349 q.text("value = ");
1350 q.text("%#x" % self.value)
1351 q.text(","); q.breakable()
1352 q.text("value_mask = ");
1353 q.text("%#x" % self.value_mask)
1354 q.breakable()
1355 q.text('}')
1356
1357oxm.subtypes[199432] = bsn_l3_src_class_id_masked
1358
1359class bsn_lag_id(oxm):
1360 type_len = 197124
1361
1362 def __init__(self, value=None):
1363 if value != None:
1364 self.value = value
1365 else:
1366 self.value = 0
1367 return
1368
1369 def pack(self):
1370 packed = []
1371 packed.append(struct.pack("!L", self.type_len))
1372 packed.append(struct.pack("!L", self.value))
1373 return ''.join(packed)
1374
1375 @staticmethod
1376 def unpack(reader):
1377 obj = bsn_lag_id()
1378 _type_len = reader.read("!L")[0]
1379 assert(_type_len == 197124)
1380 obj.value = reader.read("!L")[0]
1381 return obj
1382
1383 def __eq__(self, other):
1384 if type(self) != type(other): return False
1385 if self.value != other.value: return False
1386 return True
1387
1388 def pretty_print(self, q):
1389 q.text("bsn_lag_id {")
1390 with q.group():
1391 with q.indent(2):
1392 q.breakable()
1393 q.text("value = ");
1394 q.text("%#x" % self.value)
1395 q.breakable()
1396 q.text('}')
1397
1398oxm.subtypes[197124] = bsn_lag_id
1399
1400class bsn_lag_id_masked(oxm):
1401 type_len = 197384
1402
1403 def __init__(self, value=None, value_mask=None):
1404 if value != None:
1405 self.value = value
1406 else:
1407 self.value = 0
1408 if value_mask != None:
1409 self.value_mask = value_mask
1410 else:
1411 self.value_mask = 0
1412 return
1413
1414 def pack(self):
1415 packed = []
1416 packed.append(struct.pack("!L", self.type_len))
1417 packed.append(struct.pack("!L", self.value))
1418 packed.append(struct.pack("!L", self.value_mask))
1419 return ''.join(packed)
1420
1421 @staticmethod
1422 def unpack(reader):
1423 obj = bsn_lag_id_masked()
1424 _type_len = reader.read("!L")[0]
1425 assert(_type_len == 197384)
1426 obj.value = reader.read("!L")[0]
1427 obj.value_mask = reader.read("!L")[0]
1428 return obj
1429
1430 def __eq__(self, other):
1431 if type(self) != type(other): return False
1432 if self.value != other.value: return False
1433 if self.value_mask != other.value_mask: return False
1434 return True
1435
1436 def pretty_print(self, q):
1437 q.text("bsn_lag_id_masked {")
1438 with q.group():
1439 with q.indent(2):
1440 q.breakable()
1441 q.text("value = ");
1442 q.text("%#x" % self.value)
1443 q.text(","); q.breakable()
1444 q.text("value_mask = ");
1445 q.text("%#x" % self.value_mask)
1446 q.breakable()
1447 q.text('}')
1448
1449oxm.subtypes[197384] = bsn_lag_id_masked
1450
1451class bsn_tcp_flags(oxm):
1452 type_len = 204802
1453
1454 def __init__(self, value=None):
1455 if value != None:
1456 self.value = value
1457 else:
1458 self.value = 0
1459 return
1460
1461 def pack(self):
1462 packed = []
1463 packed.append(struct.pack("!L", self.type_len))
1464 packed.append(struct.pack("!H", self.value))
1465 return ''.join(packed)
1466
1467 @staticmethod
1468 def unpack(reader):
1469 obj = bsn_tcp_flags()
1470 _type_len = reader.read("!L")[0]
1471 assert(_type_len == 204802)
1472 obj.value = reader.read("!H")[0]
1473 return obj
1474
1475 def __eq__(self, other):
1476 if type(self) != type(other): return False
1477 if self.value != other.value: return False
1478 return True
1479
1480 def pretty_print(self, q):
1481 q.text("bsn_tcp_flags {")
1482 with q.group():
1483 with q.indent(2):
1484 q.breakable()
1485 q.text("value = ");
1486 q.text("%#x" % self.value)
1487 q.breakable()
1488 q.text('}')
1489
1490oxm.subtypes[204802] = bsn_tcp_flags
1491
1492class bsn_tcp_flags_masked(oxm):
1493 type_len = 205060
1494
1495 def __init__(self, value=None, value_mask=None):
1496 if value != None:
1497 self.value = value
1498 else:
1499 self.value = 0
1500 if value_mask != None:
1501 self.value_mask = value_mask
1502 else:
1503 self.value_mask = 0
1504 return
1505
1506 def pack(self):
1507 packed = []
1508 packed.append(struct.pack("!L", self.type_len))
1509 packed.append(struct.pack("!H", self.value))
1510 packed.append(struct.pack("!H", self.value_mask))
1511 return ''.join(packed)
1512
1513 @staticmethod
1514 def unpack(reader):
1515 obj = bsn_tcp_flags_masked()
1516 _type_len = reader.read("!L")[0]
1517 assert(_type_len == 205060)
1518 obj.value = reader.read("!H")[0]
1519 obj.value_mask = reader.read("!H")[0]
1520 return obj
1521
1522 def __eq__(self, other):
1523 if type(self) != type(other): return False
1524 if self.value != other.value: return False
1525 if self.value_mask != other.value_mask: return False
1526 return True
1527
1528 def pretty_print(self, q):
1529 q.text("bsn_tcp_flags_masked {")
1530 with q.group():
1531 with q.indent(2):
1532 q.breakable()
1533 q.text("value = ");
1534 q.text("%#x" % self.value)
1535 q.text(","); q.breakable()
1536 q.text("value_mask = ");
1537 q.text("%#x" % self.value_mask)
1538 q.breakable()
1539 q.text('}')
1540
1541oxm.subtypes[205060] = bsn_tcp_flags_masked
1542
1543class bsn_udf0(oxm):
1544 type_len = 200708
1545
1546 def __init__(self, value=None):
1547 if value != None:
1548 self.value = value
1549 else:
1550 self.value = 0
1551 return
1552
1553 def pack(self):
1554 packed = []
1555 packed.append(struct.pack("!L", self.type_len))
1556 packed.append(struct.pack("!L", self.value))
1557 return ''.join(packed)
1558
1559 @staticmethod
1560 def unpack(reader):
1561 obj = bsn_udf0()
1562 _type_len = reader.read("!L")[0]
1563 assert(_type_len == 200708)
1564 obj.value = reader.read("!L")[0]
1565 return obj
1566
1567 def __eq__(self, other):
1568 if type(self) != type(other): return False
1569 if self.value != other.value: return False
1570 return True
1571
1572 def pretty_print(self, q):
1573 q.text("bsn_udf0 {")
1574 with q.group():
1575 with q.indent(2):
1576 q.breakable()
1577 q.text("value = ");
1578 q.text("%#x" % self.value)
1579 q.breakable()
1580 q.text('}')
1581
1582oxm.subtypes[200708] = bsn_udf0
1583
1584class bsn_udf0_masked(oxm):
1585 type_len = 200968
1586
1587 def __init__(self, value=None, value_mask=None):
1588 if value != None:
1589 self.value = value
1590 else:
1591 self.value = 0
1592 if value_mask != None:
1593 self.value_mask = value_mask
1594 else:
1595 self.value_mask = 0
1596 return
1597
1598 def pack(self):
1599 packed = []
1600 packed.append(struct.pack("!L", self.type_len))
1601 packed.append(struct.pack("!L", self.value))
1602 packed.append(struct.pack("!L", self.value_mask))
1603 return ''.join(packed)
1604
1605 @staticmethod
1606 def unpack(reader):
1607 obj = bsn_udf0_masked()
1608 _type_len = reader.read("!L")[0]
1609 assert(_type_len == 200968)
1610 obj.value = reader.read("!L")[0]
1611 obj.value_mask = reader.read("!L")[0]
1612 return obj
1613
1614 def __eq__(self, other):
1615 if type(self) != type(other): return False
1616 if self.value != other.value: return False
1617 if self.value_mask != other.value_mask: return False
1618 return True
1619
1620 def pretty_print(self, q):
1621 q.text("bsn_udf0_masked {")
1622 with q.group():
1623 with q.indent(2):
1624 q.breakable()
1625 q.text("value = ");
1626 q.text("%#x" % self.value)
1627 q.text(","); q.breakable()
1628 q.text("value_mask = ");
1629 q.text("%#x" % self.value_mask)
1630 q.breakable()
1631 q.text('}')
1632
1633oxm.subtypes[200968] = bsn_udf0_masked
1634
1635class bsn_udf1(oxm):
1636 type_len = 201220
1637
1638 def __init__(self, value=None):
1639 if value != None:
1640 self.value = value
1641 else:
1642 self.value = 0
1643 return
1644
1645 def pack(self):
1646 packed = []
1647 packed.append(struct.pack("!L", self.type_len))
1648 packed.append(struct.pack("!L", self.value))
1649 return ''.join(packed)
1650
1651 @staticmethod
1652 def unpack(reader):
1653 obj = bsn_udf1()
1654 _type_len = reader.read("!L")[0]
1655 assert(_type_len == 201220)
1656 obj.value = reader.read("!L")[0]
1657 return obj
1658
1659 def __eq__(self, other):
1660 if type(self) != type(other): return False
1661 if self.value != other.value: return False
1662 return True
1663
1664 def pretty_print(self, q):
1665 q.text("bsn_udf1 {")
1666 with q.group():
1667 with q.indent(2):
1668 q.breakable()
1669 q.text("value = ");
1670 q.text("%#x" % self.value)
1671 q.breakable()
1672 q.text('}')
1673
1674oxm.subtypes[201220] = bsn_udf1
1675
1676class bsn_udf1_masked(oxm):
1677 type_len = 201480
1678
1679 def __init__(self, value=None, value_mask=None):
1680 if value != None:
1681 self.value = value
1682 else:
1683 self.value = 0
1684 if value_mask != None:
1685 self.value_mask = value_mask
1686 else:
1687 self.value_mask = 0
1688 return
1689
1690 def pack(self):
1691 packed = []
1692 packed.append(struct.pack("!L", self.type_len))
1693 packed.append(struct.pack("!L", self.value))
1694 packed.append(struct.pack("!L", self.value_mask))
1695 return ''.join(packed)
1696
1697 @staticmethod
1698 def unpack(reader):
1699 obj = bsn_udf1_masked()
1700 _type_len = reader.read("!L")[0]
1701 assert(_type_len == 201480)
1702 obj.value = reader.read("!L")[0]
1703 obj.value_mask = reader.read("!L")[0]
1704 return obj
1705
1706 def __eq__(self, other):
1707 if type(self) != type(other): return False
1708 if self.value != other.value: return False
1709 if self.value_mask != other.value_mask: return False
1710 return True
1711
1712 def pretty_print(self, q):
1713 q.text("bsn_udf1_masked {")
1714 with q.group():
1715 with q.indent(2):
1716 q.breakable()
1717 q.text("value = ");
1718 q.text("%#x" % self.value)
1719 q.text(","); q.breakable()
1720 q.text("value_mask = ");
1721 q.text("%#x" % self.value_mask)
1722 q.breakable()
1723 q.text('}')
1724
1725oxm.subtypes[201480] = bsn_udf1_masked
1726
1727class bsn_udf2(oxm):
1728 type_len = 201732
1729
1730 def __init__(self, value=None):
1731 if value != None:
1732 self.value = value
1733 else:
1734 self.value = 0
1735 return
1736
1737 def pack(self):
1738 packed = []
1739 packed.append(struct.pack("!L", self.type_len))
1740 packed.append(struct.pack("!L", self.value))
1741 return ''.join(packed)
1742
1743 @staticmethod
1744 def unpack(reader):
1745 obj = bsn_udf2()
1746 _type_len = reader.read("!L")[0]
1747 assert(_type_len == 201732)
1748 obj.value = reader.read("!L")[0]
1749 return obj
1750
1751 def __eq__(self, other):
1752 if type(self) != type(other): return False
1753 if self.value != other.value: return False
1754 return True
1755
1756 def pretty_print(self, q):
1757 q.text("bsn_udf2 {")
1758 with q.group():
1759 with q.indent(2):
1760 q.breakable()
1761 q.text("value = ");
1762 q.text("%#x" % self.value)
1763 q.breakable()
1764 q.text('}')
1765
1766oxm.subtypes[201732] = bsn_udf2
1767
1768class bsn_udf2_masked(oxm):
1769 type_len = 201992
1770
1771 def __init__(self, value=None, value_mask=None):
1772 if value != None:
1773 self.value = value
1774 else:
1775 self.value = 0
1776 if value_mask != None:
1777 self.value_mask = value_mask
1778 else:
1779 self.value_mask = 0
1780 return
1781
1782 def pack(self):
1783 packed = []
1784 packed.append(struct.pack("!L", self.type_len))
1785 packed.append(struct.pack("!L", self.value))
1786 packed.append(struct.pack("!L", self.value_mask))
1787 return ''.join(packed)
1788
1789 @staticmethod
1790 def unpack(reader):
1791 obj = bsn_udf2_masked()
1792 _type_len = reader.read("!L")[0]
1793 assert(_type_len == 201992)
1794 obj.value = reader.read("!L")[0]
1795 obj.value_mask = reader.read("!L")[0]
1796 return obj
1797
1798 def __eq__(self, other):
1799 if type(self) != type(other): return False
1800 if self.value != other.value: return False
1801 if self.value_mask != other.value_mask: return False
1802 return True
1803
1804 def pretty_print(self, q):
1805 q.text("bsn_udf2_masked {")
1806 with q.group():
1807 with q.indent(2):
1808 q.breakable()
1809 q.text("value = ");
1810 q.text("%#x" % self.value)
1811 q.text(","); q.breakable()
1812 q.text("value_mask = ");
1813 q.text("%#x" % self.value_mask)
1814 q.breakable()
1815 q.text('}')
1816
1817oxm.subtypes[201992] = bsn_udf2_masked
1818
1819class bsn_udf3(oxm):
1820 type_len = 202244
1821
1822 def __init__(self, value=None):
1823 if value != None:
1824 self.value = value
1825 else:
1826 self.value = 0
1827 return
1828
1829 def pack(self):
1830 packed = []
1831 packed.append(struct.pack("!L", self.type_len))
1832 packed.append(struct.pack("!L", self.value))
1833 return ''.join(packed)
1834
1835 @staticmethod
1836 def unpack(reader):
1837 obj = bsn_udf3()
1838 _type_len = reader.read("!L")[0]
1839 assert(_type_len == 202244)
1840 obj.value = reader.read("!L")[0]
1841 return obj
1842
1843 def __eq__(self, other):
1844 if type(self) != type(other): return False
1845 if self.value != other.value: return False
1846 return True
1847
1848 def pretty_print(self, q):
1849 q.text("bsn_udf3 {")
1850 with q.group():
1851 with q.indent(2):
1852 q.breakable()
1853 q.text("value = ");
1854 q.text("%#x" % self.value)
1855 q.breakable()
1856 q.text('}')
1857
1858oxm.subtypes[202244] = bsn_udf3
1859
1860class bsn_udf3_masked(oxm):
1861 type_len = 202504
1862
1863 def __init__(self, value=None, value_mask=None):
1864 if value != None:
1865 self.value = value
1866 else:
1867 self.value = 0
1868 if value_mask != None:
1869 self.value_mask = value_mask
1870 else:
1871 self.value_mask = 0
1872 return
1873
1874 def pack(self):
1875 packed = []
1876 packed.append(struct.pack("!L", self.type_len))
1877 packed.append(struct.pack("!L", self.value))
1878 packed.append(struct.pack("!L", self.value_mask))
1879 return ''.join(packed)
1880
1881 @staticmethod
1882 def unpack(reader):
1883 obj = bsn_udf3_masked()
1884 _type_len = reader.read("!L")[0]
1885 assert(_type_len == 202504)
1886 obj.value = reader.read("!L")[0]
1887 obj.value_mask = reader.read("!L")[0]
1888 return obj
1889
1890 def __eq__(self, other):
1891 if type(self) != type(other): return False
1892 if self.value != other.value: return False
1893 if self.value_mask != other.value_mask: return False
1894 return True
1895
1896 def pretty_print(self, q):
1897 q.text("bsn_udf3_masked {")
1898 with q.group():
1899 with q.indent(2):
1900 q.breakable()
1901 q.text("value = ");
1902 q.text("%#x" % self.value)
1903 q.text(","); q.breakable()
1904 q.text("value_mask = ");
1905 q.text("%#x" % self.value_mask)
1906 q.breakable()
1907 q.text('}')
1908
1909oxm.subtypes[202504] = bsn_udf3_masked
1910
1911class bsn_udf4(oxm):
1912 type_len = 202756
1913
1914 def __init__(self, value=None):
1915 if value != None:
1916 self.value = value
1917 else:
1918 self.value = 0
1919 return
1920
1921 def pack(self):
1922 packed = []
1923 packed.append(struct.pack("!L", self.type_len))
1924 packed.append(struct.pack("!L", self.value))
1925 return ''.join(packed)
1926
1927 @staticmethod
1928 def unpack(reader):
1929 obj = bsn_udf4()
1930 _type_len = reader.read("!L")[0]
1931 assert(_type_len == 202756)
1932 obj.value = reader.read("!L")[0]
1933 return obj
1934
1935 def __eq__(self, other):
1936 if type(self) != type(other): return False
1937 if self.value != other.value: return False
1938 return True
1939
1940 def pretty_print(self, q):
1941 q.text("bsn_udf4 {")
1942 with q.group():
1943 with q.indent(2):
1944 q.breakable()
1945 q.text("value = ");
1946 q.text("%#x" % self.value)
1947 q.breakable()
1948 q.text('}')
1949
1950oxm.subtypes[202756] = bsn_udf4
1951
1952class bsn_udf4_masked(oxm):
1953 type_len = 203016
1954
1955 def __init__(self, value=None, value_mask=None):
1956 if value != None:
1957 self.value = value
1958 else:
1959 self.value = 0
1960 if value_mask != None:
1961 self.value_mask = value_mask
1962 else:
1963 self.value_mask = 0
1964 return
1965
1966 def pack(self):
1967 packed = []
1968 packed.append(struct.pack("!L", self.type_len))
1969 packed.append(struct.pack("!L", self.value))
1970 packed.append(struct.pack("!L", self.value_mask))
1971 return ''.join(packed)
1972
1973 @staticmethod
1974 def unpack(reader):
1975 obj = bsn_udf4_masked()
1976 _type_len = reader.read("!L")[0]
1977 assert(_type_len == 203016)
1978 obj.value = reader.read("!L")[0]
1979 obj.value_mask = reader.read("!L")[0]
1980 return obj
1981
1982 def __eq__(self, other):
1983 if type(self) != type(other): return False
1984 if self.value != other.value: return False
1985 if self.value_mask != other.value_mask: return False
1986 return True
1987
1988 def pretty_print(self, q):
1989 q.text("bsn_udf4_masked {")
1990 with q.group():
1991 with q.indent(2):
1992 q.breakable()
1993 q.text("value = ");
1994 q.text("%#x" % self.value)
1995 q.text(","); q.breakable()
1996 q.text("value_mask = ");
1997 q.text("%#x" % self.value_mask)
1998 q.breakable()
1999 q.text('}')
2000
2001oxm.subtypes[203016] = bsn_udf4_masked
2002
2003class bsn_udf5(oxm):
2004 type_len = 203268
2005
2006 def __init__(self, value=None):
2007 if value != None:
2008 self.value = value
2009 else:
2010 self.value = 0
2011 return
2012
2013 def pack(self):
2014 packed = []
2015 packed.append(struct.pack("!L", self.type_len))
2016 packed.append(struct.pack("!L", self.value))
2017 return ''.join(packed)
2018
2019 @staticmethod
2020 def unpack(reader):
2021 obj = bsn_udf5()
2022 _type_len = reader.read("!L")[0]
2023 assert(_type_len == 203268)
2024 obj.value = reader.read("!L")[0]
2025 return obj
2026
2027 def __eq__(self, other):
2028 if type(self) != type(other): return False
2029 if self.value != other.value: return False
2030 return True
2031
2032 def pretty_print(self, q):
2033 q.text("bsn_udf5 {")
2034 with q.group():
2035 with q.indent(2):
2036 q.breakable()
2037 q.text("value = ");
2038 q.text("%#x" % self.value)
2039 q.breakable()
2040 q.text('}')
2041
2042oxm.subtypes[203268] = bsn_udf5
2043
2044class bsn_udf5_masked(oxm):
2045 type_len = 203528
2046
2047 def __init__(self, value=None, value_mask=None):
2048 if value != None:
2049 self.value = value
2050 else:
2051 self.value = 0
2052 if value_mask != None:
2053 self.value_mask = value_mask
2054 else:
2055 self.value_mask = 0
2056 return
2057
2058 def pack(self):
2059 packed = []
2060 packed.append(struct.pack("!L", self.type_len))
2061 packed.append(struct.pack("!L", self.value))
2062 packed.append(struct.pack("!L", self.value_mask))
2063 return ''.join(packed)
2064
2065 @staticmethod
2066 def unpack(reader):
2067 obj = bsn_udf5_masked()
2068 _type_len = reader.read("!L")[0]
2069 assert(_type_len == 203528)
2070 obj.value = reader.read("!L")[0]
2071 obj.value_mask = reader.read("!L")[0]
2072 return obj
2073
2074 def __eq__(self, other):
2075 if type(self) != type(other): return False
2076 if self.value != other.value: return False
2077 if self.value_mask != other.value_mask: return False
2078 return True
2079
2080 def pretty_print(self, q):
2081 q.text("bsn_udf5_masked {")
2082 with q.group():
2083 with q.indent(2):
2084 q.breakable()
2085 q.text("value = ");
2086 q.text("%#x" % self.value)
2087 q.text(","); q.breakable()
2088 q.text("value_mask = ");
2089 q.text("%#x" % self.value_mask)
2090 q.breakable()
2091 q.text('}')
2092
2093oxm.subtypes[203528] = bsn_udf5_masked
2094
2095class bsn_udf6(oxm):
2096 type_len = 203780
2097
2098 def __init__(self, value=None):
2099 if value != None:
2100 self.value = value
2101 else:
2102 self.value = 0
2103 return
2104
2105 def pack(self):
2106 packed = []
2107 packed.append(struct.pack("!L", self.type_len))
2108 packed.append(struct.pack("!L", self.value))
2109 return ''.join(packed)
2110
2111 @staticmethod
2112 def unpack(reader):
2113 obj = bsn_udf6()
2114 _type_len = reader.read("!L")[0]
2115 assert(_type_len == 203780)
2116 obj.value = reader.read("!L")[0]
2117 return obj
2118
2119 def __eq__(self, other):
2120 if type(self) != type(other): return False
2121 if self.value != other.value: return False
2122 return True
2123
2124 def pretty_print(self, q):
2125 q.text("bsn_udf6 {")
2126 with q.group():
2127 with q.indent(2):
2128 q.breakable()
2129 q.text("value = ");
2130 q.text("%#x" % self.value)
2131 q.breakable()
2132 q.text('}')
2133
2134oxm.subtypes[203780] = bsn_udf6
2135
2136class bsn_udf6_masked(oxm):
2137 type_len = 204040
2138
2139 def __init__(self, value=None, value_mask=None):
2140 if value != None:
2141 self.value = value
2142 else:
2143 self.value = 0
2144 if value_mask != None:
2145 self.value_mask = value_mask
2146 else:
2147 self.value_mask = 0
2148 return
2149
2150 def pack(self):
2151 packed = []
2152 packed.append(struct.pack("!L", self.type_len))
2153 packed.append(struct.pack("!L", self.value))
2154 packed.append(struct.pack("!L", self.value_mask))
2155 return ''.join(packed)
2156
2157 @staticmethod
2158 def unpack(reader):
2159 obj = bsn_udf6_masked()
2160 _type_len = reader.read("!L")[0]
2161 assert(_type_len == 204040)
2162 obj.value = reader.read("!L")[0]
2163 obj.value_mask = reader.read("!L")[0]
2164 return obj
2165
2166 def __eq__(self, other):
2167 if type(self) != type(other): return False
2168 if self.value != other.value: return False
2169 if self.value_mask != other.value_mask: return False
2170 return True
2171
2172 def pretty_print(self, q):
2173 q.text("bsn_udf6_masked {")
2174 with q.group():
2175 with q.indent(2):
2176 q.breakable()
2177 q.text("value = ");
2178 q.text("%#x" % self.value)
2179 q.text(","); q.breakable()
2180 q.text("value_mask = ");
2181 q.text("%#x" % self.value_mask)
2182 q.breakable()
2183 q.text('}')
2184
2185oxm.subtypes[204040] = bsn_udf6_masked
2186
2187class bsn_udf7(oxm):
2188 type_len = 204292
2189
2190 def __init__(self, value=None):
2191 if value != None:
2192 self.value = value
2193 else:
2194 self.value = 0
2195 return
2196
2197 def pack(self):
2198 packed = []
2199 packed.append(struct.pack("!L", self.type_len))
2200 packed.append(struct.pack("!L", self.value))
2201 return ''.join(packed)
2202
2203 @staticmethod
2204 def unpack(reader):
2205 obj = bsn_udf7()
2206 _type_len = reader.read("!L")[0]
2207 assert(_type_len == 204292)
2208 obj.value = reader.read("!L")[0]
2209 return obj
2210
2211 def __eq__(self, other):
2212 if type(self) != type(other): return False
2213 if self.value != other.value: return False
2214 return True
2215
2216 def pretty_print(self, q):
2217 q.text("bsn_udf7 {")
2218 with q.group():
2219 with q.indent(2):
2220 q.breakable()
2221 q.text("value = ");
2222 q.text("%#x" % self.value)
2223 q.breakable()
2224 q.text('}')
2225
2226oxm.subtypes[204292] = bsn_udf7
2227
2228class bsn_udf7_masked(oxm):
2229 type_len = 204552
2230
2231 def __init__(self, value=None, value_mask=None):
2232 if value != None:
2233 self.value = value
2234 else:
2235 self.value = 0
2236 if value_mask != None:
2237 self.value_mask = value_mask
2238 else:
2239 self.value_mask = 0
2240 return
2241
2242 def pack(self):
2243 packed = []
2244 packed.append(struct.pack("!L", self.type_len))
2245 packed.append(struct.pack("!L", self.value))
2246 packed.append(struct.pack("!L", self.value_mask))
2247 return ''.join(packed)
2248
2249 @staticmethod
2250 def unpack(reader):
2251 obj = bsn_udf7_masked()
2252 _type_len = reader.read("!L")[0]
2253 assert(_type_len == 204552)
2254 obj.value = reader.read("!L")[0]
2255 obj.value_mask = reader.read("!L")[0]
2256 return obj
2257
2258 def __eq__(self, other):
2259 if type(self) != type(other): return False
2260 if self.value != other.value: return False
2261 if self.value_mask != other.value_mask: return False
2262 return True
2263
2264 def pretty_print(self, q):
2265 q.text("bsn_udf7_masked {")
2266 with q.group():
2267 with q.indent(2):
2268 q.breakable()
2269 q.text("value = ");
2270 q.text("%#x" % self.value)
2271 q.text(","); q.breakable()
2272 q.text("value_mask = ");
2273 q.text("%#x" % self.value_mask)
2274 q.breakable()
2275 q.text('}')
2276
2277oxm.subtypes[204552] = bsn_udf7_masked
2278
2279class bsn_vlan_xlate_port_group_id(oxm):
2280 type_len = 205316
2281
2282 def __init__(self, value=None):
2283 if value != None:
2284 self.value = value
2285 else:
2286 self.value = 0
2287 return
2288
2289 def pack(self):
2290 packed = []
2291 packed.append(struct.pack("!L", self.type_len))
2292 packed.append(struct.pack("!L", self.value))
2293 return ''.join(packed)
2294
2295 @staticmethod
2296 def unpack(reader):
2297 obj = bsn_vlan_xlate_port_group_id()
2298 _type_len = reader.read("!L")[0]
2299 assert(_type_len == 205316)
2300 obj.value = reader.read("!L")[0]
2301 return obj
2302
2303 def __eq__(self, other):
2304 if type(self) != type(other): return False
2305 if self.value != other.value: return False
2306 return True
2307
2308 def pretty_print(self, q):
2309 q.text("bsn_vlan_xlate_port_group_id {")
2310 with q.group():
2311 with q.indent(2):
2312 q.breakable()
2313 q.text("value = ");
2314 q.text("%#x" % self.value)
2315 q.breakable()
2316 q.text('}')
2317
2318oxm.subtypes[205316] = bsn_vlan_xlate_port_group_id
2319
2320class bsn_vlan_xlate_port_group_id_masked(oxm):
2321 type_len = 205576
2322
2323 def __init__(self, value=None, value_mask=None):
2324 if value != None:
2325 self.value = value
2326 else:
2327 self.value = 0
2328 if value_mask != None:
2329 self.value_mask = value_mask
2330 else:
2331 self.value_mask = 0
2332 return
2333
2334 def pack(self):
2335 packed = []
2336 packed.append(struct.pack("!L", self.type_len))
2337 packed.append(struct.pack("!L", self.value))
2338 packed.append(struct.pack("!L", self.value_mask))
2339 return ''.join(packed)
2340
2341 @staticmethod
2342 def unpack(reader):
2343 obj = bsn_vlan_xlate_port_group_id_masked()
2344 _type_len = reader.read("!L")[0]
2345 assert(_type_len == 205576)
2346 obj.value = reader.read("!L")[0]
2347 obj.value_mask = reader.read("!L")[0]
2348 return obj
2349
2350 def __eq__(self, other):
2351 if type(self) != type(other): return False
2352 if self.value != other.value: return False
2353 if self.value_mask != other.value_mask: return False
2354 return True
2355
2356 def pretty_print(self, q):
2357 q.text("bsn_vlan_xlate_port_group_id_masked {")
2358 with q.group():
2359 with q.indent(2):
2360 q.breakable()
2361 q.text("value = ");
2362 q.text("%#x" % self.value)
2363 q.text(","); q.breakable()
2364 q.text("value_mask = ");
2365 q.text("%#x" % self.value_mask)
2366 q.breakable()
2367 q.text('}')
2368
2369oxm.subtypes[205576] = bsn_vlan_xlate_port_group_id_masked
2370
2371class bsn_vrf(oxm):
2372 type_len = 197636
2373
2374 def __init__(self, value=None):
2375 if value != None:
2376 self.value = value
2377 else:
2378 self.value = 0
2379 return
2380
2381 def pack(self):
2382 packed = []
2383 packed.append(struct.pack("!L", self.type_len))
2384 packed.append(struct.pack("!L", self.value))
2385 return ''.join(packed)
2386
2387 @staticmethod
2388 def unpack(reader):
2389 obj = bsn_vrf()
2390 _type_len = reader.read("!L")[0]
2391 assert(_type_len == 197636)
2392 obj.value = reader.read("!L")[0]
2393 return obj
2394
2395 def __eq__(self, other):
2396 if type(self) != type(other): return False
2397 if self.value != other.value: return False
2398 return True
2399
2400 def pretty_print(self, q):
2401 q.text("bsn_vrf {")
2402 with q.group():
2403 with q.indent(2):
2404 q.breakable()
2405 q.text("value = ");
2406 q.text("%#x" % self.value)
2407 q.breakable()
2408 q.text('}')
2409
2410oxm.subtypes[197636] = bsn_vrf
2411
2412class bsn_vrf_masked(oxm):
2413 type_len = 197896
2414
2415 def __init__(self, value=None, value_mask=None):
2416 if value != None:
2417 self.value = value
2418 else:
2419 self.value = 0
2420 if value_mask != None:
2421 self.value_mask = value_mask
2422 else:
2423 self.value_mask = 0
2424 return
2425
2426 def pack(self):
2427 packed = []
2428 packed.append(struct.pack("!L", self.type_len))
2429 packed.append(struct.pack("!L", self.value))
2430 packed.append(struct.pack("!L", self.value_mask))
2431 return ''.join(packed)
2432
2433 @staticmethod
2434 def unpack(reader):
2435 obj = bsn_vrf_masked()
2436 _type_len = reader.read("!L")[0]
2437 assert(_type_len == 197896)
2438 obj.value = reader.read("!L")[0]
2439 obj.value_mask = reader.read("!L")[0]
2440 return obj
2441
2442 def __eq__(self, other):
2443 if type(self) != type(other): return False
2444 if self.value != other.value: return False
2445 if self.value_mask != other.value_mask: return False
2446 return True
2447
2448 def pretty_print(self, q):
2449 q.text("bsn_vrf_masked {")
2450 with q.group():
2451 with q.indent(2):
2452 q.breakable()
2453 q.text("value = ");
2454 q.text("%#x" % self.value)
2455 q.text(","); q.breakable()
2456 q.text("value_mask = ");
2457 q.text("%#x" % self.value_mask)
2458 q.breakable()
2459 q.text('}')
2460
2461oxm.subtypes[197896] = bsn_vrf_masked
2462
2463class eth_dst(oxm):
2464 type_len = 2147485190
2465
2466 def __init__(self, value=None):
2467 if value != None:
2468 self.value = value
2469 else:
2470 self.value = [0,0,0,0,0,0]
2471 return
2472
2473 def pack(self):
2474 packed = []
2475 packed.append(struct.pack("!L", self.type_len))
2476 packed.append(struct.pack("!6B", *self.value))
2477 return ''.join(packed)
2478
2479 @staticmethod
2480 def unpack(reader):
2481 obj = eth_dst()
2482 _type_len = reader.read("!L")[0]
2483 assert(_type_len == 2147485190)
2484 obj.value = list(reader.read('!6B'))
2485 return obj
2486
2487 def __eq__(self, other):
2488 if type(self) != type(other): return False
2489 if self.value != other.value: return False
2490 return True
2491
2492 def pretty_print(self, q):
2493 q.text("eth_dst {")
2494 with q.group():
2495 with q.indent(2):
2496 q.breakable()
2497 q.text("value = ");
2498 q.text(util.pretty_mac(self.value))
2499 q.breakable()
2500 q.text('}')
2501
2502oxm.subtypes[2147485190] = eth_dst
2503
2504class eth_dst_masked(oxm):
2505 type_len = 2147485452
2506
2507 def __init__(self, value=None, value_mask=None):
2508 if value != None:
2509 self.value = value
2510 else:
2511 self.value = [0,0,0,0,0,0]
2512 if value_mask != None:
2513 self.value_mask = value_mask
2514 else:
2515 self.value_mask = [0,0,0,0,0,0]
2516 return
2517
2518 def pack(self):
2519 packed = []
2520 packed.append(struct.pack("!L", self.type_len))
2521 packed.append(struct.pack("!6B", *self.value))
2522 packed.append(struct.pack("!6B", *self.value_mask))
2523 return ''.join(packed)
2524
2525 @staticmethod
2526 def unpack(reader):
2527 obj = eth_dst_masked()
2528 _type_len = reader.read("!L")[0]
2529 assert(_type_len == 2147485452)
2530 obj.value = list(reader.read('!6B'))
2531 obj.value_mask = list(reader.read('!6B'))
2532 return obj
2533
2534 def __eq__(self, other):
2535 if type(self) != type(other): return False
2536 if self.value != other.value: return False
2537 if self.value_mask != other.value_mask: return False
2538 return True
2539
2540 def pretty_print(self, q):
2541 q.text("eth_dst_masked {")
2542 with q.group():
2543 with q.indent(2):
2544 q.breakable()
2545 q.text("value = ");
2546 q.text(util.pretty_mac(self.value))
2547 q.text(","); q.breakable()
2548 q.text("value_mask = ");
2549 q.text(util.pretty_mac(self.value_mask))
2550 q.breakable()
2551 q.text('}')
2552
2553oxm.subtypes[2147485452] = eth_dst_masked
2554
2555class eth_src(oxm):
2556 type_len = 2147485702
2557
2558 def __init__(self, value=None):
2559 if value != None:
2560 self.value = value
2561 else:
2562 self.value = [0,0,0,0,0,0]
2563 return
2564
2565 def pack(self):
2566 packed = []
2567 packed.append(struct.pack("!L", self.type_len))
2568 packed.append(struct.pack("!6B", *self.value))
2569 return ''.join(packed)
2570
2571 @staticmethod
2572 def unpack(reader):
2573 obj = eth_src()
2574 _type_len = reader.read("!L")[0]
2575 assert(_type_len == 2147485702)
2576 obj.value = list(reader.read('!6B'))
2577 return obj
2578
2579 def __eq__(self, other):
2580 if type(self) != type(other): return False
2581 if self.value != other.value: return False
2582 return True
2583
2584 def pretty_print(self, q):
2585 q.text("eth_src {")
2586 with q.group():
2587 with q.indent(2):
2588 q.breakable()
2589 q.text("value = ");
2590 q.text(util.pretty_mac(self.value))
2591 q.breakable()
2592 q.text('}')
2593
2594oxm.subtypes[2147485702] = eth_src
2595
2596class eth_src_masked(oxm):
2597 type_len = 2147485964
2598
2599 def __init__(self, value=None, value_mask=None):
2600 if value != None:
2601 self.value = value
2602 else:
2603 self.value = [0,0,0,0,0,0]
2604 if value_mask != None:
2605 self.value_mask = value_mask
2606 else:
2607 self.value_mask = [0,0,0,0,0,0]
2608 return
2609
2610 def pack(self):
2611 packed = []
2612 packed.append(struct.pack("!L", self.type_len))
2613 packed.append(struct.pack("!6B", *self.value))
2614 packed.append(struct.pack("!6B", *self.value_mask))
2615 return ''.join(packed)
2616
2617 @staticmethod
2618 def unpack(reader):
2619 obj = eth_src_masked()
2620 _type_len = reader.read("!L")[0]
2621 assert(_type_len == 2147485964)
2622 obj.value = list(reader.read('!6B'))
2623 obj.value_mask = list(reader.read('!6B'))
2624 return obj
2625
2626 def __eq__(self, other):
2627 if type(self) != type(other): return False
2628 if self.value != other.value: return False
2629 if self.value_mask != other.value_mask: return False
2630 return True
2631
2632 def pretty_print(self, q):
2633 q.text("eth_src_masked {")
2634 with q.group():
2635 with q.indent(2):
2636 q.breakable()
2637 q.text("value = ");
2638 q.text(util.pretty_mac(self.value))
2639 q.text(","); q.breakable()
2640 q.text("value_mask = ");
2641 q.text(util.pretty_mac(self.value_mask))
2642 q.breakable()
2643 q.text('}')
2644
2645oxm.subtypes[2147485964] = eth_src_masked
2646
2647class eth_type(oxm):
2648 type_len = 2147486210
2649
2650 def __init__(self, value=None):
2651 if value != None:
2652 self.value = value
2653 else:
2654 self.value = 0
2655 return
2656
2657 def pack(self):
2658 packed = []
2659 packed.append(struct.pack("!L", self.type_len))
2660 packed.append(struct.pack("!H", self.value))
2661 return ''.join(packed)
2662
2663 @staticmethod
2664 def unpack(reader):
2665 obj = eth_type()
2666 _type_len = reader.read("!L")[0]
2667 assert(_type_len == 2147486210)
2668 obj.value = reader.read("!H")[0]
2669 return obj
2670
2671 def __eq__(self, other):
2672 if type(self) != type(other): return False
2673 if self.value != other.value: return False
2674 return True
2675
2676 def pretty_print(self, q):
2677 q.text("eth_type {")
2678 with q.group():
2679 with q.indent(2):
2680 q.breakable()
2681 q.text("value = ");
2682 q.text("%#x" % self.value)
2683 q.breakable()
2684 q.text('}')
2685
2686oxm.subtypes[2147486210] = eth_type
2687
2688class eth_type_masked(oxm):
2689 type_len = 2147486468
2690
2691 def __init__(self, value=None, value_mask=None):
2692 if value != None:
2693 self.value = value
2694 else:
2695 self.value = 0
2696 if value_mask != None:
2697 self.value_mask = value_mask
2698 else:
2699 self.value_mask = 0
2700 return
2701
2702 def pack(self):
2703 packed = []
2704 packed.append(struct.pack("!L", self.type_len))
2705 packed.append(struct.pack("!H", self.value))
2706 packed.append(struct.pack("!H", self.value_mask))
2707 return ''.join(packed)
2708
2709 @staticmethod
2710 def unpack(reader):
2711 obj = eth_type_masked()
2712 _type_len = reader.read("!L")[0]
2713 assert(_type_len == 2147486468)
2714 obj.value = reader.read("!H")[0]
2715 obj.value_mask = reader.read("!H")[0]
2716 return obj
2717
2718 def __eq__(self, other):
2719 if type(self) != type(other): return False
2720 if self.value != other.value: return False
2721 if self.value_mask != other.value_mask: return False
2722 return True
2723
2724 def pretty_print(self, q):
2725 q.text("eth_type_masked {")
2726 with q.group():
2727 with q.indent(2):
2728 q.breakable()
2729 q.text("value = ");
2730 q.text("%#x" % self.value)
2731 q.text(","); q.breakable()
2732 q.text("value_mask = ");
2733 q.text("%#x" % self.value_mask)
2734 q.breakable()
2735 q.text('}')
2736
2737oxm.subtypes[2147486468] = eth_type_masked
2738
2739class icmpv4_code(oxm):
2740 type_len = 2147493889
2741
2742 def __init__(self, value=None):
2743 if value != None:
2744 self.value = value
2745 else:
2746 self.value = 0
2747 return
2748
2749 def pack(self):
2750 packed = []
2751 packed.append(struct.pack("!L", self.type_len))
2752 packed.append(struct.pack("!B", self.value))
2753 return ''.join(packed)
2754
2755 @staticmethod
2756 def unpack(reader):
2757 obj = icmpv4_code()
2758 _type_len = reader.read("!L")[0]
2759 assert(_type_len == 2147493889)
2760 obj.value = reader.read("!B")[0]
2761 return obj
2762
2763 def __eq__(self, other):
2764 if type(self) != type(other): return False
2765 if self.value != other.value: return False
2766 return True
2767
2768 def pretty_print(self, q):
2769 q.text("icmpv4_code {")
2770 with q.group():
2771 with q.indent(2):
2772 q.breakable()
2773 q.text("value = ");
2774 q.text("%#x" % self.value)
2775 q.breakable()
2776 q.text('}')
2777
2778oxm.subtypes[2147493889] = icmpv4_code
2779
2780class icmpv4_code_masked(oxm):
2781 type_len = 2147494146
2782
2783 def __init__(self, value=None, value_mask=None):
2784 if value != None:
2785 self.value = value
2786 else:
2787 self.value = 0
2788 if value_mask != None:
2789 self.value_mask = value_mask
2790 else:
2791 self.value_mask = 0
2792 return
2793
2794 def pack(self):
2795 packed = []
2796 packed.append(struct.pack("!L", self.type_len))
2797 packed.append(struct.pack("!B", self.value))
2798 packed.append(struct.pack("!B", self.value_mask))
2799 return ''.join(packed)
2800
2801 @staticmethod
2802 def unpack(reader):
2803 obj = icmpv4_code_masked()
2804 _type_len = reader.read("!L")[0]
2805 assert(_type_len == 2147494146)
2806 obj.value = reader.read("!B")[0]
2807 obj.value_mask = reader.read("!B")[0]
2808 return obj
2809
2810 def __eq__(self, other):
2811 if type(self) != type(other): return False
2812 if self.value != other.value: return False
2813 if self.value_mask != other.value_mask: return False
2814 return True
2815
2816 def pretty_print(self, q):
2817 q.text("icmpv4_code_masked {")
2818 with q.group():
2819 with q.indent(2):
2820 q.breakable()
2821 q.text("value = ");
2822 q.text("%#x" % self.value)
2823 q.text(","); q.breakable()
2824 q.text("value_mask = ");
2825 q.text("%#x" % self.value_mask)
2826 q.breakable()
2827 q.text('}')
2828
2829oxm.subtypes[2147494146] = icmpv4_code_masked
2830
2831class icmpv4_type(oxm):
2832 type_len = 2147493377
2833
2834 def __init__(self, value=None):
2835 if value != None:
2836 self.value = value
2837 else:
2838 self.value = 0
2839 return
2840
2841 def pack(self):
2842 packed = []
2843 packed.append(struct.pack("!L", self.type_len))
2844 packed.append(struct.pack("!B", self.value))
2845 return ''.join(packed)
2846
2847 @staticmethod
2848 def unpack(reader):
2849 obj = icmpv4_type()
2850 _type_len = reader.read("!L")[0]
2851 assert(_type_len == 2147493377)
2852 obj.value = reader.read("!B")[0]
2853 return obj
2854
2855 def __eq__(self, other):
2856 if type(self) != type(other): return False
2857 if self.value != other.value: return False
2858 return True
2859
2860 def pretty_print(self, q):
2861 q.text("icmpv4_type {")
2862 with q.group():
2863 with q.indent(2):
2864 q.breakable()
2865 q.text("value = ");
2866 q.text("%#x" % self.value)
2867 q.breakable()
2868 q.text('}')
2869
2870oxm.subtypes[2147493377] = icmpv4_type
2871
2872class icmpv4_type_masked(oxm):
2873 type_len = 2147493634
2874
2875 def __init__(self, value=None, value_mask=None):
2876 if value != None:
2877 self.value = value
2878 else:
2879 self.value = 0
2880 if value_mask != None:
2881 self.value_mask = value_mask
2882 else:
2883 self.value_mask = 0
2884 return
2885
2886 def pack(self):
2887 packed = []
2888 packed.append(struct.pack("!L", self.type_len))
2889 packed.append(struct.pack("!B", self.value))
2890 packed.append(struct.pack("!B", self.value_mask))
2891 return ''.join(packed)
2892
2893 @staticmethod
2894 def unpack(reader):
2895 obj = icmpv4_type_masked()
2896 _type_len = reader.read("!L")[0]
2897 assert(_type_len == 2147493634)
2898 obj.value = reader.read("!B")[0]
2899 obj.value_mask = reader.read("!B")[0]
2900 return obj
2901
2902 def __eq__(self, other):
2903 if type(self) != type(other): return False
2904 if self.value != other.value: return False
2905 if self.value_mask != other.value_mask: return False
2906 return True
2907
2908 def pretty_print(self, q):
2909 q.text("icmpv4_type_masked {")
2910 with q.group():
2911 with q.indent(2):
2912 q.breakable()
2913 q.text("value = ");
2914 q.text("%#x" % self.value)
2915 q.text(","); q.breakable()
2916 q.text("value_mask = ");
2917 q.text("%#x" % self.value_mask)
2918 q.breakable()
2919 q.text('}')
2920
2921oxm.subtypes[2147493634] = icmpv4_type_masked
2922
2923class icmpv6_code(oxm):
2924 type_len = 2147499009
2925
2926 def __init__(self, value=None):
2927 if value != None:
2928 self.value = value
2929 else:
2930 self.value = 0
2931 return
2932
2933 def pack(self):
2934 packed = []
2935 packed.append(struct.pack("!L", self.type_len))
2936 packed.append(struct.pack("!B", self.value))
2937 return ''.join(packed)
2938
2939 @staticmethod
2940 def unpack(reader):
2941 obj = icmpv6_code()
2942 _type_len = reader.read("!L")[0]
2943 assert(_type_len == 2147499009)
2944 obj.value = reader.read("!B")[0]
2945 return obj
2946
2947 def __eq__(self, other):
2948 if type(self) != type(other): return False
2949 if self.value != other.value: return False
2950 return True
2951
2952 def pretty_print(self, q):
2953 q.text("icmpv6_code {")
2954 with q.group():
2955 with q.indent(2):
2956 q.breakable()
2957 q.text("value = ");
2958 q.text("%#x" % self.value)
2959 q.breakable()
2960 q.text('}')
2961
2962oxm.subtypes[2147499009] = icmpv6_code
2963
2964class icmpv6_code_masked(oxm):
2965 type_len = 2147499266
2966
2967 def __init__(self, value=None, value_mask=None):
2968 if value != None:
2969 self.value = value
2970 else:
2971 self.value = 0
2972 if value_mask != None:
2973 self.value_mask = value_mask
2974 else:
2975 self.value_mask = 0
2976 return
2977
2978 def pack(self):
2979 packed = []
2980 packed.append(struct.pack("!L", self.type_len))
2981 packed.append(struct.pack("!B", self.value))
2982 packed.append(struct.pack("!B", self.value_mask))
2983 return ''.join(packed)
2984
2985 @staticmethod
2986 def unpack(reader):
2987 obj = icmpv6_code_masked()
2988 _type_len = reader.read("!L")[0]
2989 assert(_type_len == 2147499266)
2990 obj.value = reader.read("!B")[0]
2991 obj.value_mask = reader.read("!B")[0]
2992 return obj
2993
2994 def __eq__(self, other):
2995 if type(self) != type(other): return False
2996 if self.value != other.value: return False
2997 if self.value_mask != other.value_mask: return False
2998 return True
2999
3000 def pretty_print(self, q):
3001 q.text("icmpv6_code_masked {")
3002 with q.group():
3003 with q.indent(2):
3004 q.breakable()
3005 q.text("value = ");
3006 q.text("%#x" % self.value)
3007 q.text(","); q.breakable()
3008 q.text("value_mask = ");
3009 q.text("%#x" % self.value_mask)
3010 q.breakable()
3011 q.text('}')
3012
3013oxm.subtypes[2147499266] = icmpv6_code_masked
3014
3015class icmpv6_type(oxm):
3016 type_len = 2147498497
3017
3018 def __init__(self, value=None):
3019 if value != None:
3020 self.value = value
3021 else:
3022 self.value = 0
3023 return
3024
3025 def pack(self):
3026 packed = []
3027 packed.append(struct.pack("!L", self.type_len))
3028 packed.append(struct.pack("!B", self.value))
3029 return ''.join(packed)
3030
3031 @staticmethod
3032 def unpack(reader):
3033 obj = icmpv6_type()
3034 _type_len = reader.read("!L")[0]
3035 assert(_type_len == 2147498497)
3036 obj.value = reader.read("!B")[0]
3037 return obj
3038
3039 def __eq__(self, other):
3040 if type(self) != type(other): return False
3041 if self.value != other.value: return False
3042 return True
3043
3044 def pretty_print(self, q):
3045 q.text("icmpv6_type {")
3046 with q.group():
3047 with q.indent(2):
3048 q.breakable()
3049 q.text("value = ");
3050 q.text("%#x" % self.value)
3051 q.breakable()
3052 q.text('}')
3053
3054oxm.subtypes[2147498497] = icmpv6_type
3055
3056class icmpv6_type_masked(oxm):
3057 type_len = 2147498754
3058
3059 def __init__(self, value=None, value_mask=None):
3060 if value != None:
3061 self.value = value
3062 else:
3063 self.value = 0
3064 if value_mask != None:
3065 self.value_mask = value_mask
3066 else:
3067 self.value_mask = 0
3068 return
3069
3070 def pack(self):
3071 packed = []
3072 packed.append(struct.pack("!L", self.type_len))
3073 packed.append(struct.pack("!B", self.value))
3074 packed.append(struct.pack("!B", self.value_mask))
3075 return ''.join(packed)
3076
3077 @staticmethod
3078 def unpack(reader):
3079 obj = icmpv6_type_masked()
3080 _type_len = reader.read("!L")[0]
3081 assert(_type_len == 2147498754)
3082 obj.value = reader.read("!B")[0]
3083 obj.value_mask = reader.read("!B")[0]
3084 return obj
3085
3086 def __eq__(self, other):
3087 if type(self) != type(other): return False
3088 if self.value != other.value: return False
3089 if self.value_mask != other.value_mask: return False
3090 return True
3091
3092 def pretty_print(self, q):
3093 q.text("icmpv6_type_masked {")
3094 with q.group():
3095 with q.indent(2):
3096 q.breakable()
3097 q.text("value = ");
3098 q.text("%#x" % self.value)
3099 q.text(","); q.breakable()
3100 q.text("value_mask = ");
3101 q.text("%#x" % self.value_mask)
3102 q.breakable()
3103 q.text('}')
3104
3105oxm.subtypes[2147498754] = icmpv6_type_masked
3106
3107class in_phy_port(oxm):
3108 type_len = 2147484164
3109
3110 def __init__(self, value=None):
3111 if value != None:
3112 self.value = value
3113 else:
3114 self.value = 0
3115 return
3116
3117 def pack(self):
3118 packed = []
3119 packed.append(struct.pack("!L", self.type_len))
3120 packed.append(util.pack_port_no(self.value))
3121 return ''.join(packed)
3122
3123 @staticmethod
3124 def unpack(reader):
3125 obj = in_phy_port()
3126 _type_len = reader.read("!L")[0]
3127 assert(_type_len == 2147484164)
3128 obj.value = util.unpack_port_no(reader)
3129 return obj
3130
3131 def __eq__(self, other):
3132 if type(self) != type(other): return False
3133 if self.value != other.value: return False
3134 return True
3135
3136 def pretty_print(self, q):
3137 q.text("in_phy_port {")
3138 with q.group():
3139 with q.indent(2):
3140 q.breakable()
3141 q.text("value = ");
3142 q.text(util.pretty_port(self.value))
3143 q.breakable()
3144 q.text('}')
3145
3146oxm.subtypes[2147484164] = in_phy_port
3147
3148class in_phy_port_masked(oxm):
3149 type_len = 2147484424
3150
3151 def __init__(self, value=None, value_mask=None):
3152 if value != None:
3153 self.value = value
3154 else:
3155 self.value = 0
3156 if value_mask != None:
3157 self.value_mask = value_mask
3158 else:
3159 self.value_mask = 0
3160 return
3161
3162 def pack(self):
3163 packed = []
3164 packed.append(struct.pack("!L", self.type_len))
3165 packed.append(util.pack_port_no(self.value))
3166 packed.append(util.pack_port_no(self.value_mask))
3167 return ''.join(packed)
3168
3169 @staticmethod
3170 def unpack(reader):
3171 obj = in_phy_port_masked()
3172 _type_len = reader.read("!L")[0]
3173 assert(_type_len == 2147484424)
3174 obj.value = util.unpack_port_no(reader)
3175 obj.value_mask = util.unpack_port_no(reader)
3176 return obj
3177
3178 def __eq__(self, other):
3179 if type(self) != type(other): return False
3180 if self.value != other.value: return False
3181 if self.value_mask != other.value_mask: return False
3182 return True
3183
3184 def pretty_print(self, q):
3185 q.text("in_phy_port_masked {")
3186 with q.group():
3187 with q.indent(2):
3188 q.breakable()
3189 q.text("value = ");
3190 q.text(util.pretty_port(self.value))
3191 q.text(","); q.breakable()
3192 q.text("value_mask = ");
3193 q.text(util.pretty_port(self.value_mask))
3194 q.breakable()
3195 q.text('}')
3196
3197oxm.subtypes[2147484424] = in_phy_port_masked
3198
3199class in_port(oxm):
3200 type_len = 2147483652
3201
3202 def __init__(self, value=None):
3203 if value != None:
3204 self.value = value
3205 else:
3206 self.value = 0
3207 return
3208
3209 def pack(self):
3210 packed = []
3211 packed.append(struct.pack("!L", self.type_len))
3212 packed.append(util.pack_port_no(self.value))
3213 return ''.join(packed)
3214
3215 @staticmethod
3216 def unpack(reader):
3217 obj = in_port()
3218 _type_len = reader.read("!L")[0]
3219 assert(_type_len == 2147483652)
3220 obj.value = util.unpack_port_no(reader)
3221 return obj
3222
3223 def __eq__(self, other):
3224 if type(self) != type(other): return False
3225 if self.value != other.value: return False
3226 return True
3227
3228 def pretty_print(self, q):
3229 q.text("in_port {")
3230 with q.group():
3231 with q.indent(2):
3232 q.breakable()
3233 q.text("value = ");
3234 q.text(util.pretty_port(self.value))
3235 q.breakable()
3236 q.text('}')
3237
3238oxm.subtypes[2147483652] = in_port
3239
3240class in_port_masked(oxm):
3241 type_len = 2147483912
3242
3243 def __init__(self, value=None, value_mask=None):
3244 if value != None:
3245 self.value = value
3246 else:
3247 self.value = 0
3248 if value_mask != None:
3249 self.value_mask = value_mask
3250 else:
3251 self.value_mask = 0
3252 return
3253
3254 def pack(self):
3255 packed = []
3256 packed.append(struct.pack("!L", self.type_len))
3257 packed.append(util.pack_port_no(self.value))
3258 packed.append(util.pack_port_no(self.value_mask))
3259 return ''.join(packed)
3260
3261 @staticmethod
3262 def unpack(reader):
3263 obj = in_port_masked()
3264 _type_len = reader.read("!L")[0]
3265 assert(_type_len == 2147483912)
3266 obj.value = util.unpack_port_no(reader)
3267 obj.value_mask = util.unpack_port_no(reader)
3268 return obj
3269
3270 def __eq__(self, other):
3271 if type(self) != type(other): return False
3272 if self.value != other.value: return False
3273 if self.value_mask != other.value_mask: return False
3274 return True
3275
3276 def pretty_print(self, q):
3277 q.text("in_port_masked {")
3278 with q.group():
3279 with q.indent(2):
3280 q.breakable()
3281 q.text("value = ");
3282 q.text(util.pretty_port(self.value))
3283 q.text(","); q.breakable()
3284 q.text("value_mask = ");
3285 q.text(util.pretty_port(self.value_mask))
3286 q.breakable()
3287 q.text('}')
3288
3289oxm.subtypes[2147483912] = in_port_masked
3290
3291class ip_dscp(oxm):
3292 type_len = 2147487745
3293
3294 def __init__(self, value=None):
3295 if value != None:
3296 self.value = value
3297 else:
3298 self.value = 0
3299 return
3300
3301 def pack(self):
3302 packed = []
3303 packed.append(struct.pack("!L", self.type_len))
3304 packed.append(struct.pack("!B", self.value))
3305 return ''.join(packed)
3306
3307 @staticmethod
3308 def unpack(reader):
3309 obj = ip_dscp()
3310 _type_len = reader.read("!L")[0]
3311 assert(_type_len == 2147487745)
3312 obj.value = reader.read("!B")[0]
3313 return obj
3314
3315 def __eq__(self, other):
3316 if type(self) != type(other): return False
3317 if self.value != other.value: return False
3318 return True
3319
3320 def pretty_print(self, q):
3321 q.text("ip_dscp {")
3322 with q.group():
3323 with q.indent(2):
3324 q.breakable()
3325 q.text("value = ");
3326 q.text("%#x" % self.value)
3327 q.breakable()
3328 q.text('}')
3329
3330oxm.subtypes[2147487745] = ip_dscp
3331
3332class ip_dscp_masked(oxm):
3333 type_len = 2147488002
3334
3335 def __init__(self, value=None, value_mask=None):
3336 if value != None:
3337 self.value = value
3338 else:
3339 self.value = 0
3340 if value_mask != None:
3341 self.value_mask = value_mask
3342 else:
3343 self.value_mask = 0
3344 return
3345
3346 def pack(self):
3347 packed = []
3348 packed.append(struct.pack("!L", self.type_len))
3349 packed.append(struct.pack("!B", self.value))
3350 packed.append(struct.pack("!B", self.value_mask))
3351 return ''.join(packed)
3352
3353 @staticmethod
3354 def unpack(reader):
3355 obj = ip_dscp_masked()
3356 _type_len = reader.read("!L")[0]
3357 assert(_type_len == 2147488002)
3358 obj.value = reader.read("!B")[0]
3359 obj.value_mask = reader.read("!B")[0]
3360 return obj
3361
3362 def __eq__(self, other):
3363 if type(self) != type(other): return False
3364 if self.value != other.value: return False
3365 if self.value_mask != other.value_mask: return False
3366 return True
3367
3368 def pretty_print(self, q):
3369 q.text("ip_dscp_masked {")
3370 with q.group():
3371 with q.indent(2):
3372 q.breakable()
3373 q.text("value = ");
3374 q.text("%#x" % self.value)
3375 q.text(","); q.breakable()
3376 q.text("value_mask = ");
3377 q.text("%#x" % self.value_mask)
3378 q.breakable()
3379 q.text('}')
3380
3381oxm.subtypes[2147488002] = ip_dscp_masked
3382
3383class ip_ecn(oxm):
3384 type_len = 2147488257
3385
3386 def __init__(self, value=None):
3387 if value != None:
3388 self.value = value
3389 else:
3390 self.value = 0
3391 return
3392
3393 def pack(self):
3394 packed = []
3395 packed.append(struct.pack("!L", self.type_len))
3396 packed.append(struct.pack("!B", self.value))
3397 return ''.join(packed)
3398
3399 @staticmethod
3400 def unpack(reader):
3401 obj = ip_ecn()
3402 _type_len = reader.read("!L")[0]
3403 assert(_type_len == 2147488257)
3404 obj.value = reader.read("!B")[0]
3405 return obj
3406
3407 def __eq__(self, other):
3408 if type(self) != type(other): return False
3409 if self.value != other.value: return False
3410 return True
3411
3412 def pretty_print(self, q):
3413 q.text("ip_ecn {")
3414 with q.group():
3415 with q.indent(2):
3416 q.breakable()
3417 q.text("value = ");
3418 q.text("%#x" % self.value)
3419 q.breakable()
3420 q.text('}')
3421
3422oxm.subtypes[2147488257] = ip_ecn
3423
3424class ip_ecn_masked(oxm):
3425 type_len = 2147488514
3426
3427 def __init__(self, value=None, value_mask=None):
3428 if value != None:
3429 self.value = value
3430 else:
3431 self.value = 0
3432 if value_mask != None:
3433 self.value_mask = value_mask
3434 else:
3435 self.value_mask = 0
3436 return
3437
3438 def pack(self):
3439 packed = []
3440 packed.append(struct.pack("!L", self.type_len))
3441 packed.append(struct.pack("!B", self.value))
3442 packed.append(struct.pack("!B", self.value_mask))
3443 return ''.join(packed)
3444
3445 @staticmethod
3446 def unpack(reader):
3447 obj = ip_ecn_masked()
3448 _type_len = reader.read("!L")[0]
3449 assert(_type_len == 2147488514)
3450 obj.value = reader.read("!B")[0]
3451 obj.value_mask = reader.read("!B")[0]
3452 return obj
3453
3454 def __eq__(self, other):
3455 if type(self) != type(other): return False
3456 if self.value != other.value: return False
3457 if self.value_mask != other.value_mask: return False
3458 return True
3459
3460 def pretty_print(self, q):
3461 q.text("ip_ecn_masked {")
3462 with q.group():
3463 with q.indent(2):
3464 q.breakable()
3465 q.text("value = ");
3466 q.text("%#x" % self.value)
3467 q.text(","); q.breakable()
3468 q.text("value_mask = ");
3469 q.text("%#x" % self.value_mask)
3470 q.breakable()
3471 q.text('}')
3472
3473oxm.subtypes[2147488514] = ip_ecn_masked
3474
3475class ip_proto(oxm):
3476 type_len = 2147488769
3477
3478 def __init__(self, value=None):
3479 if value != None:
3480 self.value = value
3481 else:
3482 self.value = 0
3483 return
3484
3485 def pack(self):
3486 packed = []
3487 packed.append(struct.pack("!L", self.type_len))
3488 packed.append(struct.pack("!B", self.value))
3489 return ''.join(packed)
3490
3491 @staticmethod
3492 def unpack(reader):
3493 obj = ip_proto()
3494 _type_len = reader.read("!L")[0]
3495 assert(_type_len == 2147488769)
3496 obj.value = reader.read("!B")[0]
3497 return obj
3498
3499 def __eq__(self, other):
3500 if type(self) != type(other): return False
3501 if self.value != other.value: return False
3502 return True
3503
3504 def pretty_print(self, q):
3505 q.text("ip_proto {")
3506 with q.group():
3507 with q.indent(2):
3508 q.breakable()
3509 q.text("value = ");
3510 q.text("%#x" % self.value)
3511 q.breakable()
3512 q.text('}')
3513
3514oxm.subtypes[2147488769] = ip_proto
3515
3516class ip_proto_masked(oxm):
3517 type_len = 2147489026
3518
3519 def __init__(self, value=None, value_mask=None):
3520 if value != None:
3521 self.value = value
3522 else:
3523 self.value = 0
3524 if value_mask != None:
3525 self.value_mask = value_mask
3526 else:
3527 self.value_mask = 0
3528 return
3529
3530 def pack(self):
3531 packed = []
3532 packed.append(struct.pack("!L", self.type_len))
3533 packed.append(struct.pack("!B", self.value))
3534 packed.append(struct.pack("!B", self.value_mask))
3535 return ''.join(packed)
3536
3537 @staticmethod
3538 def unpack(reader):
3539 obj = ip_proto_masked()
3540 _type_len = reader.read("!L")[0]
3541 assert(_type_len == 2147489026)
3542 obj.value = reader.read("!B")[0]
3543 obj.value_mask = reader.read("!B")[0]
3544 return obj
3545
3546 def __eq__(self, other):
3547 if type(self) != type(other): return False
3548 if self.value != other.value: return False
3549 if self.value_mask != other.value_mask: return False
3550 return True
3551
3552 def pretty_print(self, q):
3553 q.text("ip_proto_masked {")
3554 with q.group():
3555 with q.indent(2):
3556 q.breakable()
3557 q.text("value = ");
3558 q.text("%#x" % self.value)
3559 q.text(","); q.breakable()
3560 q.text("value_mask = ");
3561 q.text("%#x" % self.value_mask)
3562 q.breakable()
3563 q.text('}')
3564
3565oxm.subtypes[2147489026] = ip_proto_masked
3566
3567class ipv4_dst(oxm):
3568 type_len = 2147489796
3569
3570 def __init__(self, value=None):
3571 if value != None:
3572 self.value = value
3573 else:
3574 self.value = 0
3575 return
3576
3577 def pack(self):
3578 packed = []
3579 packed.append(struct.pack("!L", self.type_len))
3580 packed.append(struct.pack("!L", self.value))
3581 return ''.join(packed)
3582
3583 @staticmethod
3584 def unpack(reader):
3585 obj = ipv4_dst()
3586 _type_len = reader.read("!L")[0]
3587 assert(_type_len == 2147489796)
3588 obj.value = reader.read("!L")[0]
3589 return obj
3590
3591 def __eq__(self, other):
3592 if type(self) != type(other): return False
3593 if self.value != other.value: return False
3594 return True
3595
3596 def pretty_print(self, q):
3597 q.text("ipv4_dst {")
3598 with q.group():
3599 with q.indent(2):
3600 q.breakable()
3601 q.text("value = ");
3602 q.text(util.pretty_ipv4(self.value))
3603 q.breakable()
3604 q.text('}')
3605
3606oxm.subtypes[2147489796] = ipv4_dst
3607
3608class ipv4_dst_masked(oxm):
3609 type_len = 2147490056
3610
3611 def __init__(self, value=None, value_mask=None):
3612 if value != None:
3613 self.value = value
3614 else:
3615 self.value = 0
3616 if value_mask != None:
3617 self.value_mask = value_mask
3618 else:
3619 self.value_mask = 0
3620 return
3621
3622 def pack(self):
3623 packed = []
3624 packed.append(struct.pack("!L", self.type_len))
3625 packed.append(struct.pack("!L", self.value))
3626 packed.append(struct.pack("!L", self.value_mask))
3627 return ''.join(packed)
3628
3629 @staticmethod
3630 def unpack(reader):
3631 obj = ipv4_dst_masked()
3632 _type_len = reader.read("!L")[0]
3633 assert(_type_len == 2147490056)
3634 obj.value = reader.read("!L")[0]
3635 obj.value_mask = reader.read("!L")[0]
3636 return obj
3637
3638 def __eq__(self, other):
3639 if type(self) != type(other): return False
3640 if self.value != other.value: return False
3641 if self.value_mask != other.value_mask: return False
3642 return True
3643
3644 def pretty_print(self, q):
3645 q.text("ipv4_dst_masked {")
3646 with q.group():
3647 with q.indent(2):
3648 q.breakable()
3649 q.text("value = ");
3650 q.text(util.pretty_ipv4(self.value))
3651 q.text(","); q.breakable()
3652 q.text("value_mask = ");
3653 q.text(util.pretty_ipv4(self.value_mask))
3654 q.breakable()
3655 q.text('}')
3656
3657oxm.subtypes[2147490056] = ipv4_dst_masked
3658
3659class ipv4_src(oxm):
3660 type_len = 2147489284
3661
3662 def __init__(self, value=None):
3663 if value != None:
3664 self.value = value
3665 else:
3666 self.value = 0
3667 return
3668
3669 def pack(self):
3670 packed = []
3671 packed.append(struct.pack("!L", self.type_len))
3672 packed.append(struct.pack("!L", self.value))
3673 return ''.join(packed)
3674
3675 @staticmethod
3676 def unpack(reader):
3677 obj = ipv4_src()
3678 _type_len = reader.read("!L")[0]
3679 assert(_type_len == 2147489284)
3680 obj.value = reader.read("!L")[0]
3681 return obj
3682
3683 def __eq__(self, other):
3684 if type(self) != type(other): return False
3685 if self.value != other.value: return False
3686 return True
3687
3688 def pretty_print(self, q):
3689 q.text("ipv4_src {")
3690 with q.group():
3691 with q.indent(2):
3692 q.breakable()
3693 q.text("value = ");
3694 q.text(util.pretty_ipv4(self.value))
3695 q.breakable()
3696 q.text('}')
3697
3698oxm.subtypes[2147489284] = ipv4_src
3699
3700class ipv4_src_masked(oxm):
3701 type_len = 2147489544
3702
3703 def __init__(self, value=None, value_mask=None):
3704 if value != None:
3705 self.value = value
3706 else:
3707 self.value = 0
3708 if value_mask != None:
3709 self.value_mask = value_mask
3710 else:
3711 self.value_mask = 0
3712 return
3713
3714 def pack(self):
3715 packed = []
3716 packed.append(struct.pack("!L", self.type_len))
3717 packed.append(struct.pack("!L", self.value))
3718 packed.append(struct.pack("!L", self.value_mask))
3719 return ''.join(packed)
3720
3721 @staticmethod
3722 def unpack(reader):
3723 obj = ipv4_src_masked()
3724 _type_len = reader.read("!L")[0]
3725 assert(_type_len == 2147489544)
3726 obj.value = reader.read("!L")[0]
3727 obj.value_mask = reader.read("!L")[0]
3728 return obj
3729
3730 def __eq__(self, other):
3731 if type(self) != type(other): return False
3732 if self.value != other.value: return False
3733 if self.value_mask != other.value_mask: return False
3734 return True
3735
3736 def pretty_print(self, q):
3737 q.text("ipv4_src_masked {")
3738 with q.group():
3739 with q.indent(2):
3740 q.breakable()
3741 q.text("value = ");
3742 q.text(util.pretty_ipv4(self.value))
3743 q.text(","); q.breakable()
3744 q.text("value_mask = ");
3745 q.text(util.pretty_ipv4(self.value_mask))
3746 q.breakable()
3747 q.text('}')
3748
3749oxm.subtypes[2147489544] = ipv4_src_masked
3750
3751class ipv6_dst(oxm):
3752 type_len = 2147497488
3753
3754 def __init__(self, value=None):
3755 if value != None:
3756 self.value = value
3757 else:
3758 self.value = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
3759 return
3760
3761 def pack(self):
3762 packed = []
3763 packed.append(struct.pack("!L", self.type_len))
3764 packed.append(struct.pack("!16s", self.value))
3765 return ''.join(packed)
3766
3767 @staticmethod
3768 def unpack(reader):
3769 obj = ipv6_dst()
3770 _type_len = reader.read("!L")[0]
3771 assert(_type_len == 2147497488)
3772 obj.value = reader.read('!16s')[0]
3773 return obj
3774
3775 def __eq__(self, other):
3776 if type(self) != type(other): return False
3777 if self.value != other.value: return False
3778 return True
3779
3780 def pretty_print(self, q):
3781 q.text("ipv6_dst {")
3782 with q.group():
3783 with q.indent(2):
3784 q.breakable()
3785 q.text("value = ");
3786 q.pp(self.value)
3787 q.breakable()
3788 q.text('}')
3789
3790oxm.subtypes[2147497488] = ipv6_dst
3791
3792class ipv6_dst_masked(oxm):
3793 type_len = 2147497760
3794
3795 def __init__(self, value=None, value_mask=None):
3796 if value != None:
3797 self.value = value
3798 else:
3799 self.value = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
3800 if value_mask != None:
3801 self.value_mask = value_mask
3802 else:
3803 self.value_mask = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
3804 return
3805
3806 def pack(self):
3807 packed = []
3808 packed.append(struct.pack("!L", self.type_len))
3809 packed.append(struct.pack("!16s", self.value))
3810 packed.append(struct.pack("!16s", self.value_mask))
3811 return ''.join(packed)
3812
3813 @staticmethod
3814 def unpack(reader):
3815 obj = ipv6_dst_masked()
3816 _type_len = reader.read("!L")[0]
3817 assert(_type_len == 2147497760)
3818 obj.value = reader.read('!16s')[0]
3819 obj.value_mask = reader.read('!16s')[0]
3820 return obj
3821
3822 def __eq__(self, other):
3823 if type(self) != type(other): return False
3824 if self.value != other.value: return False
3825 if self.value_mask != other.value_mask: return False
3826 return True
3827
3828 def pretty_print(self, q):
3829 q.text("ipv6_dst_masked {")
3830 with q.group():
3831 with q.indent(2):
3832 q.breakable()
3833 q.text("value = ");
3834 q.pp(self.value)
3835 q.text(","); q.breakable()
3836 q.text("value_mask = ");
3837 q.pp(self.value_mask)
3838 q.breakable()
3839 q.text('}')
3840
3841oxm.subtypes[2147497760] = ipv6_dst_masked
3842
3843class ipv6_flabel(oxm):
3844 type_len = 2147497988
3845
3846 def __init__(self, value=None):
3847 if value != None:
3848 self.value = value
3849 else:
3850 self.value = 0
3851 return
3852
3853 def pack(self):
3854 packed = []
3855 packed.append(struct.pack("!L", self.type_len))
3856 packed.append(struct.pack("!L", self.value))
3857 return ''.join(packed)
3858
3859 @staticmethod
3860 def unpack(reader):
3861 obj = ipv6_flabel()
3862 _type_len = reader.read("!L")[0]
3863 assert(_type_len == 2147497988)
3864 obj.value = reader.read("!L")[0]
3865 return obj
3866
3867 def __eq__(self, other):
3868 if type(self) != type(other): return False
3869 if self.value != other.value: return False
3870 return True
3871
3872 def pretty_print(self, q):
3873 q.text("ipv6_flabel {")
3874 with q.group():
3875 with q.indent(2):
3876 q.breakable()
3877 q.text("value = ");
3878 q.text("%#x" % self.value)
3879 q.breakable()
3880 q.text('}')
3881
3882oxm.subtypes[2147497988] = ipv6_flabel
3883
3884class ipv6_flabel_masked(oxm):
3885 type_len = 2147498248
3886
3887 def __init__(self, value=None, value_mask=None):
3888 if value != None:
3889 self.value = value
3890 else:
3891 self.value = 0
3892 if value_mask != None:
3893 self.value_mask = value_mask
3894 else:
3895 self.value_mask = 0
3896 return
3897
3898 def pack(self):
3899 packed = []
3900 packed.append(struct.pack("!L", self.type_len))
3901 packed.append(struct.pack("!L", self.value))
3902 packed.append(struct.pack("!L", self.value_mask))
3903 return ''.join(packed)
3904
3905 @staticmethod
3906 def unpack(reader):
3907 obj = ipv6_flabel_masked()
3908 _type_len = reader.read("!L")[0]
3909 assert(_type_len == 2147498248)
3910 obj.value = reader.read("!L")[0]
3911 obj.value_mask = reader.read("!L")[0]
3912 return obj
3913
3914 def __eq__(self, other):
3915 if type(self) != type(other): return False
3916 if self.value != other.value: return False
3917 if self.value_mask != other.value_mask: return False
3918 return True
3919
3920 def pretty_print(self, q):
3921 q.text("ipv6_flabel_masked {")
3922 with q.group():
3923 with q.indent(2):
3924 q.breakable()
3925 q.text("value = ");
3926 q.text("%#x" % self.value)
3927 q.text(","); q.breakable()
3928 q.text("value_mask = ");
3929 q.text("%#x" % self.value_mask)
3930 q.breakable()
3931 q.text('}')
3932
3933oxm.subtypes[2147498248] = ipv6_flabel_masked
3934
3935class ipv6_nd_sll(oxm):
3936 type_len = 2147500038
3937
3938 def __init__(self, value=None):
3939 if value != None:
3940 self.value = value
3941 else:
3942 self.value = [0,0,0,0,0,0]
3943 return
3944
3945 def pack(self):
3946 packed = []
3947 packed.append(struct.pack("!L", self.type_len))
3948 packed.append(struct.pack("!6B", *self.value))
3949 return ''.join(packed)
3950
3951 @staticmethod
3952 def unpack(reader):
3953 obj = ipv6_nd_sll()
3954 _type_len = reader.read("!L")[0]
3955 assert(_type_len == 2147500038)
3956 obj.value = list(reader.read('!6B'))
3957 return obj
3958
3959 def __eq__(self, other):
3960 if type(self) != type(other): return False
3961 if self.value != other.value: return False
3962 return True
3963
3964 def pretty_print(self, q):
3965 q.text("ipv6_nd_sll {")
3966 with q.group():
3967 with q.indent(2):
3968 q.breakable()
3969 q.text("value = ");
3970 q.text(util.pretty_mac(self.value))
3971 q.breakable()
3972 q.text('}')
3973
3974oxm.subtypes[2147500038] = ipv6_nd_sll
3975
3976class ipv6_nd_sll_masked(oxm):
3977 type_len = 2147500300
3978
3979 def __init__(self, value=None, value_mask=None):
3980 if value != None:
3981 self.value = value
3982 else:
3983 self.value = [0,0,0,0,0,0]
3984 if value_mask != None:
3985 self.value_mask = value_mask
3986 else:
3987 self.value_mask = [0,0,0,0,0,0]
3988 return
3989
3990 def pack(self):
3991 packed = []
3992 packed.append(struct.pack("!L", self.type_len))
3993 packed.append(struct.pack("!6B", *self.value))
3994 packed.append(struct.pack("!6B", *self.value_mask))
3995 return ''.join(packed)
3996
3997 @staticmethod
3998 def unpack(reader):
3999 obj = ipv6_nd_sll_masked()
4000 _type_len = reader.read("!L")[0]
4001 assert(_type_len == 2147500300)
4002 obj.value = list(reader.read('!6B'))
4003 obj.value_mask = list(reader.read('!6B'))
4004 return obj
4005
4006 def __eq__(self, other):
4007 if type(self) != type(other): return False
4008 if self.value != other.value: return False
4009 if self.value_mask != other.value_mask: return False
4010 return True
4011
4012 def pretty_print(self, q):
4013 q.text("ipv6_nd_sll_masked {")
4014 with q.group():
4015 with q.indent(2):
4016 q.breakable()
4017 q.text("value = ");
4018 q.text(util.pretty_mac(self.value))
4019 q.text(","); q.breakable()
4020 q.text("value_mask = ");
4021 q.text(util.pretty_mac(self.value_mask))
4022 q.breakable()
4023 q.text('}')
4024
4025oxm.subtypes[2147500300] = ipv6_nd_sll_masked
4026
4027class ipv6_nd_target(oxm):
4028 type_len = 2147499536
4029
4030 def __init__(self, value=None):
4031 if value != None:
4032 self.value = value
4033 else:
4034 self.value = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
4035 return
4036
4037 def pack(self):
4038 packed = []
4039 packed.append(struct.pack("!L", self.type_len))
4040 packed.append(struct.pack("!16s", self.value))
4041 return ''.join(packed)
4042
4043 @staticmethod
4044 def unpack(reader):
4045 obj = ipv6_nd_target()
4046 _type_len = reader.read("!L")[0]
4047 assert(_type_len == 2147499536)
4048 obj.value = reader.read('!16s')[0]
4049 return obj
4050
4051 def __eq__(self, other):
4052 if type(self) != type(other): return False
4053 if self.value != other.value: return False
4054 return True
4055
4056 def pretty_print(self, q):
4057 q.text("ipv6_nd_target {")
4058 with q.group():
4059 with q.indent(2):
4060 q.breakable()
4061 q.text("value = ");
4062 q.pp(self.value)
4063 q.breakable()
4064 q.text('}')
4065
4066oxm.subtypes[2147499536] = ipv6_nd_target
4067
4068class ipv6_nd_target_masked(oxm):
4069 type_len = 2147499808
4070
4071 def __init__(self, value=None, value_mask=None):
4072 if value != None:
4073 self.value = value
4074 else:
4075 self.value = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
4076 if value_mask != None:
4077 self.value_mask = value_mask
4078 else:
4079 self.value_mask = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
4080 return
4081
4082 def pack(self):
4083 packed = []
4084 packed.append(struct.pack("!L", self.type_len))
4085 packed.append(struct.pack("!16s", self.value))
4086 packed.append(struct.pack("!16s", self.value_mask))
4087 return ''.join(packed)
4088
4089 @staticmethod
4090 def unpack(reader):
4091 obj = ipv6_nd_target_masked()
4092 _type_len = reader.read("!L")[0]
4093 assert(_type_len == 2147499808)
4094 obj.value = reader.read('!16s')[0]
4095 obj.value_mask = reader.read('!16s')[0]
4096 return obj
4097
4098 def __eq__(self, other):
4099 if type(self) != type(other): return False
4100 if self.value != other.value: return False
4101 if self.value_mask != other.value_mask: return False
4102 return True
4103
4104 def pretty_print(self, q):
4105 q.text("ipv6_nd_target_masked {")
4106 with q.group():
4107 with q.indent(2):
4108 q.breakable()
4109 q.text("value = ");
4110 q.pp(self.value)
4111 q.text(","); q.breakable()
4112 q.text("value_mask = ");
4113 q.pp(self.value_mask)
4114 q.breakable()
4115 q.text('}')
4116
4117oxm.subtypes[2147499808] = ipv6_nd_target_masked
4118
4119class ipv6_nd_tll(oxm):
4120 type_len = 2147500550
4121
4122 def __init__(self, value=None):
4123 if value != None:
4124 self.value = value
4125 else:
4126 self.value = [0,0,0,0,0,0]
4127 return
4128
4129 def pack(self):
4130 packed = []
4131 packed.append(struct.pack("!L", self.type_len))
4132 packed.append(struct.pack("!6B", *self.value))
4133 return ''.join(packed)
4134
4135 @staticmethod
4136 def unpack(reader):
4137 obj = ipv6_nd_tll()
4138 _type_len = reader.read("!L")[0]
4139 assert(_type_len == 2147500550)
4140 obj.value = list(reader.read('!6B'))
4141 return obj
4142
4143 def __eq__(self, other):
4144 if type(self) != type(other): return False
4145 if self.value != other.value: return False
4146 return True
4147
4148 def pretty_print(self, q):
4149 q.text("ipv6_nd_tll {")
4150 with q.group():
4151 with q.indent(2):
4152 q.breakable()
4153 q.text("value = ");
4154 q.text(util.pretty_mac(self.value))
4155 q.breakable()
4156 q.text('}')
4157
4158oxm.subtypes[2147500550] = ipv6_nd_tll
4159
4160class ipv6_nd_tll_masked(oxm):
4161 type_len = 2147500812
4162
4163 def __init__(self, value=None, value_mask=None):
4164 if value != None:
4165 self.value = value
4166 else:
4167 self.value = [0,0,0,0,0,0]
4168 if value_mask != None:
4169 self.value_mask = value_mask
4170 else:
4171 self.value_mask = [0,0,0,0,0,0]
4172 return
4173
4174 def pack(self):
4175 packed = []
4176 packed.append(struct.pack("!L", self.type_len))
4177 packed.append(struct.pack("!6B", *self.value))
4178 packed.append(struct.pack("!6B", *self.value_mask))
4179 return ''.join(packed)
4180
4181 @staticmethod
4182 def unpack(reader):
4183 obj = ipv6_nd_tll_masked()
4184 _type_len = reader.read("!L")[0]
4185 assert(_type_len == 2147500812)
4186 obj.value = list(reader.read('!6B'))
4187 obj.value_mask = list(reader.read('!6B'))
4188 return obj
4189
4190 def __eq__(self, other):
4191 if type(self) != type(other): return False
4192 if self.value != other.value: return False
4193 if self.value_mask != other.value_mask: return False
4194 return True
4195
4196 def pretty_print(self, q):
4197 q.text("ipv6_nd_tll_masked {")
4198 with q.group():
4199 with q.indent(2):
4200 q.breakable()
4201 q.text("value = ");
4202 q.text(util.pretty_mac(self.value))
4203 q.text(","); q.breakable()
4204 q.text("value_mask = ");
4205 q.text(util.pretty_mac(self.value_mask))
4206 q.breakable()
4207 q.text('}')
4208
4209oxm.subtypes[2147500812] = ipv6_nd_tll_masked
4210
4211class ipv6_src(oxm):
4212 type_len = 2147496976
4213
4214 def __init__(self, value=None):
4215 if value != None:
4216 self.value = value
4217 else:
4218 self.value = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
4219 return
4220
4221 def pack(self):
4222 packed = []
4223 packed.append(struct.pack("!L", self.type_len))
4224 packed.append(struct.pack("!16s", self.value))
4225 return ''.join(packed)
4226
4227 @staticmethod
4228 def unpack(reader):
4229 obj = ipv6_src()
4230 _type_len = reader.read("!L")[0]
4231 assert(_type_len == 2147496976)
4232 obj.value = reader.read('!16s')[0]
4233 return obj
4234
4235 def __eq__(self, other):
4236 if type(self) != type(other): return False
4237 if self.value != other.value: return False
4238 return True
4239
4240 def pretty_print(self, q):
4241 q.text("ipv6_src {")
4242 with q.group():
4243 with q.indent(2):
4244 q.breakable()
4245 q.text("value = ");
4246 q.pp(self.value)
4247 q.breakable()
4248 q.text('}')
4249
4250oxm.subtypes[2147496976] = ipv6_src
4251
4252class ipv6_src_masked(oxm):
4253 type_len = 2147497248
4254
4255 def __init__(self, value=None, value_mask=None):
4256 if value != None:
4257 self.value = value
4258 else:
4259 self.value = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
4260 if value_mask != None:
4261 self.value_mask = value_mask
4262 else:
4263 self.value_mask = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
4264 return
4265
4266 def pack(self):
4267 packed = []
4268 packed.append(struct.pack("!L", self.type_len))
4269 packed.append(struct.pack("!16s", self.value))
4270 packed.append(struct.pack("!16s", self.value_mask))
4271 return ''.join(packed)
4272
4273 @staticmethod
4274 def unpack(reader):
4275 obj = ipv6_src_masked()
4276 _type_len = reader.read("!L")[0]
4277 assert(_type_len == 2147497248)
4278 obj.value = reader.read('!16s')[0]
4279 obj.value_mask = reader.read('!16s')[0]
4280 return obj
4281
4282 def __eq__(self, other):
4283 if type(self) != type(other): return False
4284 if self.value != other.value: return False
4285 if self.value_mask != other.value_mask: return False
4286 return True
4287
4288 def pretty_print(self, q):
4289 q.text("ipv6_src_masked {")
4290 with q.group():
4291 with q.indent(2):
4292 q.breakable()
4293 q.text("value = ");
4294 q.pp(self.value)
4295 q.text(","); q.breakable()
4296 q.text("value_mask = ");
4297 q.pp(self.value_mask)
4298 q.breakable()
4299 q.text('}')
4300
4301oxm.subtypes[2147497248] = ipv6_src_masked
4302
4303class metadata(oxm):
4304 type_len = 2147484680
4305
4306 def __init__(self, value=None):
4307 if value != None:
4308 self.value = value
4309 else:
4310 self.value = 0
4311 return
4312
4313 def pack(self):
4314 packed = []
4315 packed.append(struct.pack("!L", self.type_len))
4316 packed.append(struct.pack("!Q", self.value))
4317 return ''.join(packed)
4318
4319 @staticmethod
4320 def unpack(reader):
4321 obj = metadata()
4322 _type_len = reader.read("!L")[0]
4323 assert(_type_len == 2147484680)
4324 obj.value = reader.read("!Q")[0]
4325 return obj
4326
4327 def __eq__(self, other):
4328 if type(self) != type(other): return False
4329 if self.value != other.value: return False
4330 return True
4331
4332 def pretty_print(self, q):
4333 q.text("metadata {")
4334 with q.group():
4335 with q.indent(2):
4336 q.breakable()
4337 q.text("value = ");
4338 q.text("%#x" % self.value)
4339 q.breakable()
4340 q.text('}')
4341
4342oxm.subtypes[2147484680] = metadata
4343
4344class metadata_masked(oxm):
4345 type_len = 2147484944
4346
4347 def __init__(self, value=None, value_mask=None):
4348 if value != None:
4349 self.value = value
4350 else:
4351 self.value = 0
4352 if value_mask != None:
4353 self.value_mask = value_mask
4354 else:
4355 self.value_mask = 0
4356 return
4357
4358 def pack(self):
4359 packed = []
4360 packed.append(struct.pack("!L", self.type_len))
4361 packed.append(struct.pack("!Q", self.value))
4362 packed.append(struct.pack("!Q", self.value_mask))
4363 return ''.join(packed)
4364
4365 @staticmethod
4366 def unpack(reader):
4367 obj = metadata_masked()
4368 _type_len = reader.read("!L")[0]
4369 assert(_type_len == 2147484944)
4370 obj.value = reader.read("!Q")[0]
4371 obj.value_mask = reader.read("!Q")[0]
4372 return obj
4373
4374 def __eq__(self, other):
4375 if type(self) != type(other): return False
4376 if self.value != other.value: return False
4377 if self.value_mask != other.value_mask: return False
4378 return True
4379
4380 def pretty_print(self, q):
4381 q.text("metadata_masked {")
4382 with q.group():
4383 with q.indent(2):
4384 q.breakable()
4385 q.text("value = ");
4386 q.text("%#x" % self.value)
4387 q.text(","); q.breakable()
4388 q.text("value_mask = ");
4389 q.text("%#x" % self.value_mask)
4390 q.breakable()
4391 q.text('}')
4392
4393oxm.subtypes[2147484944] = metadata_masked
4394
4395class mpls_label(oxm):
4396 type_len = 2147501060
4397
4398 def __init__(self, value=None):
4399 if value != None:
4400 self.value = value
4401 else:
4402 self.value = 0
4403 return
4404
4405 def pack(self):
4406 packed = []
4407 packed.append(struct.pack("!L", self.type_len))
4408 packed.append(struct.pack("!L", self.value))
4409 return ''.join(packed)
4410
4411 @staticmethod
4412 def unpack(reader):
4413 obj = mpls_label()
4414 _type_len = reader.read("!L")[0]
4415 assert(_type_len == 2147501060)
4416 obj.value = reader.read("!L")[0]
4417 return obj
4418
4419 def __eq__(self, other):
4420 if type(self) != type(other): return False
4421 if self.value != other.value: return False
4422 return True
4423
4424 def pretty_print(self, q):
4425 q.text("mpls_label {")
4426 with q.group():
4427 with q.indent(2):
4428 q.breakable()
4429 q.text("value = ");
4430 q.text("%#x" % self.value)
4431 q.breakable()
4432 q.text('}')
4433
4434oxm.subtypes[2147501060] = mpls_label
4435
4436class mpls_label_masked(oxm):
4437 type_len = 2147501320
4438
4439 def __init__(self, value=None, value_mask=None):
4440 if value != None:
4441 self.value = value
4442 else:
4443 self.value = 0
4444 if value_mask != None:
4445 self.value_mask = value_mask
4446 else:
4447 self.value_mask = 0
4448 return
4449
4450 def pack(self):
4451 packed = []
4452 packed.append(struct.pack("!L", self.type_len))
4453 packed.append(struct.pack("!L", self.value))
4454 packed.append(struct.pack("!L", self.value_mask))
4455 return ''.join(packed)
4456
4457 @staticmethod
4458 def unpack(reader):
4459 obj = mpls_label_masked()
4460 _type_len = reader.read("!L")[0]
4461 assert(_type_len == 2147501320)
4462 obj.value = reader.read("!L")[0]
4463 obj.value_mask = reader.read("!L")[0]
4464 return obj
4465
4466 def __eq__(self, other):
4467 if type(self) != type(other): return False
4468 if self.value != other.value: return False
4469 if self.value_mask != other.value_mask: return False
4470 return True
4471
4472 def pretty_print(self, q):
4473 q.text("mpls_label_masked {")
4474 with q.group():
4475 with q.indent(2):
4476 q.breakable()
4477 q.text("value = ");
4478 q.text("%#x" % self.value)
4479 q.text(","); q.breakable()
4480 q.text("value_mask = ");
4481 q.text("%#x" % self.value_mask)
4482 q.breakable()
4483 q.text('}')
4484
4485oxm.subtypes[2147501320] = mpls_label_masked
4486
4487class mpls_tc(oxm):
4488 type_len = 2147501569
4489
4490 def __init__(self, value=None):
4491 if value != None:
4492 self.value = value
4493 else:
4494 self.value = 0
4495 return
4496
4497 def pack(self):
4498 packed = []
4499 packed.append(struct.pack("!L", self.type_len))
4500 packed.append(struct.pack("!B", self.value))
4501 return ''.join(packed)
4502
4503 @staticmethod
4504 def unpack(reader):
4505 obj = mpls_tc()
4506 _type_len = reader.read("!L")[0]
4507 assert(_type_len == 2147501569)
4508 obj.value = reader.read("!B")[0]
4509 return obj
4510
4511 def __eq__(self, other):
4512 if type(self) != type(other): return False
4513 if self.value != other.value: return False
4514 return True
4515
4516 def pretty_print(self, q):
4517 q.text("mpls_tc {")
4518 with q.group():
4519 with q.indent(2):
4520 q.breakable()
4521 q.text("value = ");
4522 q.text("%#x" % self.value)
4523 q.breakable()
4524 q.text('}')
4525
4526oxm.subtypes[2147501569] = mpls_tc
4527
4528class mpls_tc_masked(oxm):
4529 type_len = 2147501826
4530
4531 def __init__(self, value=None, value_mask=None):
4532 if value != None:
4533 self.value = value
4534 else:
4535 self.value = 0
4536 if value_mask != None:
4537 self.value_mask = value_mask
4538 else:
4539 self.value_mask = 0
4540 return
4541
4542 def pack(self):
4543 packed = []
4544 packed.append(struct.pack("!L", self.type_len))
4545 packed.append(struct.pack("!B", self.value))
4546 packed.append(struct.pack("!B", self.value_mask))
4547 return ''.join(packed)
4548
4549 @staticmethod
4550 def unpack(reader):
4551 obj = mpls_tc_masked()
4552 _type_len = reader.read("!L")[0]
4553 assert(_type_len == 2147501826)
4554 obj.value = reader.read("!B")[0]
4555 obj.value_mask = reader.read("!B")[0]
4556 return obj
4557
4558 def __eq__(self, other):
4559 if type(self) != type(other): return False
4560 if self.value != other.value: return False
4561 if self.value_mask != other.value_mask: return False
4562 return True
4563
4564 def pretty_print(self, q):
4565 q.text("mpls_tc_masked {")
4566 with q.group():
4567 with q.indent(2):
4568 q.breakable()
4569 q.text("value = ");
4570 q.text("%#x" % self.value)
4571 q.text(","); q.breakable()
4572 q.text("value_mask = ");
4573 q.text("%#x" % self.value_mask)
4574 q.breakable()
4575 q.text('}')
4576
4577oxm.subtypes[2147501826] = mpls_tc_masked
4578
4579class sctp_dst(oxm):
4580 type_len = 2147492866
4581
4582 def __init__(self, value=None):
4583 if value != None:
4584 self.value = value
4585 else:
4586 self.value = 0
4587 return
4588
4589 def pack(self):
4590 packed = []
4591 packed.append(struct.pack("!L", self.type_len))
4592 packed.append(struct.pack("!H", self.value))
4593 return ''.join(packed)
4594
4595 @staticmethod
4596 def unpack(reader):
4597 obj = sctp_dst()
4598 _type_len = reader.read("!L")[0]
4599 assert(_type_len == 2147492866)
4600 obj.value = reader.read("!H")[0]
4601 return obj
4602
4603 def __eq__(self, other):
4604 if type(self) != type(other): return False
4605 if self.value != other.value: return False
4606 return True
4607
4608 def pretty_print(self, q):
4609 q.text("sctp_dst {")
4610 with q.group():
4611 with q.indent(2):
4612 q.breakable()
4613 q.text("value = ");
4614 q.text("%#x" % self.value)
4615 q.breakable()
4616 q.text('}')
4617
4618oxm.subtypes[2147492866] = sctp_dst
4619
4620class sctp_dst_masked(oxm):
4621 type_len = 2147493124
4622
4623 def __init__(self, value=None, value_mask=None):
4624 if value != None:
4625 self.value = value
4626 else:
4627 self.value = 0
4628 if value_mask != None:
4629 self.value_mask = value_mask
4630 else:
4631 self.value_mask = 0
4632 return
4633
4634 def pack(self):
4635 packed = []
4636 packed.append(struct.pack("!L", self.type_len))
4637 packed.append(struct.pack("!H", self.value))
4638 packed.append(struct.pack("!H", self.value_mask))
4639 return ''.join(packed)
4640
4641 @staticmethod
4642 def unpack(reader):
4643 obj = sctp_dst_masked()
4644 _type_len = reader.read("!L")[0]
4645 assert(_type_len == 2147493124)
4646 obj.value = reader.read("!H")[0]
4647 obj.value_mask = reader.read("!H")[0]
4648 return obj
4649
4650 def __eq__(self, other):
4651 if type(self) != type(other): return False
4652 if self.value != other.value: return False
4653 if self.value_mask != other.value_mask: return False
4654 return True
4655
4656 def pretty_print(self, q):
4657 q.text("sctp_dst_masked {")
4658 with q.group():
4659 with q.indent(2):
4660 q.breakable()
4661 q.text("value = ");
4662 q.text("%#x" % self.value)
4663 q.text(","); q.breakable()
4664 q.text("value_mask = ");
4665 q.text("%#x" % self.value_mask)
4666 q.breakable()
4667 q.text('}')
4668
4669oxm.subtypes[2147493124] = sctp_dst_masked
4670
4671class sctp_src(oxm):
4672 type_len = 2147492354
4673
4674 def __init__(self, value=None):
4675 if value != None:
4676 self.value = value
4677 else:
4678 self.value = 0
4679 return
4680
4681 def pack(self):
4682 packed = []
4683 packed.append(struct.pack("!L", self.type_len))
4684 packed.append(struct.pack("!H", self.value))
4685 return ''.join(packed)
4686
4687 @staticmethod
4688 def unpack(reader):
4689 obj = sctp_src()
4690 _type_len = reader.read("!L")[0]
4691 assert(_type_len == 2147492354)
4692 obj.value = reader.read("!H")[0]
4693 return obj
4694
4695 def __eq__(self, other):
4696 if type(self) != type(other): return False
4697 if self.value != other.value: return False
4698 return True
4699
4700 def pretty_print(self, q):
4701 q.text("sctp_src {")
4702 with q.group():
4703 with q.indent(2):
4704 q.breakable()
4705 q.text("value = ");
4706 q.text("%#x" % self.value)
4707 q.breakable()
4708 q.text('}')
4709
4710oxm.subtypes[2147492354] = sctp_src
4711
4712class sctp_src_masked(oxm):
4713 type_len = 2147492612
4714
4715 def __init__(self, value=None, value_mask=None):
4716 if value != None:
4717 self.value = value
4718 else:
4719 self.value = 0
4720 if value_mask != None:
4721 self.value_mask = value_mask
4722 else:
4723 self.value_mask = 0
4724 return
4725
4726 def pack(self):
4727 packed = []
4728 packed.append(struct.pack("!L", self.type_len))
4729 packed.append(struct.pack("!H", self.value))
4730 packed.append(struct.pack("!H", self.value_mask))
4731 return ''.join(packed)
4732
4733 @staticmethod
4734 def unpack(reader):
4735 obj = sctp_src_masked()
4736 _type_len = reader.read("!L")[0]
4737 assert(_type_len == 2147492612)
4738 obj.value = reader.read("!H")[0]
4739 obj.value_mask = reader.read("!H")[0]
4740 return obj
4741
4742 def __eq__(self, other):
4743 if type(self) != type(other): return False
4744 if self.value != other.value: return False
4745 if self.value_mask != other.value_mask: return False
4746 return True
4747
4748 def pretty_print(self, q):
4749 q.text("sctp_src_masked {")
4750 with q.group():
4751 with q.indent(2):
4752 q.breakable()
4753 q.text("value = ");
4754 q.text("%#x" % self.value)
4755 q.text(","); q.breakable()
4756 q.text("value_mask = ");
4757 q.text("%#x" % self.value_mask)
4758 q.breakable()
4759 q.text('}')
4760
4761oxm.subtypes[2147492612] = sctp_src_masked
4762
4763class tcp_dst(oxm):
4764 type_len = 2147490818
4765
4766 def __init__(self, value=None):
4767 if value != None:
4768 self.value = value
4769 else:
4770 self.value = 0
4771 return
4772
4773 def pack(self):
4774 packed = []
4775 packed.append(struct.pack("!L", self.type_len))
4776 packed.append(struct.pack("!H", self.value))
4777 return ''.join(packed)
4778
4779 @staticmethod
4780 def unpack(reader):
4781 obj = tcp_dst()
4782 _type_len = reader.read("!L")[0]
4783 assert(_type_len == 2147490818)
4784 obj.value = reader.read("!H")[0]
4785 return obj
4786
4787 def __eq__(self, other):
4788 if type(self) != type(other): return False
4789 if self.value != other.value: return False
4790 return True
4791
4792 def pretty_print(self, q):
4793 q.text("tcp_dst {")
4794 with q.group():
4795 with q.indent(2):
4796 q.breakable()
4797 q.text("value = ");
4798 q.text("%#x" % self.value)
4799 q.breakable()
4800 q.text('}')
4801
4802oxm.subtypes[2147490818] = tcp_dst
4803
4804class tcp_dst_masked(oxm):
4805 type_len = 2147491076
4806
4807 def __init__(self, value=None, value_mask=None):
4808 if value != None:
4809 self.value = value
4810 else:
4811 self.value = 0
4812 if value_mask != None:
4813 self.value_mask = value_mask
4814 else:
4815 self.value_mask = 0
4816 return
4817
4818 def pack(self):
4819 packed = []
4820 packed.append(struct.pack("!L", self.type_len))
4821 packed.append(struct.pack("!H", self.value))
4822 packed.append(struct.pack("!H", self.value_mask))
4823 return ''.join(packed)
4824
4825 @staticmethod
4826 def unpack(reader):
4827 obj = tcp_dst_masked()
4828 _type_len = reader.read("!L")[0]
4829 assert(_type_len == 2147491076)
4830 obj.value = reader.read("!H")[0]
4831 obj.value_mask = reader.read("!H")[0]
4832 return obj
4833
4834 def __eq__(self, other):
4835 if type(self) != type(other): return False
4836 if self.value != other.value: return False
4837 if self.value_mask != other.value_mask: return False
4838 return True
4839
4840 def pretty_print(self, q):
4841 q.text("tcp_dst_masked {")
4842 with q.group():
4843 with q.indent(2):
4844 q.breakable()
4845 q.text("value = ");
4846 q.text("%#x" % self.value)
4847 q.text(","); q.breakable()
4848 q.text("value_mask = ");
4849 q.text("%#x" % self.value_mask)
4850 q.breakable()
4851 q.text('}')
4852
4853oxm.subtypes[2147491076] = tcp_dst_masked
4854
4855class tcp_src(oxm):
4856 type_len = 2147490306
4857
4858 def __init__(self, value=None):
4859 if value != None:
4860 self.value = value
4861 else:
4862 self.value = 0
4863 return
4864
4865 def pack(self):
4866 packed = []
4867 packed.append(struct.pack("!L", self.type_len))
4868 packed.append(struct.pack("!H", self.value))
4869 return ''.join(packed)
4870
4871 @staticmethod
4872 def unpack(reader):
4873 obj = tcp_src()
4874 _type_len = reader.read("!L")[0]
4875 assert(_type_len == 2147490306)
4876 obj.value = reader.read("!H")[0]
4877 return obj
4878
4879 def __eq__(self, other):
4880 if type(self) != type(other): return False
4881 if self.value != other.value: return False
4882 return True
4883
4884 def pretty_print(self, q):
4885 q.text("tcp_src {")
4886 with q.group():
4887 with q.indent(2):
4888 q.breakable()
4889 q.text("value = ");
4890 q.text("%#x" % self.value)
4891 q.breakable()
4892 q.text('}')
4893
4894oxm.subtypes[2147490306] = tcp_src
4895
4896class tcp_src_masked(oxm):
4897 type_len = 2147490564
4898
4899 def __init__(self, value=None, value_mask=None):
4900 if value != None:
4901 self.value = value
4902 else:
4903 self.value = 0
4904 if value_mask != None:
4905 self.value_mask = value_mask
4906 else:
4907 self.value_mask = 0
4908 return
4909
4910 def pack(self):
4911 packed = []
4912 packed.append(struct.pack("!L", self.type_len))
4913 packed.append(struct.pack("!H", self.value))
4914 packed.append(struct.pack("!H", self.value_mask))
4915 return ''.join(packed)
4916
4917 @staticmethod
4918 def unpack(reader):
4919 obj = tcp_src_masked()
4920 _type_len = reader.read("!L")[0]
4921 assert(_type_len == 2147490564)
4922 obj.value = reader.read("!H")[0]
4923 obj.value_mask = reader.read("!H")[0]
4924 return obj
4925
4926 def __eq__(self, other):
4927 if type(self) != type(other): return False
4928 if self.value != other.value: return False
4929 if self.value_mask != other.value_mask: return False
4930 return True
4931
4932 def pretty_print(self, q):
4933 q.text("tcp_src_masked {")
4934 with q.group():
4935 with q.indent(2):
4936 q.breakable()
4937 q.text("value = ");
4938 q.text("%#x" % self.value)
4939 q.text(","); q.breakable()
4940 q.text("value_mask = ");
4941 q.text("%#x" % self.value_mask)
4942 q.breakable()
4943 q.text('}')
4944
4945oxm.subtypes[2147490564] = tcp_src_masked
4946
4947class tunnel_ipv4_dst(oxm):
4948 type_len = 81924
4949
4950 def __init__(self, value=None):
4951 if value != None:
4952 self.value = value
4953 else:
4954 self.value = 0
4955 return
4956
4957 def pack(self):
4958 packed = []
4959 packed.append(struct.pack("!L", self.type_len))
4960 packed.append(struct.pack("!L", self.value))
4961 return ''.join(packed)
4962
4963 @staticmethod
4964 def unpack(reader):
4965 obj = tunnel_ipv4_dst()
4966 _type_len = reader.read("!L")[0]
4967 assert(_type_len == 81924)
4968 obj.value = reader.read("!L")[0]
4969 return obj
4970
4971 def __eq__(self, other):
4972 if type(self) != type(other): return False
4973 if self.value != other.value: return False
4974 return True
4975
4976 def pretty_print(self, q):
4977 q.text("tunnel_ipv4_dst {")
4978 with q.group():
4979 with q.indent(2):
4980 q.breakable()
4981 q.text("value = ");
4982 q.text(util.pretty_ipv4(self.value))
4983 q.breakable()
4984 q.text('}')
4985
4986oxm.subtypes[81924] = tunnel_ipv4_dst
4987
4988class tunnel_ipv4_dst_masked(oxm):
4989 type_len = 82184
4990
4991 def __init__(self, value=None, value_mask=None):
4992 if value != None:
4993 self.value = value
4994 else:
4995 self.value = 0
4996 if value_mask != None:
4997 self.value_mask = value_mask
4998 else:
4999 self.value_mask = 0
5000 return
5001
5002 def pack(self):
5003 packed = []
5004 packed.append(struct.pack("!L", self.type_len))
5005 packed.append(struct.pack("!L", self.value))
5006 packed.append(struct.pack("!L", self.value_mask))
5007 return ''.join(packed)
5008
5009 @staticmethod
5010 def unpack(reader):
5011 obj = tunnel_ipv4_dst_masked()
5012 _type_len = reader.read("!L")[0]
5013 assert(_type_len == 82184)
5014 obj.value = reader.read("!L")[0]
5015 obj.value_mask = reader.read("!L")[0]
5016 return obj
5017
5018 def __eq__(self, other):
5019 if type(self) != type(other): return False
5020 if self.value != other.value: return False
5021 if self.value_mask != other.value_mask: return False
5022 return True
5023
5024 def pretty_print(self, q):
5025 q.text("tunnel_ipv4_dst_masked {")
5026 with q.group():
5027 with q.indent(2):
5028 q.breakable()
5029 q.text("value = ");
5030 q.text(util.pretty_ipv4(self.value))
5031 q.text(","); q.breakable()
5032 q.text("value_mask = ");
5033 q.text(util.pretty_ipv4(self.value_mask))
5034 q.breakable()
5035 q.text('}')
5036
5037oxm.subtypes[82184] = tunnel_ipv4_dst_masked
5038
5039class tunnel_ipv4_src(oxm):
5040 type_len = 81412
5041
5042 def __init__(self, value=None):
5043 if value != None:
5044 self.value = value
5045 else:
5046 self.value = 0
5047 return
5048
5049 def pack(self):
5050 packed = []
5051 packed.append(struct.pack("!L", self.type_len))
5052 packed.append(struct.pack("!L", self.value))
5053 return ''.join(packed)
5054
5055 @staticmethod
5056 def unpack(reader):
5057 obj = tunnel_ipv4_src()
5058 _type_len = reader.read("!L")[0]
5059 assert(_type_len == 81412)
5060 obj.value = reader.read("!L")[0]
5061 return obj
5062
5063 def __eq__(self, other):
5064 if type(self) != type(other): return False
5065 if self.value != other.value: return False
5066 return True
5067
5068 def pretty_print(self, q):
5069 q.text("tunnel_ipv4_src {")
5070 with q.group():
5071 with q.indent(2):
5072 q.breakable()
5073 q.text("value = ");
5074 q.text(util.pretty_ipv4(self.value))
5075 q.breakable()
5076 q.text('}')
5077
5078oxm.subtypes[81412] = tunnel_ipv4_src
5079
5080class tunnel_ipv4_src_masked(oxm):
5081 type_len = 81672
5082
5083 def __init__(self, value=None, value_mask=None):
5084 if value != None:
5085 self.value = value
5086 else:
5087 self.value = 0
5088 if value_mask != None:
5089 self.value_mask = value_mask
5090 else:
5091 self.value_mask = 0
5092 return
5093
5094 def pack(self):
5095 packed = []
5096 packed.append(struct.pack("!L", self.type_len))
5097 packed.append(struct.pack("!L", self.value))
5098 packed.append(struct.pack("!L", self.value_mask))
5099 return ''.join(packed)
5100
5101 @staticmethod
5102 def unpack(reader):
5103 obj = tunnel_ipv4_src_masked()
5104 _type_len = reader.read("!L")[0]
5105 assert(_type_len == 81672)
5106 obj.value = reader.read("!L")[0]
5107 obj.value_mask = reader.read("!L")[0]
5108 return obj
5109
5110 def __eq__(self, other):
5111 if type(self) != type(other): return False
5112 if self.value != other.value: return False
5113 if self.value_mask != other.value_mask: return False
5114 return True
5115
5116 def pretty_print(self, q):
5117 q.text("tunnel_ipv4_src_masked {")
5118 with q.group():
5119 with q.indent(2):
5120 q.breakable()
5121 q.text("value = ");
5122 q.text(util.pretty_ipv4(self.value))
5123 q.text(","); q.breakable()
5124 q.text("value_mask = ");
5125 q.text(util.pretty_ipv4(self.value_mask))
5126 q.breakable()
5127 q.text('}')
5128
5129oxm.subtypes[81672] = tunnel_ipv4_src_masked
5130
5131class udp_dst(oxm):
5132 type_len = 2147491842
5133
5134 def __init__(self, value=None):
5135 if value != None:
5136 self.value = value
5137 else:
5138 self.value = 0
5139 return
5140
5141 def pack(self):
5142 packed = []
5143 packed.append(struct.pack("!L", self.type_len))
5144 packed.append(struct.pack("!H", self.value))
5145 return ''.join(packed)
5146
5147 @staticmethod
5148 def unpack(reader):
5149 obj = udp_dst()
5150 _type_len = reader.read("!L")[0]
5151 assert(_type_len == 2147491842)
5152 obj.value = reader.read("!H")[0]
5153 return obj
5154
5155 def __eq__(self, other):
5156 if type(self) != type(other): return False
5157 if self.value != other.value: return False
5158 return True
5159
5160 def pretty_print(self, q):
5161 q.text("udp_dst {")
5162 with q.group():
5163 with q.indent(2):
5164 q.breakable()
5165 q.text("value = ");
5166 q.text("%#x" % self.value)
5167 q.breakable()
5168 q.text('}')
5169
5170oxm.subtypes[2147491842] = udp_dst
5171
5172class udp_dst_masked(oxm):
5173 type_len = 2147492100
5174
5175 def __init__(self, value=None, value_mask=None):
5176 if value != None:
5177 self.value = value
5178 else:
5179 self.value = 0
5180 if value_mask != None:
5181 self.value_mask = value_mask
5182 else:
5183 self.value_mask = 0
5184 return
5185
5186 def pack(self):
5187 packed = []
5188 packed.append(struct.pack("!L", self.type_len))
5189 packed.append(struct.pack("!H", self.value))
5190 packed.append(struct.pack("!H", self.value_mask))
5191 return ''.join(packed)
5192
5193 @staticmethod
5194 def unpack(reader):
5195 obj = udp_dst_masked()
5196 _type_len = reader.read("!L")[0]
5197 assert(_type_len == 2147492100)
5198 obj.value = reader.read("!H")[0]
5199 obj.value_mask = reader.read("!H")[0]
5200 return obj
5201
5202 def __eq__(self, other):
5203 if type(self) != type(other): return False
5204 if self.value != other.value: return False
5205 if self.value_mask != other.value_mask: return False
5206 return True
5207
5208 def pretty_print(self, q):
5209 q.text("udp_dst_masked {")
5210 with q.group():
5211 with q.indent(2):
5212 q.breakable()
5213 q.text("value = ");
5214 q.text("%#x" % self.value)
5215 q.text(","); q.breakable()
5216 q.text("value_mask = ");
5217 q.text("%#x" % self.value_mask)
5218 q.breakable()
5219 q.text('}')
5220
5221oxm.subtypes[2147492100] = udp_dst_masked
5222
5223class udp_src(oxm):
5224 type_len = 2147491330
5225
5226 def __init__(self, value=None):
5227 if value != None:
5228 self.value = value
5229 else:
5230 self.value = 0
5231 return
5232
5233 def pack(self):
5234 packed = []
5235 packed.append(struct.pack("!L", self.type_len))
5236 packed.append(struct.pack("!H", self.value))
5237 return ''.join(packed)
5238
5239 @staticmethod
5240 def unpack(reader):
5241 obj = udp_src()
5242 _type_len = reader.read("!L")[0]
5243 assert(_type_len == 2147491330)
5244 obj.value = reader.read("!H")[0]
5245 return obj
5246
5247 def __eq__(self, other):
5248 if type(self) != type(other): return False
5249 if self.value != other.value: return False
5250 return True
5251
5252 def pretty_print(self, q):
5253 q.text("udp_src {")
5254 with q.group():
5255 with q.indent(2):
5256 q.breakable()
5257 q.text("value = ");
5258 q.text("%#x" % self.value)
5259 q.breakable()
5260 q.text('}')
5261
5262oxm.subtypes[2147491330] = udp_src
5263
5264class udp_src_masked(oxm):
5265 type_len = 2147491588
5266
5267 def __init__(self, value=None, value_mask=None):
5268 if value != None:
5269 self.value = value
5270 else:
5271 self.value = 0
5272 if value_mask != None:
5273 self.value_mask = value_mask
5274 else:
5275 self.value_mask = 0
5276 return
5277
5278 def pack(self):
5279 packed = []
5280 packed.append(struct.pack("!L", self.type_len))
5281 packed.append(struct.pack("!H", self.value))
5282 packed.append(struct.pack("!H", self.value_mask))
5283 return ''.join(packed)
5284
5285 @staticmethod
5286 def unpack(reader):
5287 obj = udp_src_masked()
5288 _type_len = reader.read("!L")[0]
5289 assert(_type_len == 2147491588)
5290 obj.value = reader.read("!H")[0]
5291 obj.value_mask = reader.read("!H")[0]
5292 return obj
5293
5294 def __eq__(self, other):
5295 if type(self) != type(other): return False
5296 if self.value != other.value: return False
5297 if self.value_mask != other.value_mask: return False
5298 return True
5299
5300 def pretty_print(self, q):
5301 q.text("udp_src_masked {")
5302 with q.group():
5303 with q.indent(2):
5304 q.breakable()
5305 q.text("value = ");
5306 q.text("%#x" % self.value)
5307 q.text(","); q.breakable()
5308 q.text("value_mask = ");
5309 q.text("%#x" % self.value_mask)
5310 q.breakable()
5311 q.text('}')
5312
5313oxm.subtypes[2147491588] = udp_src_masked
5314
5315class vlan_pcp(oxm):
5316 type_len = 2147487233
5317
5318 def __init__(self, value=None):
5319 if value != None:
5320 self.value = value
5321 else:
5322 self.value = 0
5323 return
5324
5325 def pack(self):
5326 packed = []
5327 packed.append(struct.pack("!L", self.type_len))
5328 packed.append(struct.pack("!B", self.value))
5329 return ''.join(packed)
5330
5331 @staticmethod
5332 def unpack(reader):
5333 obj = vlan_pcp()
5334 _type_len = reader.read("!L")[0]
5335 assert(_type_len == 2147487233)
5336 obj.value = reader.read("!B")[0]
5337 return obj
5338
5339 def __eq__(self, other):
5340 if type(self) != type(other): return False
5341 if self.value != other.value: return False
5342 return True
5343
5344 def pretty_print(self, q):
5345 q.text("vlan_pcp {")
5346 with q.group():
5347 with q.indent(2):
5348 q.breakable()
5349 q.text("value = ");
5350 q.text("%#x" % self.value)
5351 q.breakable()
5352 q.text('}')
5353
5354oxm.subtypes[2147487233] = vlan_pcp
5355
5356class vlan_pcp_masked(oxm):
5357 type_len = 2147487490
5358
5359 def __init__(self, value=None, value_mask=None):
5360 if value != None:
5361 self.value = value
5362 else:
5363 self.value = 0
5364 if value_mask != None:
5365 self.value_mask = value_mask
5366 else:
5367 self.value_mask = 0
5368 return
5369
5370 def pack(self):
5371 packed = []
5372 packed.append(struct.pack("!L", self.type_len))
5373 packed.append(struct.pack("!B", self.value))
5374 packed.append(struct.pack("!B", self.value_mask))
5375 return ''.join(packed)
5376
5377 @staticmethod
5378 def unpack(reader):
5379 obj = vlan_pcp_masked()
5380 _type_len = reader.read("!L")[0]
5381 assert(_type_len == 2147487490)
5382 obj.value = reader.read("!B")[0]
5383 obj.value_mask = reader.read("!B")[0]
5384 return obj
5385
5386 def __eq__(self, other):
5387 if type(self) != type(other): return False
5388 if self.value != other.value: return False
5389 if self.value_mask != other.value_mask: return False
5390 return True
5391
5392 def pretty_print(self, q):
5393 q.text("vlan_pcp_masked {")
5394 with q.group():
5395 with q.indent(2):
5396 q.breakable()
5397 q.text("value = ");
5398 q.text("%#x" % self.value)
5399 q.text(","); q.breakable()
5400 q.text("value_mask = ");
5401 q.text("%#x" % self.value_mask)
5402 q.breakable()
5403 q.text('}')
5404
5405oxm.subtypes[2147487490] = vlan_pcp_masked
5406
5407class vlan_vid(oxm):
5408 type_len = 2147486722
5409
5410 def __init__(self, value=None):
5411 if value != None:
5412 self.value = value
5413 else:
5414 self.value = 0
5415 return
5416
5417 def pack(self):
5418 packed = []
5419 packed.append(struct.pack("!L", self.type_len))
5420 packed.append(struct.pack("!H", self.value))
5421 return ''.join(packed)
5422
5423 @staticmethod
5424 def unpack(reader):
5425 obj = vlan_vid()
5426 _type_len = reader.read("!L")[0]
5427 assert(_type_len == 2147486722)
5428 obj.value = reader.read("!H")[0]
5429 return obj
5430
5431 def __eq__(self, other):
5432 if type(self) != type(other): return False
5433 if self.value != other.value: return False
5434 return True
5435
5436 def pretty_print(self, q):
5437 q.text("vlan_vid {")
5438 with q.group():
5439 with q.indent(2):
5440 q.breakable()
5441 q.text("value = ");
5442 q.text("%#x" % self.value)
5443 q.breakable()
5444 q.text('}')
5445
5446oxm.subtypes[2147486722] = vlan_vid
5447
5448class vlan_vid_masked(oxm):
5449 type_len = 2147486980
5450
5451 def __init__(self, value=None, value_mask=None):
5452 if value != None:
5453 self.value = value
5454 else:
5455 self.value = 0
5456 if value_mask != None:
5457 self.value_mask = value_mask
5458 else:
5459 self.value_mask = 0
5460 return
5461
5462 def pack(self):
5463 packed = []
5464 packed.append(struct.pack("!L", self.type_len))
5465 packed.append(struct.pack("!H", self.value))
5466 packed.append(struct.pack("!H", self.value_mask))
5467 return ''.join(packed)
5468
5469 @staticmethod
5470 def unpack(reader):
5471 obj = vlan_vid_masked()
5472 _type_len = reader.read("!L")[0]
5473 assert(_type_len == 2147486980)
5474 obj.value = reader.read("!H")[0]
5475 obj.value_mask = reader.read("!H")[0]
5476 return obj
5477
5478 def __eq__(self, other):
5479 if type(self) != type(other): return False
5480 if self.value != other.value: return False
5481 if self.value_mask != other.value_mask: return False
5482 return True
5483
5484 def pretty_print(self, q):
5485 q.text("vlan_vid_masked {")
5486 with q.group():
5487 with q.indent(2):
5488 q.breakable()
5489 q.text("value = ");
5490 q.text("%#x" % self.value)
5491 q.text(","); q.breakable()
5492 q.text("value_mask = ");
5493 q.text("%#x" % self.value_mask)
5494 q.breakable()
5495 q.text('}')
5496
5497oxm.subtypes[2147486980] = vlan_vid_masked
5498
5499