Gitiles
Code Review Sign In
gerrit.opencord.org / goloxi / 44bdbfc319927fdbd8a09267da232ae09bc39962 / . / of15 / action_id.go
blob: 426c1eab5e765f7009e4e46a28fae0db698fb946 [file] [log] [blame]
Jonathan Hart44bdbfc2020-04-14 17:45:47 -0700[diff] [blame^]1/*
2 * Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
3 * Copyright (c) 2011, 2012 Open Networking Foundation
4 * Copyright 2013, Big Switch Networks, Inc. This library was generated by the LoxiGen Compiler.
5 * Copyright 2018, Red Hat, Inc.
6 */
7// Automatically generated by LOXI from template module.go
8// Do not modify
9
10package of15
11
12import (
13 "encoding/binary"
14 "fmt"
15
16 "github.com/opencord/goloxi"
17)
18
19type ActionId struct {
20 Type uint16
21 Len uint16
22}
23
24type IActionId interface {
25 goloxi.Serializable
26 GetType() uint16
27 GetLen() uint16
28}
29
30func (self *ActionId) GetType() uint16 {
31 return self.Type
32}
33
34func (self *ActionId) SetType(v uint16) {
35 self.Type = v
36}
37
38func (self *ActionId) GetLen() uint16 {
39 return self.Len
40}
41
42func (self *ActionId) SetLen(v uint16) {
43 self.Len = v
44}
45
46func (self *ActionId) Serialize(encoder *goloxi.Encoder) error {
47
48 encoder.PutUint16(uint16(self.Type))
49 encoder.PutUint16(uint16(self.Len))
50
51 return nil
52}
53
54func DecodeActionId(decoder *goloxi.Decoder) (IActionId, error) {
55 _actionid := &ActionId{}
56 if decoder.Length() < 4 {
57 return nil, fmt.Errorf("ActionId packet too short: %d < 4", decoder.Length())
58 }
59 _actionid.Type = uint16(decoder.ReadUint16())
60 _actionid.Len = uint16(decoder.ReadUint16())
61 oldDecoder := decoder
62 defer func() { decoder = oldDecoder }()
63 decoder = decoder.SliceDecoder(int(_actionid.Len), 2+2)
64
65 switch _actionid.Type {
66 case 0:
67 return DecodeActionIdOutput(_actionid, decoder)
68 case 11:
69 return DecodeActionIdCopyTtlOut(_actionid, decoder)
70 case 12:
71 return DecodeActionIdCopyTtlIn(_actionid, decoder)
72 case 15:
73 return DecodeActionIdSetMplsTtl(_actionid, decoder)
74 case 16:
75 return DecodeActionIdDecMplsTtl(_actionid, decoder)
76 case 17:
77 return DecodeActionIdPushVlan(_actionid, decoder)
78 case 18:
79 return DecodeActionIdPopVlan(_actionid, decoder)
80 case 19:
81 return DecodeActionIdPushMpls(_actionid, decoder)
82 case 20:
83 return DecodeActionIdPopMpls(_actionid, decoder)
84 case 21:
85 return DecodeActionIdSetQueue(_actionid, decoder)
86 case 22:
87 return DecodeActionIdGroup(_actionid, decoder)
88 case 23:
89 return DecodeActionIdSetNwTtl(_actionid, decoder)
90 case 24:
91 return DecodeActionIdDecNwTtl(_actionid, decoder)
92 case 25:
93 return DecodeActionIdSetField(_actionid, decoder)
94 case 26:
95 return DecodeActionIdPushPbb(_actionid, decoder)
96 case 27:
97 return DecodeActionIdPopPbb(_actionid, decoder)
98 case 29:
99 return DecodeActionIdMeter(_actionid, decoder)
100 case 65535:
101 return DecodeActionIdExperimenter(_actionid, decoder)
102 default:
103 return _actionid, nil
104 }
105}
106
107func NewActionId(_type uint16) *ActionId {
108 obj := &ActionId{}
109 obj.Type = _type
110 return obj
111}
112
113type ActionIdExperimenter struct {
114 *ActionId
115 Experimenter uint32
116}
117
118type IActionIdExperimenter interface {
119 IActionId
120 GetExperimenter() uint32
121}
122
123func (self *ActionIdExperimenter) GetExperimenter() uint32 {
124 return self.Experimenter
125}
126
127func (self *ActionIdExperimenter) SetExperimenter(v uint32) {
128 self.Experimenter = v
129}
130
131func (self *ActionIdExperimenter) Serialize(encoder *goloxi.Encoder) error {
132 if err := self.ActionId.Serialize(encoder); err != nil {
133 return err
134 }
135
136 encoder.PutUint32(uint32(self.Experimenter))
137
138 return nil
139}
140
141func DecodeActionIdExperimenter(parent *ActionId, decoder *goloxi.Decoder) (IActionIdExperimenter, error) {
142 _actionidexperimenter := &ActionIdExperimenter{ActionId: parent}
143 if decoder.Length() < 4 {
144 return nil, fmt.Errorf("ActionIdExperimenter packet too short: %d < 4", decoder.Length())
145 }
146 _actionidexperimenter.Experimenter = uint32(decoder.ReadUint32())
147
148 switch _actionidexperimenter.Experimenter {
149 case 8992:
150 return DecodeActionIdNicira(_actionidexperimenter, decoder)
151 case 6035143:
152 return DecodeActionIdBsn(_actionidexperimenter, decoder)
153 default:
154 return _actionidexperimenter, nil
155 }
156}
157
158func NewActionIdExperimenter(_experimenter uint32) *ActionIdExperimenter {
159 obj := &ActionIdExperimenter{
160 ActionId: NewActionId(65535),
161 }
162 obj.Experimenter = _experimenter
163 return obj
164}
165
166type ActionIdBsn struct {
167 *ActionIdExperimenter
168 Subtype uint32
169}
170
171type IActionIdBsn interface {
172 IActionIdExperimenter
173 GetSubtype() uint32
174}
175
176func (self *ActionIdBsn) GetSubtype() uint32 {
177 return self.Subtype
178}
179
180func (self *ActionIdBsn) SetSubtype(v uint32) {
181 self.Subtype = v
182}
183
184func (self *ActionIdBsn) Serialize(encoder *goloxi.Encoder) error {
185 if err := self.ActionIdExperimenter.Serialize(encoder); err != nil {
186 return err
187 }
188
189 encoder.PutUint32(uint32(self.Subtype))
190
191 return nil
192}
193
194func DecodeActionIdBsn(parent *ActionIdExperimenter, decoder *goloxi.Decoder) (IActionIdBsn, error) {
195 _actionidbsn := &ActionIdBsn{ActionIdExperimenter: parent}
196 if decoder.Length() < 4 {
197 return nil, fmt.Errorf("ActionIdBsn packet too short: %d < 4", decoder.Length())
198 }
199 _actionidbsn.Subtype = uint32(decoder.ReadUint32())
200
201 switch _actionidbsn.Subtype {
202 case 1:
203 return DecodeActionIdBsnMirror(_actionidbsn, decoder)
204 case 2:
205 return DecodeActionIdBsnSetTunnelDst(_actionidbsn, decoder)
206 case 4:
207 return DecodeActionIdBsnChecksum(_actionidbsn, decoder)
208 case 5:
209 return DecodeActionIdBsnGentable(_actionidbsn, decoder)
210 default:
211 return _actionidbsn, nil
212 }
213}
214
215func NewActionIdBsn(_subtype uint32) *ActionIdBsn {
216 obj := &ActionIdBsn{
217 ActionIdExperimenter: NewActionIdExperimenter(6035143),
218 }
219 obj.Subtype = _subtype
220 return obj
221}
222
223type ActionIdBsnChecksum struct {
224 *ActionIdBsn
225}
226
227type IActionIdBsnChecksum interface {
228 IActionIdBsn
229}
230
231func (self *ActionIdBsnChecksum) Serialize(encoder *goloxi.Encoder) error {
232 startIndex := len(encoder.Bytes())
233 if err := self.ActionIdBsn.Serialize(encoder); err != nil {
234 return err
235 }
236 length := len(encoder.Bytes()) - startIndex
237
238 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
239
240 return nil
241}
242
243func DecodeActionIdBsnChecksum(parent *ActionIdBsn, decoder *goloxi.Decoder) (*ActionIdBsnChecksum, error) {
244 _actionidbsnchecksum := &ActionIdBsnChecksum{ActionIdBsn: parent}
245 return _actionidbsnchecksum, nil
246}
247
248func NewActionIdBsnChecksum() *ActionIdBsnChecksum {
249 obj := &ActionIdBsnChecksum{
250 ActionIdBsn: NewActionIdBsn(4),
251 }
252 return obj
253}
254
255type ActionIdBsnGentable struct {
256 *ActionIdBsn
257}
258
259type IActionIdBsnGentable interface {
260 IActionIdBsn
261}
262
263func (self *ActionIdBsnGentable) Serialize(encoder *goloxi.Encoder) error {
264 startIndex := len(encoder.Bytes())
265 if err := self.ActionIdBsn.Serialize(encoder); err != nil {
266 return err
267 }
268 length := len(encoder.Bytes()) - startIndex
269
270 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
271
272 return nil
273}
274
275func DecodeActionIdBsnGentable(parent *ActionIdBsn, decoder *goloxi.Decoder) (*ActionIdBsnGentable, error) {
276 _actionidbsngentable := &ActionIdBsnGentable{ActionIdBsn: parent}
277 return _actionidbsngentable, nil
278}
279
280func NewActionIdBsnGentable() *ActionIdBsnGentable {
281 obj := &ActionIdBsnGentable{
282 ActionIdBsn: NewActionIdBsn(5),
283 }
284 return obj
285}
286
287type ActionIdBsnMirror struct {
288 *ActionIdBsn
289}
290
291type IActionIdBsnMirror interface {
292 IActionIdBsn
293}
294
295func (self *ActionIdBsnMirror) Serialize(encoder *goloxi.Encoder) error {
296 startIndex := len(encoder.Bytes())
297 if err := self.ActionIdBsn.Serialize(encoder); err != nil {
298 return err
299 }
300 length := len(encoder.Bytes()) - startIndex
301
302 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
303
304 return nil
305}
306
307func DecodeActionIdBsnMirror(parent *ActionIdBsn, decoder *goloxi.Decoder) (*ActionIdBsnMirror, error) {
308 _actionidbsnmirror := &ActionIdBsnMirror{ActionIdBsn: parent}
309 return _actionidbsnmirror, nil
310}
311
312func NewActionIdBsnMirror() *ActionIdBsnMirror {
313 obj := &ActionIdBsnMirror{
314 ActionIdBsn: NewActionIdBsn(1),
315 }
316 return obj
317}
318
319type ActionIdBsnSetTunnelDst struct {
320 *ActionIdBsn
321}
322
323type IActionIdBsnSetTunnelDst interface {
324 IActionIdBsn
325}
326
327func (self *ActionIdBsnSetTunnelDst) Serialize(encoder *goloxi.Encoder) error {
328 startIndex := len(encoder.Bytes())
329 if err := self.ActionIdBsn.Serialize(encoder); err != nil {
330 return err
331 }
332 length := len(encoder.Bytes()) - startIndex
333
334 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
335
336 return nil
337}
338
339func DecodeActionIdBsnSetTunnelDst(parent *ActionIdBsn, decoder *goloxi.Decoder) (*ActionIdBsnSetTunnelDst, error) {
340 _actionidbsnsettunneldst := &ActionIdBsnSetTunnelDst{ActionIdBsn: parent}
341 return _actionidbsnsettunneldst, nil
342}
343
344func NewActionIdBsnSetTunnelDst() *ActionIdBsnSetTunnelDst {
345 obj := &ActionIdBsnSetTunnelDst{
346 ActionIdBsn: NewActionIdBsn(2),
347 }
348 return obj
349}
350
351type ActionIdCopyTtlIn struct {
352 *ActionId
353}
354
355type IActionIdCopyTtlIn interface {
356 IActionId
357}
358
359func (self *ActionIdCopyTtlIn) Serialize(encoder *goloxi.Encoder) error {
360 startIndex := len(encoder.Bytes())
361 if err := self.ActionId.Serialize(encoder); err != nil {
362 return err
363 }
364 length := len(encoder.Bytes()) - startIndex
365
366 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
367
368 return nil
369}
370
371func DecodeActionIdCopyTtlIn(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdCopyTtlIn, error) {
372 _actionidcopyttlin := &ActionIdCopyTtlIn{ActionId: parent}
373 return _actionidcopyttlin, nil
374}
375
376func NewActionIdCopyTtlIn() *ActionIdCopyTtlIn {
377 obj := &ActionIdCopyTtlIn{
378 ActionId: NewActionId(12),
379 }
380 return obj
381}
382
383type ActionIdCopyTtlOut struct {
384 *ActionId
385}
386
387type IActionIdCopyTtlOut interface {
388 IActionId
389}
390
391func (self *ActionIdCopyTtlOut) Serialize(encoder *goloxi.Encoder) error {
392 startIndex := len(encoder.Bytes())
393 if err := self.ActionId.Serialize(encoder); err != nil {
394 return err
395 }
396 length := len(encoder.Bytes()) - startIndex
397
398 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
399
400 return nil
401}
402
403func DecodeActionIdCopyTtlOut(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdCopyTtlOut, error) {
404 _actionidcopyttlout := &ActionIdCopyTtlOut{ActionId: parent}
405 return _actionidcopyttlout, nil
406}
407
408func NewActionIdCopyTtlOut() *ActionIdCopyTtlOut {
409 obj := &ActionIdCopyTtlOut{
410 ActionId: NewActionId(11),
411 }
412 return obj
413}
414
415type ActionIdDecMplsTtl struct {
416 *ActionId
417}
418
419type IActionIdDecMplsTtl interface {
420 IActionId
421}
422
423func (self *ActionIdDecMplsTtl) Serialize(encoder *goloxi.Encoder) error {
424 startIndex := len(encoder.Bytes())
425 if err := self.ActionId.Serialize(encoder); err != nil {
426 return err
427 }
428 length := len(encoder.Bytes()) - startIndex
429
430 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
431
432 return nil
433}
434
435func DecodeActionIdDecMplsTtl(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdDecMplsTtl, error) {
436 _actioniddecmplsttl := &ActionIdDecMplsTtl{ActionId: parent}
437 return _actioniddecmplsttl, nil
438}
439
440func NewActionIdDecMplsTtl() *ActionIdDecMplsTtl {
441 obj := &ActionIdDecMplsTtl{
442 ActionId: NewActionId(16),
443 }
444 return obj
445}
446
447type ActionIdDecNwTtl struct {
448 *ActionId
449}
450
451type IActionIdDecNwTtl interface {
452 IActionId
453}
454
455func (self *ActionIdDecNwTtl) Serialize(encoder *goloxi.Encoder) error {
456 startIndex := len(encoder.Bytes())
457 if err := self.ActionId.Serialize(encoder); err != nil {
458 return err
459 }
460 length := len(encoder.Bytes()) - startIndex
461
462 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
463
464 return nil
465}
466
467func DecodeActionIdDecNwTtl(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdDecNwTtl, error) {
468 _actioniddecnwttl := &ActionIdDecNwTtl{ActionId: parent}
469 return _actioniddecnwttl, nil
470}
471
472func NewActionIdDecNwTtl() *ActionIdDecNwTtl {
473 obj := &ActionIdDecNwTtl{
474 ActionId: NewActionId(24),
475 }
476 return obj
477}
478
479type ActionIdGroup struct {
480 *ActionId
481}
482
483type IActionIdGroup interface {
484 IActionId
485}
486
487func (self *ActionIdGroup) Serialize(encoder *goloxi.Encoder) error {
488 startIndex := len(encoder.Bytes())
489 if err := self.ActionId.Serialize(encoder); err != nil {
490 return err
491 }
492 length := len(encoder.Bytes()) - startIndex
493
494 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
495
496 return nil
497}
498
499func DecodeActionIdGroup(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdGroup, error) {
500 _actionidgroup := &ActionIdGroup{ActionId: parent}
501 return _actionidgroup, nil
502}
503
504func NewActionIdGroup() *ActionIdGroup {
505 obj := &ActionIdGroup{
506 ActionId: NewActionId(22),
507 }
508 return obj
509}
510
511type ActionIdMeter struct {
512 *ActionId
513}
514
515type IActionIdMeter interface {
516 IActionId
517}
518
519func (self *ActionIdMeter) Serialize(encoder *goloxi.Encoder) error {
520 startIndex := len(encoder.Bytes())
521 if err := self.ActionId.Serialize(encoder); err != nil {
522 return err
523 }
524 length := len(encoder.Bytes()) - startIndex
525
526 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
527
528 return nil
529}
530
531func DecodeActionIdMeter(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdMeter, error) {
532 _actionidmeter := &ActionIdMeter{ActionId: parent}
533 return _actionidmeter, nil
534}
535
536func NewActionIdMeter() *ActionIdMeter {
537 obj := &ActionIdMeter{
538 ActionId: NewActionId(29),
539 }
540 return obj
541}
542
543type ActionIdNicira struct {
544 *ActionIdExperimenter
545 Subtype uint16
546}
547
548type IActionIdNicira interface {
549 IActionIdExperimenter
550 GetSubtype() uint16
551}
552
553func (self *ActionIdNicira) GetSubtype() uint16 {
554 return self.Subtype
555}
556
557func (self *ActionIdNicira) SetSubtype(v uint16) {
558 self.Subtype = v
559}
560
561func (self *ActionIdNicira) Serialize(encoder *goloxi.Encoder) error {
562 if err := self.ActionIdExperimenter.Serialize(encoder); err != nil {
563 return err
564 }
565
566 encoder.PutUint16(uint16(self.Subtype))
567
568 return nil
569}
570
571func DecodeActionIdNicira(parent *ActionIdExperimenter, decoder *goloxi.Decoder) (IActionIdNicira, error) {
572 _actionidnicira := &ActionIdNicira{ActionIdExperimenter: parent}
573 if decoder.Length() < 2 {
574 return nil, fmt.Errorf("ActionIdNicira packet too short: %d < 2", decoder.Length())
575 }
576 _actionidnicira.Subtype = uint16(decoder.ReadUint16())
577
578 switch _actionidnicira.Subtype {
579 case 1:
580 return DecodeActionIdNxResubmit(_actionidnicira, decoder)
581 case 2:
582 return DecodeActionIdNxSetTunnel(_actionidnicira, decoder)
583 case 4:
584 return DecodeActionIdNxSetQueue(_actionidnicira, decoder)
585 case 5:
586 return DecodeActionIdNxPopQueue(_actionidnicira, decoder)
587 case 6:
588 return DecodeActionIdNxRegMove(_actionidnicira, decoder)
589 case 7:
590 return DecodeActionIdNxRegLoad(_actionidnicira, decoder)
591 case 8:
592 return DecodeActionIdNxNote(_actionidnicira, decoder)
593 case 9:
594 return DecodeActionIdNxSetTunnel64(_actionidnicira, decoder)
595 case 10:
596 return DecodeActionIdNxMultipath(_actionidnicira, decoder)
597 case 12:
598 return DecodeActionIdNxBundle(_actionidnicira, decoder)
599 case 13:
600 return DecodeActionIdNxBundleLoadInPort(_actionidnicira, decoder)
601 case 14:
602 return DecodeActionIdResubmit(_actionidnicira, decoder)
603 case 15:
604 return DecodeActionIdNxOutputReg(_actionidnicira, decoder)
605 case 16:
606 return DecodeActionIdNxLearn(_actionidnicira, decoder)
607 case 17:
608 return DecodeActionIdNxExit(_actionidnicira, decoder)
609 case 18:
610 return DecodeActionIdNiciraDecTtl(_actionidnicira, decoder)
611 case 19:
612 return DecodeActionIdNxFinTimeout(_actionidnicira, decoder)
613 case 20:
614 return DecodeActionIdNxController(_actionidnicira, decoder)
615 case 21:
616 return DecodeActionIdNxDecTtlCntIds(_actionidnicira, decoder)
617 case 22:
618 return DecodeActionIdNxWriteMetadata(_actionidnicira, decoder)
619 case 23:
620 return DecodeActionIdNxPushMpls(_actionidnicira, decoder)
621 case 24:
622 return DecodeActionIdNxPopMpls(_actionidnicira, decoder)
623 case 25:
624 return DecodeActionIdNxSetMplsTtl(_actionidnicira, decoder)
625 case 26:
626 return DecodeActionIdNxDecMplsTtl(_actionidnicira, decoder)
627 case 27:
628 return DecodeActionIdNxStackPush(_actionidnicira, decoder)
629 case 28:
630 return DecodeActionIdNxStackPop(_actionidnicira, decoder)
631 case 29:
632 return DecodeActionIdNxSample(_actionidnicira, decoder)
633 case 30:
634 return DecodeActionIdNxSetMplsLabel(_actionidnicira, decoder)
635 case 31:
636 return DecodeActionIdNxSetMplsTc(_actionidnicira, decoder)
637 case 32:
638 return DecodeActionIdNxOutputReg2(_actionidnicira, decoder)
639 case 33:
640 return DecodeActionIdNxRegLoad2(_actionidnicira, decoder)
641 case 34:
642 return DecodeActionIdNxConjunction(_actionidnicira, decoder)
643 case 35:
644 return DecodeActionIdNxCt(_actionidnicira, decoder)
645 case 36:
646 return DecodeActionIdNxNat(_actionidnicira, decoder)
647 case 37:
648 return DecodeActionIdNxController2(_actionidnicira, decoder)
649 case 38:
650 return DecodeActionIdNxSample2(_actionidnicira, decoder)
651 case 39:
652 return DecodeActionIdNxOutputTrunc(_actionidnicira, decoder)
653 case 40:
654 return DecodeActionIdNxGroup(_actionidnicira, decoder)
655 case 41:
656 return DecodeActionIdNxSample3(_actionidnicira, decoder)
657 case 42:
658 return DecodeActionIdNxClone(_actionidnicira, decoder)
659 case 43:
660 return DecodeActionIdNxCtClear(_actionidnicira, decoder)
661 case 44:
662 return DecodeActionIdNxResubmitTableCt(_actionidnicira, decoder)
663 case 45:
664 return DecodeActionIdNxLearn2(_actionidnicira, decoder)
665 case 46:
666 return DecodeActionIdNxEncap(_actionidnicira, decoder)
667 case 47:
668 return DecodeActionIdNxDecap(_actionidnicira, decoder)
669 case 48:
670 return DecodeActionIdNxDecNshTtl(_actionidnicira, decoder)
671 case 254:
672 return DecodeActionIdNxDebugSlow(_actionidnicira, decoder)
673 case 255:
674 return DecodeActionIdNxDebugRecirc(_actionidnicira, decoder)
675 default:
676 return _actionidnicira, nil
677 }
678}
679
680func NewActionIdNicira(_subtype uint16) *ActionIdNicira {
681 obj := &ActionIdNicira{
682 ActionIdExperimenter: NewActionIdExperimenter(8992),
683 }
684 obj.Subtype = _subtype
685 return obj
686}
687
688type ActionIdNiciraDecTtl struct {
689 *ActionIdNicira
690}
691
692type IActionIdNiciraDecTtl interface {
693 IActionIdNicira
694}
695
696func (self *ActionIdNiciraDecTtl) Serialize(encoder *goloxi.Encoder) error {
697 startIndex := len(encoder.Bytes())
698 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
699 return err
700 }
701 length := len(encoder.Bytes()) - startIndex
702
703 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
704
705 return nil
706}
707
708func DecodeActionIdNiciraDecTtl(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNiciraDecTtl, error) {
709 _actionidniciradecttl := &ActionIdNiciraDecTtl{ActionIdNicira: parent}
710 return _actionidniciradecttl, nil
711}
712
713func NewActionIdNiciraDecTtl() *ActionIdNiciraDecTtl {
714 obj := &ActionIdNiciraDecTtl{
715 ActionIdNicira: NewActionIdNicira(18),
716 }
717 return obj
718}
719
720type ActionIdNxBundle struct {
721 *ActionIdNicira
722}
723
724type IActionIdNxBundle interface {
725 IActionIdNicira
726}
727
728func (self *ActionIdNxBundle) Serialize(encoder *goloxi.Encoder) error {
729 startIndex := len(encoder.Bytes())
730 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
731 return err
732 }
733 length := len(encoder.Bytes()) - startIndex
734
735 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
736
737 return nil
738}
739
740func DecodeActionIdNxBundle(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxBundle, error) {
741 _actionidnxbundle := &ActionIdNxBundle{ActionIdNicira: parent}
742 return _actionidnxbundle, nil
743}
744
745func NewActionIdNxBundle() *ActionIdNxBundle {
746 obj := &ActionIdNxBundle{
747 ActionIdNicira: NewActionIdNicira(12),
748 }
749 return obj
750}
751
752type ActionIdNxBundleLoad struct {
753 *ActionIdNicira
754 SlaveType ActionNxBundleSlaveType
755}
756
757type IActionIdNxBundleLoad interface {
758 IActionIdNicira
759 GetSlaveType() ActionNxBundleSlaveType
760}
761
762func (self *ActionIdNxBundleLoad) GetSlaveType() ActionNxBundleSlaveType {
763 return self.SlaveType
764}
765
766func (self *ActionIdNxBundleLoad) SetSlaveType(v ActionNxBundleSlaveType) {
767 self.SlaveType = v
768}
769
770func (self *ActionIdNxBundleLoad) Serialize(encoder *goloxi.Encoder) error {
771 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
772 return err
773 }
774
775 encoder.PutUint32(uint32(self.SlaveType))
776
777 return nil
778}
779
780func DecodeActionIdNxBundleLoad(parent *ActionIdNicira, decoder *goloxi.Decoder) (IActionIdNxBundleLoad, error) {
781 _actionidnxbundleload := &ActionIdNxBundleLoad{ActionIdNicira: parent}
782 if decoder.Length() < 4 {
783 return nil, fmt.Errorf("ActionIdNxBundleLoad packet too short: %d < 4", decoder.Length())
784 }
785 _actionidnxbundleload.SlaveType = ActionNxBundleSlaveType(decoder.ReadUint32())
786 return _actionidnxbundleload, nil
787}
788
789func NewActionIdNxBundleLoad(_slave_type ActionNxBundleSlaveType) *ActionIdNxBundleLoad {
790 obj := &ActionIdNxBundleLoad{
791 ActionIdNicira: NewActionIdNicira(13),
792 }
793 obj.SlaveType = _slave_type
794 return obj
795}
796
797type ActionIdNxBundleLoadInPort struct {
798 *ActionIdNicira
799 SlaveType ActionNxBundleSlaveType
800 NSlaves uint16
801}
802
803type IActionIdNxBundleLoadInPort interface {
804 IActionIdNicira
805 GetSlaveType() ActionNxBundleSlaveType
806 GetNSlaves() uint16
807}
808
809func (self *ActionIdNxBundleLoadInPort) GetSlaveType() ActionNxBundleSlaveType {
810 return self.SlaveType
811}
812
813func (self *ActionIdNxBundleLoadInPort) SetSlaveType(v ActionNxBundleSlaveType) {
814 self.SlaveType = v
815}
816
817func (self *ActionIdNxBundleLoadInPort) GetNSlaves() uint16 {
818 return self.NSlaves
819}
820
821func (self *ActionIdNxBundleLoadInPort) SetNSlaves(v uint16) {
822 self.NSlaves = v
823}
824
825func (self *ActionIdNxBundleLoadInPort) Serialize(encoder *goloxi.Encoder) error {
826 startIndex := len(encoder.Bytes())
827 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
828 return err
829 }
830
831 encoder.PutUint32(uint32(self.SlaveType))
832 encoder.PutUint16(uint16(self.NSlaves))
833 length := len(encoder.Bytes()) - startIndex
834
835 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
836
837 return nil
838}
839
840func DecodeActionIdNxBundleLoadInPort(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxBundleLoadInPort, error) {
841 _actionidnxbundleloadinport := &ActionIdNxBundleLoadInPort{ActionIdNicira: parent}
842 if decoder.Length() < 6 {
843 return nil, fmt.Errorf("ActionIdNxBundleLoadInPort packet too short: %d < 6", decoder.Length())
844 }
845 _actionidnxbundleloadinport.SlaveType = ActionNxBundleSlaveType(decoder.ReadUint32())
846 _actionidnxbundleloadinport.NSlaves = uint16(decoder.ReadUint16())
847 return _actionidnxbundleloadinport, nil
848}
849
850func NewActionIdNxBundleLoadInPort() *ActionIdNxBundleLoadInPort {
851 obj := &ActionIdNxBundleLoadInPort{
852 ActionIdNicira: NewActionIdNicira(13),
853 }
854 return obj
855}
856
857type ActionIdNxClone struct {
858 *ActionIdNicira
859}
860
861type IActionIdNxClone interface {
862 IActionIdNicira
863}
864
865func (self *ActionIdNxClone) Serialize(encoder *goloxi.Encoder) error {
866 startIndex := len(encoder.Bytes())
867 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
868 return err
869 }
870 length := len(encoder.Bytes()) - startIndex
871
872 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
873
874 return nil
875}
876
877func DecodeActionIdNxClone(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxClone, error) {
878 _actionidnxclone := &ActionIdNxClone{ActionIdNicira: parent}
879 return _actionidnxclone, nil
880}
881
882func NewActionIdNxClone() *ActionIdNxClone {
883 obj := &ActionIdNxClone{
884 ActionIdNicira: NewActionIdNicira(42),
885 }
886 return obj
887}
888
889type ActionIdNxConjunction struct {
890 *ActionIdNicira
891}
892
893type IActionIdNxConjunction interface {
894 IActionIdNicira
895}
896
897func (self *ActionIdNxConjunction) Serialize(encoder *goloxi.Encoder) error {
898 startIndex := len(encoder.Bytes())
899 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
900 return err
901 }
902 length := len(encoder.Bytes()) - startIndex
903
904 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
905
906 return nil
907}
908
909func DecodeActionIdNxConjunction(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxConjunction, error) {
910 _actionidnxconjunction := &ActionIdNxConjunction{ActionIdNicira: parent}
911 return _actionidnxconjunction, nil
912}
913
914func NewActionIdNxConjunction() *ActionIdNxConjunction {
915 obj := &ActionIdNxConjunction{
916 ActionIdNicira: NewActionIdNicira(34),
917 }
918 return obj
919}
920
921type ActionIdNxController struct {
922 *ActionIdNicira
923}
924
925type IActionIdNxController interface {
926 IActionIdNicira
927}
928
929func (self *ActionIdNxController) Serialize(encoder *goloxi.Encoder) error {
930 startIndex := len(encoder.Bytes())
931 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
932 return err
933 }
934 length := len(encoder.Bytes()) - startIndex
935
936 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
937
938 return nil
939}
940
941func DecodeActionIdNxController(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxController, error) {
942 _actionidnxcontroller := &ActionIdNxController{ActionIdNicira: parent}
943 return _actionidnxcontroller, nil
944}
945
946func NewActionIdNxController() *ActionIdNxController {
947 obj := &ActionIdNxController{
948 ActionIdNicira: NewActionIdNicira(20),
949 }
950 return obj
951}
952
953type ActionIdNxController2 struct {
954 *ActionIdNicira
955}
956
957type IActionIdNxController2 interface {
958 IActionIdNicira
959}
960
961func (self *ActionIdNxController2) Serialize(encoder *goloxi.Encoder) error {
962 startIndex := len(encoder.Bytes())
963 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
964 return err
965 }
966 length := len(encoder.Bytes()) - startIndex
967
968 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
969
970 return nil
971}
972
973func DecodeActionIdNxController2(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxController2, error) {
974 _actionidnxcontroller2 := &ActionIdNxController2{ActionIdNicira: parent}
975 return _actionidnxcontroller2, nil
976}
977
978func NewActionIdNxController2() *ActionIdNxController2 {
979 obj := &ActionIdNxController2{
980 ActionIdNicira: NewActionIdNicira(37),
981 }
982 return obj
983}
984
985type ActionIdNxCt struct {
986 *ActionIdNicira
987}
988
989type IActionIdNxCt interface {
990 IActionIdNicira
991}
992
993func (self *ActionIdNxCt) Serialize(encoder *goloxi.Encoder) error {
994 startIndex := len(encoder.Bytes())
995 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
996 return err
997 }
998 length := len(encoder.Bytes()) - startIndex
999
1000 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1001
1002 return nil
1003}
1004
1005func DecodeActionIdNxCt(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxCt, error) {
1006 _actionidnxct := &ActionIdNxCt{ActionIdNicira: parent}
1007 return _actionidnxct, nil
1008}
1009
1010func NewActionIdNxCt() *ActionIdNxCt {
1011 obj := &ActionIdNxCt{
1012 ActionIdNicira: NewActionIdNicira(35),
1013 }
1014 return obj
1015}
1016
1017type ActionIdNxCtClear struct {
1018 *ActionIdNicira
1019}
1020
1021type IActionIdNxCtClear interface {
1022 IActionIdNicira
1023}
1024
1025func (self *ActionIdNxCtClear) Serialize(encoder *goloxi.Encoder) error {
1026 startIndex := len(encoder.Bytes())
1027 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1028 return err
1029 }
1030 length := len(encoder.Bytes()) - startIndex
1031
1032 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1033
1034 return nil
1035}
1036
1037func DecodeActionIdNxCtClear(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxCtClear, error) {
1038 _actionidnxctclear := &ActionIdNxCtClear{ActionIdNicira: parent}
1039 return _actionidnxctclear, nil
1040}
1041
1042func NewActionIdNxCtClear() *ActionIdNxCtClear {
1043 obj := &ActionIdNxCtClear{
1044 ActionIdNicira: NewActionIdNicira(43),
1045 }
1046 return obj
1047}
1048
1049type ActionIdNxDebugRecirc struct {
1050 *ActionIdNicira
1051}
1052
1053type IActionIdNxDebugRecirc interface {
1054 IActionIdNicira
1055}
1056
1057func (self *ActionIdNxDebugRecirc) Serialize(encoder *goloxi.Encoder) error {
1058 startIndex := len(encoder.Bytes())
1059 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1060 return err
1061 }
1062 length := len(encoder.Bytes()) - startIndex
1063
1064 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1065
1066 return nil
1067}
1068
1069func DecodeActionIdNxDebugRecirc(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxDebugRecirc, error) {
1070 _actionidnxdebugrecirc := &ActionIdNxDebugRecirc{ActionIdNicira: parent}
1071 return _actionidnxdebugrecirc, nil
1072}
1073
1074func NewActionIdNxDebugRecirc() *ActionIdNxDebugRecirc {
1075 obj := &ActionIdNxDebugRecirc{
1076 ActionIdNicira: NewActionIdNicira(255),
1077 }
1078 return obj
1079}
1080
1081type ActionIdNxDebugSlow struct {
1082 *ActionIdNicira
1083}
1084
1085type IActionIdNxDebugSlow interface {
1086 IActionIdNicira
1087}
1088
1089func (self *ActionIdNxDebugSlow) Serialize(encoder *goloxi.Encoder) error {
1090 startIndex := len(encoder.Bytes())
1091 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1092 return err
1093 }
1094 length := len(encoder.Bytes()) - startIndex
1095
1096 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1097
1098 return nil
1099}
1100
1101func DecodeActionIdNxDebugSlow(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxDebugSlow, error) {
1102 _actionidnxdebugslow := &ActionIdNxDebugSlow{ActionIdNicira: parent}
1103 return _actionidnxdebugslow, nil
1104}
1105
1106func NewActionIdNxDebugSlow() *ActionIdNxDebugSlow {
1107 obj := &ActionIdNxDebugSlow{
1108 ActionIdNicira: NewActionIdNicira(254),
1109 }
1110 return obj
1111}
1112
1113type ActionIdNxDecMplsTtl struct {
1114 *ActionIdNicira
1115}
1116
1117type IActionIdNxDecMplsTtl interface {
1118 IActionIdNicira
1119}
1120
1121func (self *ActionIdNxDecMplsTtl) Serialize(encoder *goloxi.Encoder) error {
1122 startIndex := len(encoder.Bytes())
1123 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1124 return err
1125 }
1126 length := len(encoder.Bytes()) - startIndex
1127
1128 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1129
1130 return nil
1131}
1132
1133func DecodeActionIdNxDecMplsTtl(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxDecMplsTtl, error) {
1134 _actionidnxdecmplsttl := &ActionIdNxDecMplsTtl{ActionIdNicira: parent}
1135 return _actionidnxdecmplsttl, nil
1136}
1137
1138func NewActionIdNxDecMplsTtl() *ActionIdNxDecMplsTtl {
1139 obj := &ActionIdNxDecMplsTtl{
1140 ActionIdNicira: NewActionIdNicira(26),
1141 }
1142 return obj
1143}
1144
1145type ActionIdNxDecNshTtl struct {
1146 *ActionIdNicira
1147}
1148
1149type IActionIdNxDecNshTtl interface {
1150 IActionIdNicira
1151}
1152
1153func (self *ActionIdNxDecNshTtl) Serialize(encoder *goloxi.Encoder) error {
1154 startIndex := len(encoder.Bytes())
1155 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1156 return err
1157 }
1158 length := len(encoder.Bytes()) - startIndex
1159
1160 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1161
1162 return nil
1163}
1164
1165func DecodeActionIdNxDecNshTtl(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxDecNshTtl, error) {
1166 _actionidnxdecnshttl := &ActionIdNxDecNshTtl{ActionIdNicira: parent}
1167 return _actionidnxdecnshttl, nil
1168}
1169
1170func NewActionIdNxDecNshTtl() *ActionIdNxDecNshTtl {
1171 obj := &ActionIdNxDecNshTtl{
1172 ActionIdNicira: NewActionIdNicira(48),
1173 }
1174 return obj
1175}
1176
1177type ActionIdNxDecTtlCntIds struct {
1178 *ActionIdNicira
1179}
1180
1181type IActionIdNxDecTtlCntIds interface {
1182 IActionIdNicira
1183}
1184
1185func (self *ActionIdNxDecTtlCntIds) Serialize(encoder *goloxi.Encoder) error {
1186 startIndex := len(encoder.Bytes())
1187 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1188 return err
1189 }
1190 length := len(encoder.Bytes()) - startIndex
1191
1192 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1193
1194 return nil
1195}
1196
1197func DecodeActionIdNxDecTtlCntIds(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxDecTtlCntIds, error) {
1198 _actionidnxdecttlcntids := &ActionIdNxDecTtlCntIds{ActionIdNicira: parent}
1199 return _actionidnxdecttlcntids, nil
1200}
1201
1202func NewActionIdNxDecTtlCntIds() *ActionIdNxDecTtlCntIds {
1203 obj := &ActionIdNxDecTtlCntIds{
1204 ActionIdNicira: NewActionIdNicira(21),
1205 }
1206 return obj
1207}
1208
1209type ActionIdNxDecap struct {
1210 *ActionIdNicira
1211}
1212
1213type IActionIdNxDecap interface {
1214 IActionIdNicira
1215}
1216
1217func (self *ActionIdNxDecap) Serialize(encoder *goloxi.Encoder) error {
1218 startIndex := len(encoder.Bytes())
1219 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1220 return err
1221 }
1222 length := len(encoder.Bytes()) - startIndex
1223
1224 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1225
1226 return nil
1227}
1228
1229func DecodeActionIdNxDecap(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxDecap, error) {
1230 _actionidnxdecap := &ActionIdNxDecap{ActionIdNicira: parent}
1231 return _actionidnxdecap, nil
1232}
1233
1234func NewActionIdNxDecap() *ActionIdNxDecap {
1235 obj := &ActionIdNxDecap{
1236 ActionIdNicira: NewActionIdNicira(47),
1237 }
1238 return obj
1239}
1240
1241type ActionIdNxEncap struct {
1242 *ActionIdNicira
1243}
1244
1245type IActionIdNxEncap interface {
1246 IActionIdNicira
1247}
1248
1249func (self *ActionIdNxEncap) Serialize(encoder *goloxi.Encoder) error {
1250 startIndex := len(encoder.Bytes())
1251 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1252 return err
1253 }
1254 length := len(encoder.Bytes()) - startIndex
1255
1256 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1257
1258 return nil
1259}
1260
1261func DecodeActionIdNxEncap(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxEncap, error) {
1262 _actionidnxencap := &ActionIdNxEncap{ActionIdNicira: parent}
1263 return _actionidnxencap, nil
1264}
1265
1266func NewActionIdNxEncap() *ActionIdNxEncap {
1267 obj := &ActionIdNxEncap{
1268 ActionIdNicira: NewActionIdNicira(46),
1269 }
1270 return obj
1271}
1272
1273type ActionIdNxExit struct {
1274 *ActionIdNicira
1275}
1276
1277type IActionIdNxExit interface {
1278 IActionIdNicira
1279}
1280
1281func (self *ActionIdNxExit) Serialize(encoder *goloxi.Encoder) error {
1282 startIndex := len(encoder.Bytes())
1283 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1284 return err
1285 }
1286 length := len(encoder.Bytes()) - startIndex
1287
1288 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1289
1290 return nil
1291}
1292
1293func DecodeActionIdNxExit(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxExit, error) {
1294 _actionidnxexit := &ActionIdNxExit{ActionIdNicira: parent}
1295 return _actionidnxexit, nil
1296}
1297
1298func NewActionIdNxExit() *ActionIdNxExit {
1299 obj := &ActionIdNxExit{
1300 ActionIdNicira: NewActionIdNicira(17),
1301 }
1302 return obj
1303}
1304
1305type ActionIdNxFinTimeout struct {
1306 *ActionIdNicira
1307}
1308
1309type IActionIdNxFinTimeout interface {
1310 IActionIdNicira
1311}
1312
1313func (self *ActionIdNxFinTimeout) Serialize(encoder *goloxi.Encoder) error {
1314 startIndex := len(encoder.Bytes())
1315 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1316 return err
1317 }
1318 length := len(encoder.Bytes()) - startIndex
1319
1320 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1321
1322 return nil
1323}
1324
1325func DecodeActionIdNxFinTimeout(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxFinTimeout, error) {
1326 _actionidnxfintimeout := &ActionIdNxFinTimeout{ActionIdNicira: parent}
1327 return _actionidnxfintimeout, nil
1328}
1329
1330func NewActionIdNxFinTimeout() *ActionIdNxFinTimeout {
1331 obj := &ActionIdNxFinTimeout{
1332 ActionIdNicira: NewActionIdNicira(19),
1333 }
1334 return obj
1335}
1336
1337type ActionIdNxGroup struct {
1338 *ActionIdNicira
1339}
1340
1341type IActionIdNxGroup interface {
1342 IActionIdNicira
1343}
1344
1345func (self *ActionIdNxGroup) Serialize(encoder *goloxi.Encoder) error {
1346 startIndex := len(encoder.Bytes())
1347 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1348 return err
1349 }
1350 length := len(encoder.Bytes()) - startIndex
1351
1352 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1353
1354 return nil
1355}
1356
1357func DecodeActionIdNxGroup(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxGroup, error) {
1358 _actionidnxgroup := &ActionIdNxGroup{ActionIdNicira: parent}
1359 return _actionidnxgroup, nil
1360}
1361
1362func NewActionIdNxGroup() *ActionIdNxGroup {
1363 obj := &ActionIdNxGroup{
1364 ActionIdNicira: NewActionIdNicira(40),
1365 }
1366 return obj
1367}
1368
1369type ActionIdNxLearn struct {
1370 *ActionIdNicira
1371}
1372
1373type IActionIdNxLearn interface {
1374 IActionIdNicira
1375}
1376
1377func (self *ActionIdNxLearn) Serialize(encoder *goloxi.Encoder) error {
1378 startIndex := len(encoder.Bytes())
1379 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1380 return err
1381 }
1382 length := len(encoder.Bytes()) - startIndex
1383
1384 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1385
1386 return nil
1387}
1388
1389func DecodeActionIdNxLearn(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxLearn, error) {
1390 _actionidnxlearn := &ActionIdNxLearn{ActionIdNicira: parent}
1391 return _actionidnxlearn, nil
1392}
1393
1394func NewActionIdNxLearn() *ActionIdNxLearn {
1395 obj := &ActionIdNxLearn{
1396 ActionIdNicira: NewActionIdNicira(16),
1397 }
1398 return obj
1399}
1400
1401type ActionIdNxLearn2 struct {
1402 *ActionIdNicira
1403}
1404
1405type IActionIdNxLearn2 interface {
1406 IActionIdNicira
1407}
1408
1409func (self *ActionIdNxLearn2) Serialize(encoder *goloxi.Encoder) error {
1410 startIndex := len(encoder.Bytes())
1411 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1412 return err
1413 }
1414 length := len(encoder.Bytes()) - startIndex
1415
1416 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1417
1418 return nil
1419}
1420
1421func DecodeActionIdNxLearn2(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxLearn2, error) {
1422 _actionidnxlearn2 := &ActionIdNxLearn2{ActionIdNicira: parent}
1423 return _actionidnxlearn2, nil
1424}
1425
1426func NewActionIdNxLearn2() *ActionIdNxLearn2 {
1427 obj := &ActionIdNxLearn2{
1428 ActionIdNicira: NewActionIdNicira(45),
1429 }
1430 return obj
1431}
1432
1433type ActionIdNxMultipath struct {
1434 *ActionIdNicira
1435}
1436
1437type IActionIdNxMultipath interface {
1438 IActionIdNicira
1439}
1440
1441func (self *ActionIdNxMultipath) Serialize(encoder *goloxi.Encoder) error {
1442 startIndex := len(encoder.Bytes())
1443 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1444 return err
1445 }
1446 length := len(encoder.Bytes()) - startIndex
1447
1448 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1449
1450 return nil
1451}
1452
1453func DecodeActionIdNxMultipath(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxMultipath, error) {
1454 _actionidnxmultipath := &ActionIdNxMultipath{ActionIdNicira: parent}
1455 return _actionidnxmultipath, nil
1456}
1457
1458func NewActionIdNxMultipath() *ActionIdNxMultipath {
1459 obj := &ActionIdNxMultipath{
1460 ActionIdNicira: NewActionIdNicira(10),
1461 }
1462 return obj
1463}
1464
1465type ActionIdNxNat struct {
1466 *ActionIdNicira
1467}
1468
1469type IActionIdNxNat interface {
1470 IActionIdNicira
1471}
1472
1473func (self *ActionIdNxNat) Serialize(encoder *goloxi.Encoder) error {
1474 startIndex := len(encoder.Bytes())
1475 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1476 return err
1477 }
1478 length := len(encoder.Bytes()) - startIndex
1479
1480 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1481
1482 return nil
1483}
1484
1485func DecodeActionIdNxNat(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxNat, error) {
1486 _actionidnxnat := &ActionIdNxNat{ActionIdNicira: parent}
1487 return _actionidnxnat, nil
1488}
1489
1490func NewActionIdNxNat() *ActionIdNxNat {
1491 obj := &ActionIdNxNat{
1492 ActionIdNicira: NewActionIdNicira(36),
1493 }
1494 return obj
1495}
1496
1497type ActionIdNxNote struct {
1498 *ActionIdNicira
1499}
1500
1501type IActionIdNxNote interface {
1502 IActionIdNicira
1503}
1504
1505func (self *ActionIdNxNote) Serialize(encoder *goloxi.Encoder) error {
1506 startIndex := len(encoder.Bytes())
1507 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1508 return err
1509 }
1510 length := len(encoder.Bytes()) - startIndex
1511
1512 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1513
1514 return nil
1515}
1516
1517func DecodeActionIdNxNote(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxNote, error) {
1518 _actionidnxnote := &ActionIdNxNote{ActionIdNicira: parent}
1519 return _actionidnxnote, nil
1520}
1521
1522func NewActionIdNxNote() *ActionIdNxNote {
1523 obj := &ActionIdNxNote{
1524 ActionIdNicira: NewActionIdNicira(8),
1525 }
1526 return obj
1527}
1528
1529type ActionIdNxOutputReg struct {
1530 *ActionIdNicira
1531}
1532
1533type IActionIdNxOutputReg interface {
1534 IActionIdNicira
1535}
1536
1537func (self *ActionIdNxOutputReg) Serialize(encoder *goloxi.Encoder) error {
1538 startIndex := len(encoder.Bytes())
1539 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1540 return err
1541 }
1542 length := len(encoder.Bytes()) - startIndex
1543
1544 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1545
1546 return nil
1547}
1548
1549func DecodeActionIdNxOutputReg(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxOutputReg, error) {
1550 _actionidnxoutputreg := &ActionIdNxOutputReg{ActionIdNicira: parent}
1551 return _actionidnxoutputreg, nil
1552}
1553
1554func NewActionIdNxOutputReg() *ActionIdNxOutputReg {
1555 obj := &ActionIdNxOutputReg{
1556 ActionIdNicira: NewActionIdNicira(15),
1557 }
1558 return obj
1559}
1560
1561type ActionIdNxOutputReg2 struct {
1562 *ActionIdNicira
1563}
1564
1565type IActionIdNxOutputReg2 interface {
1566 IActionIdNicira
1567}
1568
1569func (self *ActionIdNxOutputReg2) Serialize(encoder *goloxi.Encoder) error {
1570 startIndex := len(encoder.Bytes())
1571 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1572 return err
1573 }
1574 length := len(encoder.Bytes()) - startIndex
1575
1576 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1577
1578 return nil
1579}
1580
1581func DecodeActionIdNxOutputReg2(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxOutputReg2, error) {
1582 _actionidnxoutputreg2 := &ActionIdNxOutputReg2{ActionIdNicira: parent}
1583 return _actionidnxoutputreg2, nil
1584}
1585
1586func NewActionIdNxOutputReg2() *ActionIdNxOutputReg2 {
1587 obj := &ActionIdNxOutputReg2{
1588 ActionIdNicira: NewActionIdNicira(32),
1589 }
1590 return obj
1591}
1592
1593type ActionIdNxOutputTrunc struct {
1594 *ActionIdNicira
1595}
1596
1597type IActionIdNxOutputTrunc interface {
1598 IActionIdNicira
1599}
1600
1601func (self *ActionIdNxOutputTrunc) Serialize(encoder *goloxi.Encoder) error {
1602 startIndex := len(encoder.Bytes())
1603 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1604 return err
1605 }
1606 length := len(encoder.Bytes()) - startIndex
1607
1608 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1609
1610 return nil
1611}
1612
1613func DecodeActionIdNxOutputTrunc(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxOutputTrunc, error) {
1614 _actionidnxoutputtrunc := &ActionIdNxOutputTrunc{ActionIdNicira: parent}
1615 return _actionidnxoutputtrunc, nil
1616}
1617
1618func NewActionIdNxOutputTrunc() *ActionIdNxOutputTrunc {
1619 obj := &ActionIdNxOutputTrunc{
1620 ActionIdNicira: NewActionIdNicira(39),
1621 }
1622 return obj
1623}
1624
1625type ActionIdNxPopMpls struct {
1626 *ActionIdNicira
1627}
1628
1629type IActionIdNxPopMpls interface {
1630 IActionIdNicira
1631}
1632
1633func (self *ActionIdNxPopMpls) Serialize(encoder *goloxi.Encoder) error {
1634 startIndex := len(encoder.Bytes())
1635 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1636 return err
1637 }
1638 length := len(encoder.Bytes()) - startIndex
1639
1640 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1641
1642 return nil
1643}
1644
1645func DecodeActionIdNxPopMpls(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxPopMpls, error) {
1646 _actionidnxpopmpls := &ActionIdNxPopMpls{ActionIdNicira: parent}
1647 return _actionidnxpopmpls, nil
1648}
1649
1650func NewActionIdNxPopMpls() *ActionIdNxPopMpls {
1651 obj := &ActionIdNxPopMpls{
1652 ActionIdNicira: NewActionIdNicira(24),
1653 }
1654 return obj
1655}
1656
1657type ActionIdNxPopQueue struct {
1658 *ActionIdNicira
1659}
1660
1661type IActionIdNxPopQueue interface {
1662 IActionIdNicira
1663}
1664
1665func (self *ActionIdNxPopQueue) Serialize(encoder *goloxi.Encoder) error {
1666 startIndex := len(encoder.Bytes())
1667 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1668 return err
1669 }
1670 length := len(encoder.Bytes()) - startIndex
1671
1672 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1673
1674 return nil
1675}
1676
1677func DecodeActionIdNxPopQueue(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxPopQueue, error) {
1678 _actionidnxpopqueue := &ActionIdNxPopQueue{ActionIdNicira: parent}
1679 return _actionidnxpopqueue, nil
1680}
1681
1682func NewActionIdNxPopQueue() *ActionIdNxPopQueue {
1683 obj := &ActionIdNxPopQueue{
1684 ActionIdNicira: NewActionIdNicira(5),
1685 }
1686 return obj
1687}
1688
1689type ActionIdNxPushMpls struct {
1690 *ActionIdNicira
1691}
1692
1693type IActionIdNxPushMpls interface {
1694 IActionIdNicira
1695}
1696
1697func (self *ActionIdNxPushMpls) Serialize(encoder *goloxi.Encoder) error {
1698 startIndex := len(encoder.Bytes())
1699 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1700 return err
1701 }
1702 length := len(encoder.Bytes()) - startIndex
1703
1704 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1705
1706 return nil
1707}
1708
1709func DecodeActionIdNxPushMpls(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxPushMpls, error) {
1710 _actionidnxpushmpls := &ActionIdNxPushMpls{ActionIdNicira: parent}
1711 return _actionidnxpushmpls, nil
1712}
1713
1714func NewActionIdNxPushMpls() *ActionIdNxPushMpls {
1715 obj := &ActionIdNxPushMpls{
1716 ActionIdNicira: NewActionIdNicira(23),
1717 }
1718 return obj
1719}
1720
1721type ActionIdNxRegLoad struct {
1722 *ActionIdNicira
1723}
1724
1725type IActionIdNxRegLoad interface {
1726 IActionIdNicira
1727}
1728
1729func (self *ActionIdNxRegLoad) Serialize(encoder *goloxi.Encoder) error {
1730 startIndex := len(encoder.Bytes())
1731 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1732 return err
1733 }
1734 length := len(encoder.Bytes()) - startIndex
1735
1736 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1737
1738 return nil
1739}
1740
1741func DecodeActionIdNxRegLoad(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxRegLoad, error) {
1742 _actionidnxregload := &ActionIdNxRegLoad{ActionIdNicira: parent}
1743 return _actionidnxregload, nil
1744}
1745
1746func NewActionIdNxRegLoad() *ActionIdNxRegLoad {
1747 obj := &ActionIdNxRegLoad{
1748 ActionIdNicira: NewActionIdNicira(7),
1749 }
1750 return obj
1751}
1752
1753type ActionIdNxRegLoad2 struct {
1754 *ActionIdNicira
1755}
1756
1757type IActionIdNxRegLoad2 interface {
1758 IActionIdNicira
1759}
1760
1761func (self *ActionIdNxRegLoad2) Serialize(encoder *goloxi.Encoder) error {
1762 startIndex := len(encoder.Bytes())
1763 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1764 return err
1765 }
1766 length := len(encoder.Bytes()) - startIndex
1767
1768 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1769
1770 return nil
1771}
1772
1773func DecodeActionIdNxRegLoad2(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxRegLoad2, error) {
1774 _actionidnxregload2 := &ActionIdNxRegLoad2{ActionIdNicira: parent}
1775 return _actionidnxregload2, nil
1776}
1777
1778func NewActionIdNxRegLoad2() *ActionIdNxRegLoad2 {
1779 obj := &ActionIdNxRegLoad2{
1780 ActionIdNicira: NewActionIdNicira(33),
1781 }
1782 return obj
1783}
1784
1785type ActionIdNxRegMove struct {
1786 *ActionIdNicira
1787}
1788
1789type IActionIdNxRegMove interface {
1790 IActionIdNicira
1791}
1792
1793func (self *ActionIdNxRegMove) Serialize(encoder *goloxi.Encoder) error {
1794 startIndex := len(encoder.Bytes())
1795 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1796 return err
1797 }
1798 length := len(encoder.Bytes()) - startIndex
1799
1800 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1801
1802 return nil
1803}
1804
1805func DecodeActionIdNxRegMove(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxRegMove, error) {
1806 _actionidnxregmove := &ActionIdNxRegMove{ActionIdNicira: parent}
1807 return _actionidnxregmove, nil
1808}
1809
1810func NewActionIdNxRegMove() *ActionIdNxRegMove {
1811 obj := &ActionIdNxRegMove{
1812 ActionIdNicira: NewActionIdNicira(6),
1813 }
1814 return obj
1815}
1816
1817type ActionIdNxResubmit struct {
1818 *ActionIdNicira
1819}
1820
1821type IActionIdNxResubmit interface {
1822 IActionIdNicira
1823}
1824
1825func (self *ActionIdNxResubmit) Serialize(encoder *goloxi.Encoder) error {
1826 startIndex := len(encoder.Bytes())
1827 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1828 return err
1829 }
1830 length := len(encoder.Bytes()) - startIndex
1831
1832 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1833
1834 return nil
1835}
1836
1837func DecodeActionIdNxResubmit(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxResubmit, error) {
1838 _actionidnxresubmit := &ActionIdNxResubmit{ActionIdNicira: parent}
1839 return _actionidnxresubmit, nil
1840}
1841
1842func NewActionIdNxResubmit() *ActionIdNxResubmit {
1843 obj := &ActionIdNxResubmit{
1844 ActionIdNicira: NewActionIdNicira(1),
1845 }
1846 return obj
1847}
1848
1849type ActionIdNxResubmitTable struct {
1850 *ActionIdNicira
1851}
1852
1853type IActionIdNxResubmitTable interface {
1854 IActionIdNicira
1855}
1856
1857func (self *ActionIdNxResubmitTable) Serialize(encoder *goloxi.Encoder) error {
1858 startIndex := len(encoder.Bytes())
1859 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1860 return err
1861 }
1862 length := len(encoder.Bytes()) - startIndex
1863
1864 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1865
1866 return nil
1867}
1868
1869func DecodeActionIdNxResubmitTable(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxResubmitTable, error) {
1870 _actionidnxresubmittable := &ActionIdNxResubmitTable{ActionIdNicira: parent}
1871 return _actionidnxresubmittable, nil
1872}
1873
1874func NewActionIdNxResubmitTable() *ActionIdNxResubmitTable {
1875 obj := &ActionIdNxResubmitTable{
1876 ActionIdNicira: NewActionIdNicira(14),
1877 }
1878 return obj
1879}
1880
1881type ActionIdNxResubmitTableCt struct {
1882 *ActionIdNicira
1883}
1884
1885type IActionIdNxResubmitTableCt interface {
1886 IActionIdNicira
1887}
1888
1889func (self *ActionIdNxResubmitTableCt) Serialize(encoder *goloxi.Encoder) error {
1890 startIndex := len(encoder.Bytes())
1891 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1892 return err
1893 }
1894 length := len(encoder.Bytes()) - startIndex
1895
1896 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1897
1898 return nil
1899}
1900
1901func DecodeActionIdNxResubmitTableCt(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxResubmitTableCt, error) {
1902 _actionidnxresubmittablect := &ActionIdNxResubmitTableCt{ActionIdNicira: parent}
1903 return _actionidnxresubmittablect, nil
1904}
1905
1906func NewActionIdNxResubmitTableCt() *ActionIdNxResubmitTableCt {
1907 obj := &ActionIdNxResubmitTableCt{
1908 ActionIdNicira: NewActionIdNicira(44),
1909 }
1910 return obj
1911}
1912
1913type ActionIdNxSample struct {
1914 *ActionIdNicira
1915}
1916
1917type IActionIdNxSample interface {
1918 IActionIdNicira
1919}
1920
1921func (self *ActionIdNxSample) Serialize(encoder *goloxi.Encoder) error {
1922 startIndex := len(encoder.Bytes())
1923 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1924 return err
1925 }
1926 length := len(encoder.Bytes()) - startIndex
1927
1928 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1929
1930 return nil
1931}
1932
1933func DecodeActionIdNxSample(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxSample, error) {
1934 _actionidnxsample := &ActionIdNxSample{ActionIdNicira: parent}
1935 return _actionidnxsample, nil
1936}
1937
1938func NewActionIdNxSample() *ActionIdNxSample {
1939 obj := &ActionIdNxSample{
1940 ActionIdNicira: NewActionIdNicira(29),
1941 }
1942 return obj
1943}
1944
1945type ActionIdNxSample2 struct {
1946 *ActionIdNicira
1947}
1948
1949type IActionIdNxSample2 interface {
1950 IActionIdNicira
1951}
1952
1953func (self *ActionIdNxSample2) Serialize(encoder *goloxi.Encoder) error {
1954 startIndex := len(encoder.Bytes())
1955 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1956 return err
1957 }
1958 length := len(encoder.Bytes()) - startIndex
1959
1960 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1961
1962 return nil
1963}
1964
1965func DecodeActionIdNxSample2(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxSample2, error) {
1966 _actionidnxsample2 := &ActionIdNxSample2{ActionIdNicira: parent}
1967 return _actionidnxsample2, nil
1968}
1969
1970func NewActionIdNxSample2() *ActionIdNxSample2 {
1971 obj := &ActionIdNxSample2{
1972 ActionIdNicira: NewActionIdNicira(38),
1973 }
1974 return obj
1975}
1976
1977type ActionIdNxSample3 struct {
1978 *ActionIdNicira
1979}
1980
1981type IActionIdNxSample3 interface {
1982 IActionIdNicira
1983}
1984
1985func (self *ActionIdNxSample3) Serialize(encoder *goloxi.Encoder) error {
1986 startIndex := len(encoder.Bytes())
1987 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
1988 return err
1989 }
1990 length := len(encoder.Bytes()) - startIndex
1991
1992 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1993
1994 return nil
1995}
1996
1997func DecodeActionIdNxSample3(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxSample3, error) {
1998 _actionidnxsample3 := &ActionIdNxSample3{ActionIdNicira: parent}
1999 return _actionidnxsample3, nil
2000}
2001
2002func NewActionIdNxSample3() *ActionIdNxSample3 {
2003 obj := &ActionIdNxSample3{
2004 ActionIdNicira: NewActionIdNicira(41),
2005 }
2006 return obj
2007}
2008
2009type ActionIdNxSetMplsLabel struct {
2010 *ActionIdNicira
2011}
2012
2013type IActionIdNxSetMplsLabel interface {
2014 IActionIdNicira
2015}
2016
2017func (self *ActionIdNxSetMplsLabel) Serialize(encoder *goloxi.Encoder) error {
2018 startIndex := len(encoder.Bytes())
2019 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
2020 return err
2021 }
2022 length := len(encoder.Bytes()) - startIndex
2023
2024 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2025
2026 return nil
2027}
2028
2029func DecodeActionIdNxSetMplsLabel(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxSetMplsLabel, error) {
2030 _actionidnxsetmplslabel := &ActionIdNxSetMplsLabel{ActionIdNicira: parent}
2031 return _actionidnxsetmplslabel, nil
2032}
2033
2034func NewActionIdNxSetMplsLabel() *ActionIdNxSetMplsLabel {
2035 obj := &ActionIdNxSetMplsLabel{
2036 ActionIdNicira: NewActionIdNicira(30),
2037 }
2038 return obj
2039}
2040
2041type ActionIdNxSetMplsTc struct {
2042 *ActionIdNicira
2043}
2044
2045type IActionIdNxSetMplsTc interface {
2046 IActionIdNicira
2047}
2048
2049func (self *ActionIdNxSetMplsTc) Serialize(encoder *goloxi.Encoder) error {
2050 startIndex := len(encoder.Bytes())
2051 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
2052 return err
2053 }
2054 length := len(encoder.Bytes()) - startIndex
2055
2056 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2057
2058 return nil
2059}
2060
2061func DecodeActionIdNxSetMplsTc(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxSetMplsTc, error) {
2062 _actionidnxsetmplstc := &ActionIdNxSetMplsTc{ActionIdNicira: parent}
2063 return _actionidnxsetmplstc, nil
2064}
2065
2066func NewActionIdNxSetMplsTc() *ActionIdNxSetMplsTc {
2067 obj := &ActionIdNxSetMplsTc{
2068 ActionIdNicira: NewActionIdNicira(31),
2069 }
2070 return obj
2071}
2072
2073type ActionIdNxSetMplsTtl struct {
2074 *ActionIdNicira
2075}
2076
2077type IActionIdNxSetMplsTtl interface {
2078 IActionIdNicira
2079}
2080
2081func (self *ActionIdNxSetMplsTtl) Serialize(encoder *goloxi.Encoder) error {
2082 startIndex := len(encoder.Bytes())
2083 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
2084 return err
2085 }
2086 length := len(encoder.Bytes()) - startIndex
2087
2088 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2089
2090 return nil
2091}
2092
2093func DecodeActionIdNxSetMplsTtl(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxSetMplsTtl, error) {
2094 _actionidnxsetmplsttl := &ActionIdNxSetMplsTtl{ActionIdNicira: parent}
2095 return _actionidnxsetmplsttl, nil
2096}
2097
2098func NewActionIdNxSetMplsTtl() *ActionIdNxSetMplsTtl {
2099 obj := &ActionIdNxSetMplsTtl{
2100 ActionIdNicira: NewActionIdNicira(25),
2101 }
2102 return obj
2103}
2104
2105type ActionIdNxSetQueue struct {
2106 *ActionIdNicira
2107}
2108
2109type IActionIdNxSetQueue interface {
2110 IActionIdNicira
2111}
2112
2113func (self *ActionIdNxSetQueue) Serialize(encoder *goloxi.Encoder) error {
2114 startIndex := len(encoder.Bytes())
2115 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
2116 return err
2117 }
2118 length := len(encoder.Bytes()) - startIndex
2119
2120 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2121
2122 return nil
2123}
2124
2125func DecodeActionIdNxSetQueue(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxSetQueue, error) {
2126 _actionidnxsetqueue := &ActionIdNxSetQueue{ActionIdNicira: parent}
2127 return _actionidnxsetqueue, nil
2128}
2129
2130func NewActionIdNxSetQueue() *ActionIdNxSetQueue {
2131 obj := &ActionIdNxSetQueue{
2132 ActionIdNicira: NewActionIdNicira(4),
2133 }
2134 return obj
2135}
2136
2137type ActionIdNxSetTunnel struct {
2138 *ActionIdNicira
2139}
2140
2141type IActionIdNxSetTunnel interface {
2142 IActionIdNicira
2143}
2144
2145func (self *ActionIdNxSetTunnel) Serialize(encoder *goloxi.Encoder) error {
2146 startIndex := len(encoder.Bytes())
2147 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
2148 return err
2149 }
2150 length := len(encoder.Bytes()) - startIndex
2151
2152 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2153
2154 return nil
2155}
2156
2157func DecodeActionIdNxSetTunnel(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxSetTunnel, error) {
2158 _actionidnxsettunnel := &ActionIdNxSetTunnel{ActionIdNicira: parent}
2159 return _actionidnxsettunnel, nil
2160}
2161
2162func NewActionIdNxSetTunnel() *ActionIdNxSetTunnel {
2163 obj := &ActionIdNxSetTunnel{
2164 ActionIdNicira: NewActionIdNicira(2),
2165 }
2166 return obj
2167}
2168
2169type ActionIdNxSetTunnel64 struct {
2170 *ActionIdNicira
2171}
2172
2173type IActionIdNxSetTunnel64 interface {
2174 IActionIdNicira
2175}
2176
2177func (self *ActionIdNxSetTunnel64) Serialize(encoder *goloxi.Encoder) error {
2178 startIndex := len(encoder.Bytes())
2179 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
2180 return err
2181 }
2182 length := len(encoder.Bytes()) - startIndex
2183
2184 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2185
2186 return nil
2187}
2188
2189func DecodeActionIdNxSetTunnel64(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxSetTunnel64, error) {
2190 _actionidnxsettunnel64 := &ActionIdNxSetTunnel64{ActionIdNicira: parent}
2191 return _actionidnxsettunnel64, nil
2192}
2193
2194func NewActionIdNxSetTunnel64() *ActionIdNxSetTunnel64 {
2195 obj := &ActionIdNxSetTunnel64{
2196 ActionIdNicira: NewActionIdNicira(9),
2197 }
2198 return obj
2199}
2200
2201type ActionIdNxStackPop struct {
2202 *ActionIdNicira
2203}
2204
2205type IActionIdNxStackPop interface {
2206 IActionIdNicira
2207}
2208
2209func (self *ActionIdNxStackPop) Serialize(encoder *goloxi.Encoder) error {
2210 startIndex := len(encoder.Bytes())
2211 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
2212 return err
2213 }
2214 length := len(encoder.Bytes()) - startIndex
2215
2216 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2217
2218 return nil
2219}
2220
2221func DecodeActionIdNxStackPop(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxStackPop, error) {
2222 _actionidnxstackpop := &ActionIdNxStackPop{ActionIdNicira: parent}
2223 return _actionidnxstackpop, nil
2224}
2225
2226func NewActionIdNxStackPop() *ActionIdNxStackPop {
2227 obj := &ActionIdNxStackPop{
2228 ActionIdNicira: NewActionIdNicira(28),
2229 }
2230 return obj
2231}
2232
2233type ActionIdNxStackPush struct {
2234 *ActionIdNicira
2235}
2236
2237type IActionIdNxStackPush interface {
2238 IActionIdNicira
2239}
2240
2241func (self *ActionIdNxStackPush) Serialize(encoder *goloxi.Encoder) error {
2242 startIndex := len(encoder.Bytes())
2243 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
2244 return err
2245 }
2246 length := len(encoder.Bytes()) - startIndex
2247
2248 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2249
2250 return nil
2251}
2252
2253func DecodeActionIdNxStackPush(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxStackPush, error) {
2254 _actionidnxstackpush := &ActionIdNxStackPush{ActionIdNicira: parent}
2255 return _actionidnxstackpush, nil
2256}
2257
2258func NewActionIdNxStackPush() *ActionIdNxStackPush {
2259 obj := &ActionIdNxStackPush{
2260 ActionIdNicira: NewActionIdNicira(27),
2261 }
2262 return obj
2263}
2264
2265type ActionIdNxWriteMetadata struct {
2266 *ActionIdNicira
2267}
2268
2269type IActionIdNxWriteMetadata interface {
2270 IActionIdNicira
2271}
2272
2273func (self *ActionIdNxWriteMetadata) Serialize(encoder *goloxi.Encoder) error {
2274 startIndex := len(encoder.Bytes())
2275 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
2276 return err
2277 }
2278 length := len(encoder.Bytes()) - startIndex
2279
2280 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2281
2282 return nil
2283}
2284
2285func DecodeActionIdNxWriteMetadata(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdNxWriteMetadata, error) {
2286 _actionidnxwritemetadata := &ActionIdNxWriteMetadata{ActionIdNicira: parent}
2287 return _actionidnxwritemetadata, nil
2288}
2289
2290func NewActionIdNxWriteMetadata() *ActionIdNxWriteMetadata {
2291 obj := &ActionIdNxWriteMetadata{
2292 ActionIdNicira: NewActionIdNicira(22),
2293 }
2294 return obj
2295}
2296
2297type ActionIdOutput struct {
2298 *ActionId
2299}
2300
2301type IActionIdOutput interface {
2302 IActionId
2303}
2304
2305func (self *ActionIdOutput) Serialize(encoder *goloxi.Encoder) error {
2306 startIndex := len(encoder.Bytes())
2307 if err := self.ActionId.Serialize(encoder); err != nil {
2308 return err
2309 }
2310 length := len(encoder.Bytes()) - startIndex
2311
2312 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2313
2314 return nil
2315}
2316
2317func DecodeActionIdOutput(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdOutput, error) {
2318 _actionidoutput := &ActionIdOutput{ActionId: parent}
2319 return _actionidoutput, nil
2320}
2321
2322func NewActionIdOutput() *ActionIdOutput {
2323 obj := &ActionIdOutput{
2324 ActionId: NewActionId(0),
2325 }
2326 return obj
2327}
2328
2329type ActionIdPopMpls struct {
2330 *ActionId
2331}
2332
2333type IActionIdPopMpls interface {
2334 IActionId
2335}
2336
2337func (self *ActionIdPopMpls) Serialize(encoder *goloxi.Encoder) error {
2338 startIndex := len(encoder.Bytes())
2339 if err := self.ActionId.Serialize(encoder); err != nil {
2340 return err
2341 }
2342 length := len(encoder.Bytes()) - startIndex
2343
2344 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2345
2346 return nil
2347}
2348
2349func DecodeActionIdPopMpls(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdPopMpls, error) {
2350 _actionidpopmpls := &ActionIdPopMpls{ActionId: parent}
2351 return _actionidpopmpls, nil
2352}
2353
2354func NewActionIdPopMpls() *ActionIdPopMpls {
2355 obj := &ActionIdPopMpls{
2356 ActionId: NewActionId(20),
2357 }
2358 return obj
2359}
2360
2361type ActionIdPopPbb struct {
2362 *ActionId
2363}
2364
2365type IActionIdPopPbb interface {
2366 IActionId
2367}
2368
2369func (self *ActionIdPopPbb) Serialize(encoder *goloxi.Encoder) error {
2370 startIndex := len(encoder.Bytes())
2371 if err := self.ActionId.Serialize(encoder); err != nil {
2372 return err
2373 }
2374 length := len(encoder.Bytes()) - startIndex
2375
2376 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2377
2378 return nil
2379}
2380
2381func DecodeActionIdPopPbb(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdPopPbb, error) {
2382 _actionidpoppbb := &ActionIdPopPbb{ActionId: parent}
2383 return _actionidpoppbb, nil
2384}
2385
2386func NewActionIdPopPbb() *ActionIdPopPbb {
2387 obj := &ActionIdPopPbb{
2388 ActionId: NewActionId(27),
2389 }
2390 return obj
2391}
2392
2393type ActionIdPopVlan struct {
2394 *ActionId
2395}
2396
2397type IActionIdPopVlan interface {
2398 IActionId
2399}
2400
2401func (self *ActionIdPopVlan) Serialize(encoder *goloxi.Encoder) error {
2402 startIndex := len(encoder.Bytes())
2403 if err := self.ActionId.Serialize(encoder); err != nil {
2404 return err
2405 }
2406 length := len(encoder.Bytes()) - startIndex
2407
2408 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2409
2410 return nil
2411}
2412
2413func DecodeActionIdPopVlan(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdPopVlan, error) {
2414 _actionidpopvlan := &ActionIdPopVlan{ActionId: parent}
2415 return _actionidpopvlan, nil
2416}
2417
2418func NewActionIdPopVlan() *ActionIdPopVlan {
2419 obj := &ActionIdPopVlan{
2420 ActionId: NewActionId(18),
2421 }
2422 return obj
2423}
2424
2425type ActionIdPushMpls struct {
2426 *ActionId
2427}
2428
2429type IActionIdPushMpls interface {
2430 IActionId
2431}
2432
2433func (self *ActionIdPushMpls) Serialize(encoder *goloxi.Encoder) error {
2434 startIndex := len(encoder.Bytes())
2435 if err := self.ActionId.Serialize(encoder); err != nil {
2436 return err
2437 }
2438 length := len(encoder.Bytes()) - startIndex
2439
2440 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2441
2442 return nil
2443}
2444
2445func DecodeActionIdPushMpls(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdPushMpls, error) {
2446 _actionidpushmpls := &ActionIdPushMpls{ActionId: parent}
2447 return _actionidpushmpls, nil
2448}
2449
2450func NewActionIdPushMpls() *ActionIdPushMpls {
2451 obj := &ActionIdPushMpls{
2452 ActionId: NewActionId(19),
2453 }
2454 return obj
2455}
2456
2457type ActionIdPushPbb struct {
2458 *ActionId
2459}
2460
2461type IActionIdPushPbb interface {
2462 IActionId
2463}
2464
2465func (self *ActionIdPushPbb) Serialize(encoder *goloxi.Encoder) error {
2466 startIndex := len(encoder.Bytes())
2467 if err := self.ActionId.Serialize(encoder); err != nil {
2468 return err
2469 }
2470 length := len(encoder.Bytes()) - startIndex
2471
2472 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2473
2474 return nil
2475}
2476
2477func DecodeActionIdPushPbb(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdPushPbb, error) {
2478 _actionidpushpbb := &ActionIdPushPbb{ActionId: parent}
2479 return _actionidpushpbb, nil
2480}
2481
2482func NewActionIdPushPbb() *ActionIdPushPbb {
2483 obj := &ActionIdPushPbb{
2484 ActionId: NewActionId(26),
2485 }
2486 return obj
2487}
2488
2489type ActionIdPushVlan struct {
2490 *ActionId
2491}
2492
2493type IActionIdPushVlan interface {
2494 IActionId
2495}
2496
2497func (self *ActionIdPushVlan) Serialize(encoder *goloxi.Encoder) error {
2498 startIndex := len(encoder.Bytes())
2499 if err := self.ActionId.Serialize(encoder); err != nil {
2500 return err
2501 }
2502 length := len(encoder.Bytes()) - startIndex
2503
2504 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2505
2506 return nil
2507}
2508
2509func DecodeActionIdPushVlan(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdPushVlan, error) {
2510 _actionidpushvlan := &ActionIdPushVlan{ActionId: parent}
2511 return _actionidpushvlan, nil
2512}
2513
2514func NewActionIdPushVlan() *ActionIdPushVlan {
2515 obj := &ActionIdPushVlan{
2516 ActionId: NewActionId(17),
2517 }
2518 return obj
2519}
2520
2521type ActionIdResubmit struct {
2522 *ActionIdNicira
2523}
2524
2525type IActionIdResubmit interface {
2526 IActionIdNicira
2527}
2528
2529func (self *ActionIdResubmit) Serialize(encoder *goloxi.Encoder) error {
2530 startIndex := len(encoder.Bytes())
2531 if err := self.ActionIdNicira.Serialize(encoder); err != nil {
2532 return err
2533 }
2534 length := len(encoder.Bytes()) - startIndex
2535
2536 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2537
2538 return nil
2539}
2540
2541func DecodeActionIdResubmit(parent *ActionIdNicira, decoder *goloxi.Decoder) (*ActionIdResubmit, error) {
2542 _actionidresubmit := &ActionIdResubmit{ActionIdNicira: parent}
2543 return _actionidresubmit, nil
2544}
2545
2546func NewActionIdResubmit() *ActionIdResubmit {
2547 obj := &ActionIdResubmit{
2548 ActionIdNicira: NewActionIdNicira(14),
2549 }
2550 return obj
2551}
2552
2553type ActionIdSetField struct {
2554 *ActionId
2555}
2556
2557type IActionIdSetField interface {
2558 IActionId
2559}
2560
2561func (self *ActionIdSetField) Serialize(encoder *goloxi.Encoder) error {
2562 startIndex := len(encoder.Bytes())
2563 if err := self.ActionId.Serialize(encoder); err != nil {
2564 return err
2565 }
2566 length := len(encoder.Bytes()) - startIndex
2567
2568 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2569
2570 return nil
2571}
2572
2573func DecodeActionIdSetField(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdSetField, error) {
2574 _actionidsetfield := &ActionIdSetField{ActionId: parent}
2575 return _actionidsetfield, nil
2576}
2577
2578func NewActionIdSetField() *ActionIdSetField {
2579 obj := &ActionIdSetField{
2580 ActionId: NewActionId(25),
2581 }
2582 return obj
2583}
2584
2585type ActionIdSetMplsTtl struct {
2586 *ActionId
2587}
2588
2589type IActionIdSetMplsTtl interface {
2590 IActionId
2591}
2592
2593func (self *ActionIdSetMplsTtl) Serialize(encoder *goloxi.Encoder) error {
2594 startIndex := len(encoder.Bytes())
2595 if err := self.ActionId.Serialize(encoder); err != nil {
2596 return err
2597 }
2598 length := len(encoder.Bytes()) - startIndex
2599
2600 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2601
2602 return nil
2603}
2604
2605func DecodeActionIdSetMplsTtl(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdSetMplsTtl, error) {
2606 _actionidsetmplsttl := &ActionIdSetMplsTtl{ActionId: parent}
2607 return _actionidsetmplsttl, nil
2608}
2609
2610func NewActionIdSetMplsTtl() *ActionIdSetMplsTtl {
2611 obj := &ActionIdSetMplsTtl{
2612 ActionId: NewActionId(15),
2613 }
2614 return obj
2615}
2616
2617type ActionIdSetNwTtl struct {
2618 *ActionId
2619}
2620
2621type IActionIdSetNwTtl interface {
2622 IActionId
2623}
2624
2625func (self *ActionIdSetNwTtl) Serialize(encoder *goloxi.Encoder) error {
2626 startIndex := len(encoder.Bytes())
2627 if err := self.ActionId.Serialize(encoder); err != nil {
2628 return err
2629 }
2630 length := len(encoder.Bytes()) - startIndex
2631
2632 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2633
2634 return nil
2635}
2636
2637func DecodeActionIdSetNwTtl(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdSetNwTtl, error) {
2638 _actionidsetnwttl := &ActionIdSetNwTtl{ActionId: parent}
2639 return _actionidsetnwttl, nil
2640}
2641
2642func NewActionIdSetNwTtl() *ActionIdSetNwTtl {
2643 obj := &ActionIdSetNwTtl{
2644 ActionId: NewActionId(23),
2645 }
2646 return obj
2647}
2648
2649type ActionIdSetQueue struct {
2650 *ActionId
2651}
2652
2653type IActionIdSetQueue interface {
2654 IActionId
2655}
2656
2657func (self *ActionIdSetQueue) Serialize(encoder *goloxi.Encoder) error {
2658 startIndex := len(encoder.Bytes())
2659 if err := self.ActionId.Serialize(encoder); err != nil {
2660 return err
2661 }
2662 length := len(encoder.Bytes()) - startIndex
2663
2664 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2665
2666 return nil
2667}
2668
2669func DecodeActionIdSetQueue(parent *ActionId, decoder *goloxi.Decoder) (*ActionIdSetQueue, error) {
2670 _actionidsetqueue := &ActionIdSetQueue{ActionId: parent}
2671 return _actionidsetqueue, nil
2672}
2673
2674func NewActionIdSetQueue() *ActionIdSetQueue {
2675 obj := &ActionIdSetQueue{
2676 ActionId: NewActionId(21),
2677 }
2678 return obj
2679}