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