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