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