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