1 package qapi
2
3 import (
4 "encoding/json"
5 "errors"
6 "fmt"
7 )
8
9
10 type QType int32
11
12 const (
13 QTypeNone QType = iota
14 QTypeQnull
15 QTypeQnum
16 QTypeQstring
17 QTypeQdict
18 QTypeQlist
19 QTypeQbool
20 )
21
22 func (s QType) MarshalJSON() ([]byte, error) {
23 switch s {
24 case QTypeNone:
25 return []byte(`"none"`), nil
26 case QTypeQnull:
27 return []byte(`"qnull"`), nil
28 case QTypeQnum:
29 return []byte(`"qnum"`), nil
30 case QTypeQstring:
31 return []byte(`"qstring"`), nil
32 case QTypeQdict:
33 return []byte(`"qdict"`), nil
34 case QTypeQlist:
35 return []byte(`"qlist"`), nil
36 case QTypeQbool:
37 return []byte(`"qbool"`), nil
38 default:
39 fmt.Println("Failed to decode QType", s)
40 }
41 return nil, errors.New("Failed")
42 }
43
44 func (s *QType) UnmarshalJSON(data []byte) error {
45 var name string
46
47 if err := json.Unmarshal(data, &name); err != nil {
48 return err
49 }
50
51 switch name {
52 case "none":
53 (*s) = QTypeNone
54 case "qnull":
55 (*s) = QTypeQnull
56 case "qnum":
57 (*s) = QTypeQnum
58 case "qstring":
59 (*s) = QTypeQstring
60 case "qdict":
61 (*s) = QTypeQdict
62 case "qlist":
63 (*s) = QTypeQlist
64 case "qbool":
65 (*s) = QTypeQbool
66 default:
67 fmt.Println("Failed to decode QType", *s)
68 }
69 return nil
70 }
71
72
73
74
75 type QapiErrorClass int32
76
77 const (
78 QapiErrorClassGenericerror QapiErrorClass = iota
79 QapiErrorClassCommandnotfound
80 QapiErrorClassDevicenotactive
81 QapiErrorClassDevicenotfound
82 QapiErrorClassKvmmissingcap
83 )
84
85 func (s QapiErrorClass) MarshalJSON() ([]byte, error) {
86 switch s {
87 case QapiErrorClassGenericerror:
88 return []byte(`"GenericError"`), nil
89 case QapiErrorClassCommandnotfound:
90 return []byte(`"CommandNotFound"`), nil
91 case QapiErrorClassDevicenotactive:
92 return []byte(`"DeviceNotActive"`), nil
93 case QapiErrorClassDevicenotfound:
94 return []byte(`"DeviceNotFound"`), nil
95 case QapiErrorClassKvmmissingcap:
96 return []byte(`"KVMMissingCap"`), nil
97 default:
98 fmt.Println("Failed to decode QapiErrorClass", s)
99 }
100 return nil, errors.New("Failed")
101 }
102
103 func (s *QapiErrorClass) UnmarshalJSON(data []byte) error {
104 var name string
105
106 if err := json.Unmarshal(data, &name); err != nil {
107 return err
108 }
109
110 switch name {
111 case "GenericError":
112 (*s) = QapiErrorClassGenericerror
113 case "CommandNotFound":
114 (*s) = QapiErrorClassCommandnotfound
115 case "DeviceNotActive":
116 (*s) = QapiErrorClassDevicenotactive
117 case "DeviceNotFound":
118 (*s) = QapiErrorClassDevicenotfound
119 case "KVMMissingCap":
120 (*s) = QapiErrorClassKvmmissingcap
121 default:
122 fmt.Println("Failed to decode QapiErrorClass", *s)
123 }
124 return nil
125 }
126
127
128
129
130 type IoOperationType int32
131
132 const (
133 IoOperationTypeRead IoOperationType = iota
134 IoOperationTypeWrite
135 )
136
137 func (s IoOperationType) MarshalJSON() ([]byte, error) {
138 switch s {
139 case IoOperationTypeRead:
140 return []byte(`"read"`), nil
141 case IoOperationTypeWrite:
142 return []byte(`"write"`), nil
143 default:
144 fmt.Println("Failed to decode IoOperationType", s)
145 }
146 return nil, errors.New("Failed")
147 }
148
149 func (s *IoOperationType) UnmarshalJSON(data []byte) error {
150 var name string
151
152 if err := json.Unmarshal(data, &name); err != nil {
153 return err
154 }
155
156 switch name {
157 case "read":
158 (*s) = IoOperationTypeRead
159 case "write":
160 (*s) = IoOperationTypeWrite
161 default:
162 fmt.Println("Failed to decode IoOperationType", *s)
163 }
164 return nil
165 }
166
167
168
169
170 type OnOffAuto int32
171
172 const (
173 OnOffAutoAuto OnOffAuto = iota
174 OnOffAutoOn
175 OnOffAutoOff
176 )
177
178 func (s OnOffAuto) MarshalJSON() ([]byte, error) {
179 switch s {
180 case OnOffAutoAuto:
181 return []byte(`"auto"`), nil
182 case OnOffAutoOn:
183 return []byte(`"on"`), nil
184 case OnOffAutoOff:
185 return []byte(`"off"`), nil
186 default:
187 fmt.Println("Failed to decode OnOffAuto", s)
188 }
189 return nil, errors.New("Failed")
190 }
191
192 func (s *OnOffAuto) UnmarshalJSON(data []byte) error {
193 var name string
194
195 if err := json.Unmarshal(data, &name); err != nil {
196 return err
197 }
198
199 switch name {
200 case "auto":
201 (*s) = OnOffAutoAuto
202 case "on":
203 (*s) = OnOffAutoOn
204 case "off":
205 (*s) = OnOffAutoOff
206 default:
207 fmt.Println("Failed to decode OnOffAuto", *s)
208 }
209 return nil
210 }
211
212
213
214
215 type OnOffSplit int32
216
217 const (
218 OnOffSplitOn OnOffSplit = iota
219 OnOffSplitOff
220 OnOffSplitSplit
221 )
222
223 func (s OnOffSplit) MarshalJSON() ([]byte, error) {
224 switch s {
225 case OnOffSplitOn:
226 return []byte(`"on"`), nil
227 case OnOffSplitOff:
228 return []byte(`"off"`), nil
229 case OnOffSplitSplit:
230 return []byte(`"split"`), nil
231 default:
232 fmt.Println("Failed to decode OnOffSplit", s)
233 }
234 return nil, errors.New("Failed")
235 }
236
237 func (s *OnOffSplit) UnmarshalJSON(data []byte) error {
238 var name string
239
240 if err := json.Unmarshal(data, &name); err != nil {
241 return err
242 }
243
244 switch name {
245 case "on":
246 (*s) = OnOffSplitOn
247 case "off":
248 (*s) = OnOffSplitOff
249 case "split":
250 (*s) = OnOffSplitSplit
251 default:
252 fmt.Println("Failed to decode OnOffSplit", *s)
253 }
254 return nil
255 }
256
257
258
259
260 type OffAutoPCIBAR int32
261
262 const (
263 OffAutoPCIBAROff OffAutoPCIBAR = iota
264 OffAutoPCIBARAuto
265 OffAutoPCIBARBar0
266 OffAutoPCIBARBar1
267 OffAutoPCIBARBar2
268 OffAutoPCIBARBar3
269 OffAutoPCIBARBar4
270 OffAutoPCIBARBar5
271 )
272
273 func (s OffAutoPCIBAR) MarshalJSON() ([]byte, error) {
274 switch s {
275 case OffAutoPCIBAROff:
276 return []byte(`"off"`), nil
277 case OffAutoPCIBARAuto:
278 return []byte(`"auto"`), nil
279 case OffAutoPCIBARBar0:
280 return []byte(`"bar0"`), nil
281 case OffAutoPCIBARBar1:
282 return []byte(`"bar1"`), nil
283 case OffAutoPCIBARBar2:
284 return []byte(`"bar2"`), nil
285 case OffAutoPCIBARBar3:
286 return []byte(`"bar3"`), nil
287 case OffAutoPCIBARBar4:
288 return []byte(`"bar4"`), nil
289 case OffAutoPCIBARBar5:
290 return []byte(`"bar5"`), nil
291 default:
292 fmt.Println("Failed to decode OffAutoPCIBAR", s)
293 }
294 return nil, errors.New("Failed")
295 }
296
297 func (s *OffAutoPCIBAR) UnmarshalJSON(data []byte) error {
298 var name string
299
300 if err := json.Unmarshal(data, &name); err != nil {
301 return err
302 }
303
304 switch name {
305 case "off":
306 (*s) = OffAutoPCIBAROff
307 case "auto":
308 (*s) = OffAutoPCIBARAuto
309 case "bar0":
310 (*s) = OffAutoPCIBARBar0
311 case "bar1":
312 (*s) = OffAutoPCIBARBar1
313 case "bar2":
314 (*s) = OffAutoPCIBARBar2
315 case "bar3":
316 (*s) = OffAutoPCIBARBar3
317 case "bar4":
318 (*s) = OffAutoPCIBARBar4
319 case "bar5":
320 (*s) = OffAutoPCIBARBar5
321 default:
322 fmt.Println("Failed to decode OffAutoPCIBAR", *s)
323 }
324 return nil
325 }
326
327
328
329
330 type PCIELinkSpeed int32
331
332 const (
333 PCIELinkSpeed2_5 PCIELinkSpeed = iota
334 PCIELinkSpeed5
335 PCIELinkSpeed8
336 PCIELinkSpeed16
337 )
338
339 func (s PCIELinkSpeed) MarshalJSON() ([]byte, error) {
340 switch s {
341 case PCIELinkSpeed2_5:
342 return []byte(`"2_5"`), nil
343 case PCIELinkSpeed5:
344 return []byte(`"5"`), nil
345 case PCIELinkSpeed8:
346 return []byte(`"8"`), nil
347 case PCIELinkSpeed16:
348 return []byte(`"16"`), nil
349 default:
350 fmt.Println("Failed to decode PCIELinkSpeed", s)
351 }
352 return nil, errors.New("Failed")
353 }
354
355 func (s *PCIELinkSpeed) UnmarshalJSON(data []byte) error {
356 var name string
357
358 if err := json.Unmarshal(data, &name); err != nil {
359 return err
360 }
361
362 switch name {
363 case "2_5":
364 (*s) = PCIELinkSpeed2_5
365 case "5":
366 (*s) = PCIELinkSpeed5
367 case "8":
368 (*s) = PCIELinkSpeed8
369 case "16":
370 (*s) = PCIELinkSpeed16
371 default:
372 fmt.Println("Failed to decode PCIELinkSpeed", *s)
373 }
374 return nil
375 }
376
377
378
379
380 type PCIELinkWidth int32
381
382 const (
383 PCIELinkWidth1 PCIELinkWidth = iota
384 PCIELinkWidth2
385 PCIELinkWidth4
386 PCIELinkWidth8
387 PCIELinkWidth12
388 PCIELinkWidth16
389 PCIELinkWidth32
390 )
391
392 func (s PCIELinkWidth) MarshalJSON() ([]byte, error) {
393 switch s {
394 case PCIELinkWidth1:
395 return []byte(`"1"`), nil
396 case PCIELinkWidth2:
397 return []byte(`"2"`), nil
398 case PCIELinkWidth4:
399 return []byte(`"4"`), nil
400 case PCIELinkWidth8:
401 return []byte(`"8"`), nil
402 case PCIELinkWidth12:
403 return []byte(`"12"`), nil
404 case PCIELinkWidth16:
405 return []byte(`"16"`), nil
406 case PCIELinkWidth32:
407 return []byte(`"32"`), nil
408 default:
409 fmt.Println("Failed to decode PCIELinkWidth", s)
410 }
411 return nil, errors.New("Failed")
412 }
413
414 func (s *PCIELinkWidth) UnmarshalJSON(data []byte) error {
415 var name string
416
417 if err := json.Unmarshal(data, &name); err != nil {
418 return err
419 }
420
421 switch name {
422 case "1":
423 (*s) = PCIELinkWidth1
424 case "2":
425 (*s) = PCIELinkWidth2
426 case "4":
427 (*s) = PCIELinkWidth4
428 case "8":
429 (*s) = PCIELinkWidth8
430 case "12":
431 (*s) = PCIELinkWidth12
432 case "16":
433 (*s) = PCIELinkWidth16
434 case "32":
435 (*s) = PCIELinkWidth32
436 default:
437 fmt.Println("Failed to decode PCIELinkWidth", *s)
438 }
439 return nil
440 }
441
442
443
444
445 type HostMemPolicy int32
446
447 const (
448 HostMemPolicyDefault HostMemPolicy = iota
449 HostMemPolicyPreferred
450 HostMemPolicyBind
451 HostMemPolicyInterleave
452 )
453
454 func (s HostMemPolicy) MarshalJSON() ([]byte, error) {
455 switch s {
456 case HostMemPolicyDefault:
457 return []byte(`"default"`), nil
458 case HostMemPolicyPreferred:
459 return []byte(`"preferred"`), nil
460 case HostMemPolicyBind:
461 return []byte(`"bind"`), nil
462 case HostMemPolicyInterleave:
463 return []byte(`"interleave"`), nil
464 default:
465 fmt.Println("Failed to decode HostMemPolicy", s)
466 }
467 return nil, errors.New("Failed")
468 }
469
470 func (s *HostMemPolicy) UnmarshalJSON(data []byte) error {
471 var name string
472
473 if err := json.Unmarshal(data, &name); err != nil {
474 return err
475 }
476
477 switch name {
478 case "default":
479 (*s) = HostMemPolicyDefault
480 case "preferred":
481 (*s) = HostMemPolicyPreferred
482 case "bind":
483 (*s) = HostMemPolicyBind
484 case "interleave":
485 (*s) = HostMemPolicyInterleave
486 default:
487 fmt.Println("Failed to decode HostMemPolicy", *s)
488 }
489 return nil
490 }
491
492
493
494
495
496 type NetFilterDirection int32
497
498 const (
499 NetFilterDirectionAll NetFilterDirection = iota
500 NetFilterDirectionRx
501 NetFilterDirectionTx
502 )
503
504 func (s NetFilterDirection) MarshalJSON() ([]byte, error) {
505 switch s {
506 case NetFilterDirectionAll:
507 return []byte(`"all"`), nil
508 case NetFilterDirectionRx:
509 return []byte(`"rx"`), nil
510 case NetFilterDirectionTx:
511 return []byte(`"tx"`), nil
512 default:
513 fmt.Println("Failed to decode NetFilterDirection", s)
514 }
515 return nil, errors.New("Failed")
516 }
517
518 func (s *NetFilterDirection) UnmarshalJSON(data []byte) error {
519 var name string
520
521 if err := json.Unmarshal(data, &name); err != nil {
522 return err
523 }
524
525 switch name {
526 case "all":
527 (*s) = NetFilterDirectionAll
528 case "rx":
529 (*s) = NetFilterDirectionRx
530 case "tx":
531 (*s) = NetFilterDirectionTx
532 default:
533 fmt.Println("Failed to decode NetFilterDirection", *s)
534 }
535 return nil
536 }
537
538
539
540
541 type GrabToggleKeys int32
542
543 const (
544 GrabToggleKeysCtrlCtrl GrabToggleKeys = iota
545 GrabToggleKeysAltAlt
546 GrabToggleKeysShiftShift
547 GrabToggleKeysMetaMeta
548 GrabToggleKeysScrolllock
549 GrabToggleKeysCtrlScrolllock
550 )
551
552 func (s GrabToggleKeys) MarshalJSON() ([]byte, error) {
553 switch s {
554 case GrabToggleKeysCtrlCtrl:
555 return []byte(`"ctrl-ctrl"`), nil
556 case GrabToggleKeysAltAlt:
557 return []byte(`"alt-alt"`), nil
558 case GrabToggleKeysShiftShift:
559 return []byte(`"shift-shift"`), nil
560 case GrabToggleKeysMetaMeta:
561 return []byte(`"meta-meta"`), nil
562 case GrabToggleKeysScrolllock:
563 return []byte(`"scrolllock"`), nil
564 case GrabToggleKeysCtrlScrolllock:
565 return []byte(`"ctrl-scrolllock"`), nil
566 default:
567 fmt.Println("Failed to decode GrabToggleKeys", s)
568 }
569 return nil, errors.New("Failed")
570 }
571
572 func (s *GrabToggleKeys) UnmarshalJSON(data []byte) error {
573 var name string
574
575 if err := json.Unmarshal(data, &name); err != nil {
576 return err
577 }
578
579 switch name {
580 case "ctrl-ctrl":
581 (*s) = GrabToggleKeysCtrlCtrl
582 case "alt-alt":
583 (*s) = GrabToggleKeysAltAlt
584 case "shift-shift":
585 (*s) = GrabToggleKeysShiftShift
586 case "meta-meta":
587 (*s) = GrabToggleKeysMetaMeta
588 case "scrolllock":
589 (*s) = GrabToggleKeysScrolllock
590 case "ctrl-scrolllock":
591 (*s) = GrabToggleKeysCtrlScrolllock
592 default:
593 fmt.Println("Failed to decode GrabToggleKeys", *s)
594 }
595 return nil
596 }
597
598
599
600
601 type NetworkAddressFamily int32
602
603 const (
604 NetworkAddressFamilyIpv4 NetworkAddressFamily = iota
605 NetworkAddressFamilyIpv6
606 NetworkAddressFamilyUnix
607 NetworkAddressFamilyVsock
608 NetworkAddressFamilyUnknown
609 )
610
611 func (s NetworkAddressFamily) MarshalJSON() ([]byte, error) {
612 switch s {
613 case NetworkAddressFamilyIpv4:
614 return []byte(`"ipv4"`), nil
615 case NetworkAddressFamilyIpv6:
616 return []byte(`"ipv6"`), nil
617 case NetworkAddressFamilyUnix:
618 return []byte(`"unix"`), nil
619 case NetworkAddressFamilyVsock:
620 return []byte(`"vsock"`), nil
621 case NetworkAddressFamilyUnknown:
622 return []byte(`"unknown"`), nil
623 default:
624 fmt.Println("Failed to decode NetworkAddressFamily", s)
625 }
626 return nil, errors.New("Failed")
627 }
628
629 func (s *NetworkAddressFamily) UnmarshalJSON(data []byte) error {
630 var name string
631
632 if err := json.Unmarshal(data, &name); err != nil {
633 return err
634 }
635
636 switch name {
637 case "ipv4":
638 (*s) = NetworkAddressFamilyIpv4
639 case "ipv6":
640 (*s) = NetworkAddressFamilyIpv6
641 case "unix":
642 (*s) = NetworkAddressFamilyUnix
643 case "vsock":
644 (*s) = NetworkAddressFamilyVsock
645 case "unknown":
646 (*s) = NetworkAddressFamilyUnknown
647 default:
648 fmt.Println("Failed to decode NetworkAddressFamily", *s)
649 }
650 return nil
651 }
652
653
654
655
656 type SocketAddressType int32
657
658 const (
659 SocketAddressTypeInet SocketAddressType = iota
660 SocketAddressTypeUnix
661 SocketAddressTypeVsock
662 SocketAddressTypeFd
663 )
664
665 func (s SocketAddressType) MarshalJSON() ([]byte, error) {
666 switch s {
667 case SocketAddressTypeInet:
668 return []byte(`"inet"`), nil
669 case SocketAddressTypeUnix:
670 return []byte(`"unix"`), nil
671 case SocketAddressTypeVsock:
672 return []byte(`"vsock"`), nil
673 case SocketAddressTypeFd:
674 return []byte(`"fd"`), nil
675 default:
676 fmt.Println("Failed to decode SocketAddressType", s)
677 }
678 return nil, errors.New("Failed")
679 }
680
681 func (s *SocketAddressType) UnmarshalJSON(data []byte) error {
682 var name string
683
684 if err := json.Unmarshal(data, &name); err != nil {
685 return err
686 }
687
688 switch name {
689 case "inet":
690 (*s) = SocketAddressTypeInet
691 case "unix":
692 (*s) = SocketAddressTypeUnix
693 case "vsock":
694 (*s) = SocketAddressTypeVsock
695 case "fd":
696 (*s) = SocketAddressTypeFd
697 default:
698 fmt.Println("Failed to decode SocketAddressType", *s)
699 }
700 return nil
701 }
702
703
704 type RunState int32
705
706 const (
707 RunStateDebug RunState = iota
708 RunStateInmigrate
709 RunStateInternalError
710 RunStateIoError
711 RunStatePaused
712 RunStatePostmigrate
713 RunStatePrelaunch
714 RunStateFinishMigrate
715 RunStateRestoreVm
716 RunStateRunning
717 RunStateSaveVm
718 RunStateShutdown
719 RunStateSuspended
720 RunStateWatchdog
721 RunStateGuestPanicked
722 RunStateColo
723 )
724
725 func (s RunState) MarshalJSON() ([]byte, error) {
726 switch s {
727 case RunStateDebug:
728 return []byte(`"debug"`), nil
729 case RunStateInmigrate:
730 return []byte(`"inmigrate"`), nil
731 case RunStateInternalError:
732 return []byte(`"internal-error"`), nil
733 case RunStateIoError:
734 return []byte(`"io-error"`), nil
735 case RunStatePaused:
736 return []byte(`"paused"`), nil
737 case RunStatePostmigrate:
738 return []byte(`"postmigrate"`), nil
739 case RunStatePrelaunch:
740 return []byte(`"prelaunch"`), nil
741 case RunStateFinishMigrate:
742 return []byte(`"finish-migrate"`), nil
743 case RunStateRestoreVm:
744 return []byte(`"restore-vm"`), nil
745 case RunStateRunning:
746 return []byte(`"running"`), nil
747 case RunStateSaveVm:
748 return []byte(`"save-vm"`), nil
749 case RunStateShutdown:
750 return []byte(`"shutdown"`), nil
751 case RunStateSuspended:
752 return []byte(`"suspended"`), nil
753 case RunStateWatchdog:
754 return []byte(`"watchdog"`), nil
755 case RunStateGuestPanicked:
756 return []byte(`"guest-panicked"`), nil
757 case RunStateColo:
758 return []byte(`"colo"`), nil
759 default:
760 fmt.Println("Failed to decode RunState", s)
761 }
762 return nil, errors.New("Failed")
763 }
764
765 func (s *RunState) UnmarshalJSON(data []byte) error {
766 var name string
767
768 if err := json.Unmarshal(data, &name); err != nil {
769 return err
770 }
771
772 switch name {
773 case "debug":
774 (*s) = RunStateDebug
775 case "inmigrate":
776 (*s) = RunStateInmigrate
777 case "internal-error":
778 (*s) = RunStateInternalError
779 case "io-error":
780 (*s) = RunStateIoError
781 case "paused":
782 (*s) = RunStatePaused
783 case "postmigrate":
784 (*s) = RunStatePostmigrate
785 case "prelaunch":
786 (*s) = RunStatePrelaunch
787 case "finish-migrate":
788 (*s) = RunStateFinishMigrate
789 case "restore-vm":
790 (*s) = RunStateRestoreVm
791 case "running":
792 (*s) = RunStateRunning
793 case "save-vm":
794 (*s) = RunStateSaveVm
795 case "shutdown":
796 (*s) = RunStateShutdown
797 case "suspended":
798 (*s) = RunStateSuspended
799 case "watchdog":
800 (*s) = RunStateWatchdog
801 case "guest-panicked":
802 (*s) = RunStateGuestPanicked
803 case "colo":
804 (*s) = RunStateColo
805 default:
806 fmt.Println("Failed to decode RunState", *s)
807 }
808 return nil
809 }
810
811
812 type ShutdownCause int32
813
814 const (
815 ShutdownCauseNone ShutdownCause = iota
816 ShutdownCauseHostError
817 ShutdownCauseHostQmpQuit
818 ShutdownCauseHostQmpSystemReset
819 ShutdownCauseHostSignal
820 ShutdownCauseHostUi
821 ShutdownCauseGuestShutdown
822 ShutdownCauseGuestReset
823 ShutdownCauseGuestPanic
824 ShutdownCauseSubsystemReset
825 )
826
827 func (s ShutdownCause) MarshalJSON() ([]byte, error) {
828 switch s {
829 case ShutdownCauseNone:
830 return []byte(`"none"`), nil
831 case ShutdownCauseHostError:
832 return []byte(`"host-error"`), nil
833 case ShutdownCauseHostQmpQuit:
834 return []byte(`"host-qmp-quit"`), nil
835 case ShutdownCauseHostQmpSystemReset:
836 return []byte(`"host-qmp-system-reset"`), nil
837 case ShutdownCauseHostSignal:
838 return []byte(`"host-signal"`), nil
839 case ShutdownCauseHostUi:
840 return []byte(`"host-ui"`), nil
841 case ShutdownCauseGuestShutdown:
842 return []byte(`"guest-shutdown"`), nil
843 case ShutdownCauseGuestReset:
844 return []byte(`"guest-reset"`), nil
845 case ShutdownCauseGuestPanic:
846 return []byte(`"guest-panic"`), nil
847 case ShutdownCauseSubsystemReset:
848 return []byte(`"subsystem-reset"`), nil
849 default:
850 fmt.Println("Failed to decode ShutdownCause", s)
851 }
852 return nil, errors.New("Failed")
853 }
854
855 func (s *ShutdownCause) UnmarshalJSON(data []byte) error {
856 var name string
857
858 if err := json.Unmarshal(data, &name); err != nil {
859 return err
860 }
861
862 switch name {
863 case "none":
864 (*s) = ShutdownCauseNone
865 case "host-error":
866 (*s) = ShutdownCauseHostError
867 case "host-qmp-quit":
868 (*s) = ShutdownCauseHostQmpQuit
869 case "host-qmp-system-reset":
870 (*s) = ShutdownCauseHostQmpSystemReset
871 case "host-signal":
872 (*s) = ShutdownCauseHostSignal
873 case "host-ui":
874 (*s) = ShutdownCauseHostUi
875 case "guest-shutdown":
876 (*s) = ShutdownCauseGuestShutdown
877 case "guest-reset":
878 (*s) = ShutdownCauseGuestReset
879 case "guest-panic":
880 (*s) = ShutdownCauseGuestPanic
881 case "subsystem-reset":
882 (*s) = ShutdownCauseSubsystemReset
883 default:
884 fmt.Println("Failed to decode ShutdownCause", *s)
885 }
886 return nil
887 }
888
889
890
891
892
893 type WatchdogAction int32
894
895 const (
896 WatchdogActionReset WatchdogAction = iota
897 WatchdogActionShutdown
898 WatchdogActionPoweroff
899 WatchdogActionPause
900 WatchdogActionDebug
901 WatchdogActionNone
902 WatchdogActionInjectNmi
903 )
904
905 func (s WatchdogAction) MarshalJSON() ([]byte, error) {
906 switch s {
907 case WatchdogActionReset:
908 return []byte(`"reset"`), nil
909 case WatchdogActionShutdown:
910 return []byte(`"shutdown"`), nil
911 case WatchdogActionPoweroff:
912 return []byte(`"poweroff"`), nil
913 case WatchdogActionPause:
914 return []byte(`"pause"`), nil
915 case WatchdogActionDebug:
916 return []byte(`"debug"`), nil
917 case WatchdogActionNone:
918 return []byte(`"none"`), nil
919 case WatchdogActionInjectNmi:
920 return []byte(`"inject-nmi"`), nil
921 default:
922 fmt.Println("Failed to decode WatchdogAction", s)
923 }
924 return nil, errors.New("Failed")
925 }
926
927 func (s *WatchdogAction) UnmarshalJSON(data []byte) error {
928 var name string
929
930 if err := json.Unmarshal(data, &name); err != nil {
931 return err
932 }
933
934 switch name {
935 case "reset":
936 (*s) = WatchdogActionReset
937 case "shutdown":
938 (*s) = WatchdogActionShutdown
939 case "poweroff":
940 (*s) = WatchdogActionPoweroff
941 case "pause":
942 (*s) = WatchdogActionPause
943 case "debug":
944 (*s) = WatchdogActionDebug
945 case "none":
946 (*s) = WatchdogActionNone
947 case "inject-nmi":
948 (*s) = WatchdogActionInjectNmi
949 default:
950 fmt.Println("Failed to decode WatchdogAction", *s)
951 }
952 return nil
953 }
954
955
956
957
958 type RebootAction int32
959
960 const (
961 RebootActionReset RebootAction = iota
962 RebootActionShutdown
963 )
964
965 func (s RebootAction) MarshalJSON() ([]byte, error) {
966 switch s {
967 case RebootActionReset:
968 return []byte(`"reset"`), nil
969 case RebootActionShutdown:
970 return []byte(`"shutdown"`), nil
971 default:
972 fmt.Println("Failed to decode RebootAction", s)
973 }
974 return nil, errors.New("Failed")
975 }
976
977 func (s *RebootAction) UnmarshalJSON(data []byte) error {
978 var name string
979
980 if err := json.Unmarshal(data, &name); err != nil {
981 return err
982 }
983
984 switch name {
985 case "reset":
986 (*s) = RebootActionReset
987 case "shutdown":
988 (*s) = RebootActionShutdown
989 default:
990 fmt.Println("Failed to decode RebootAction", *s)
991 }
992 return nil
993 }
994
995
996
997
998 type ShutdownAction int32
999
1000 const (
1001 ShutdownActionPoweroff ShutdownAction = iota
1002 ShutdownActionPause
1003 )
1004
1005 func (s ShutdownAction) MarshalJSON() ([]byte, error) {
1006 switch s {
1007 case ShutdownActionPoweroff:
1008 return []byte(`"poweroff"`), nil
1009 case ShutdownActionPause:
1010 return []byte(`"pause"`), nil
1011 default:
1012 fmt.Println("Failed to decode ShutdownAction", s)
1013 }
1014 return nil, errors.New("Failed")
1015 }
1016
1017 func (s *ShutdownAction) UnmarshalJSON(data []byte) error {
1018 var name string
1019
1020 if err := json.Unmarshal(data, &name); err != nil {
1021 return err
1022 }
1023
1024 switch name {
1025 case "poweroff":
1026 (*s) = ShutdownActionPoweroff
1027 case "pause":
1028 (*s) = ShutdownActionPause
1029 default:
1030 fmt.Println("Failed to decode ShutdownAction", *s)
1031 }
1032 return nil
1033 }
1034
1035
1036 type PanicAction int32
1037
1038 const (
1039 PanicActionPause PanicAction = iota
1040 PanicActionShutdown
1041 PanicActionNone
1042 )
1043
1044 func (s PanicAction) MarshalJSON() ([]byte, error) {
1045 switch s {
1046 case PanicActionPause:
1047 return []byte(`"pause"`), nil
1048 case PanicActionShutdown:
1049 return []byte(`"shutdown"`), nil
1050 case PanicActionNone:
1051 return []byte(`"none"`), nil
1052 default:
1053 fmt.Println("Failed to decode PanicAction", s)
1054 }
1055 return nil, errors.New("Failed")
1056 }
1057
1058 func (s *PanicAction) UnmarshalJSON(data []byte) error {
1059 var name string
1060
1061 if err := json.Unmarshal(data, &name); err != nil {
1062 return err
1063 }
1064
1065 switch name {
1066 case "pause":
1067 (*s) = PanicActionPause
1068 case "shutdown":
1069 (*s) = PanicActionShutdown
1070 case "none":
1071 (*s) = PanicActionNone
1072 default:
1073 fmt.Println("Failed to decode PanicAction", *s)
1074 }
1075 return nil
1076 }
1077
1078
1079
1080
1081 type GuestPanicAction int32
1082
1083 const (
1084 GuestPanicActionPause GuestPanicAction = iota
1085 GuestPanicActionPoweroff
1086 GuestPanicActionRun
1087 )
1088
1089 func (s GuestPanicAction) MarshalJSON() ([]byte, error) {
1090 switch s {
1091 case GuestPanicActionPause:
1092 return []byte(`"pause"`), nil
1093 case GuestPanicActionPoweroff:
1094 return []byte(`"poweroff"`), nil
1095 case GuestPanicActionRun:
1096 return []byte(`"run"`), nil
1097 default:
1098 fmt.Println("Failed to decode GuestPanicAction", s)
1099 }
1100 return nil, errors.New("Failed")
1101 }
1102
1103 func (s *GuestPanicAction) UnmarshalJSON(data []byte) error {
1104 var name string
1105
1106 if err := json.Unmarshal(data, &name); err != nil {
1107 return err
1108 }
1109
1110 switch name {
1111 case "pause":
1112 (*s) = GuestPanicActionPause
1113 case "poweroff":
1114 (*s) = GuestPanicActionPoweroff
1115 case "run":
1116 (*s) = GuestPanicActionRun
1117 default:
1118 fmt.Println("Failed to decode GuestPanicAction", *s)
1119 }
1120 return nil
1121 }
1122
1123
1124
1125
1126 type GuestPanicInformationType int32
1127
1128 const (
1129 GuestPanicInformationTypeHyperV GuestPanicInformationType = iota
1130 GuestPanicInformationTypeS390
1131 )
1132
1133 func (s GuestPanicInformationType) MarshalJSON() ([]byte, error) {
1134 switch s {
1135 case GuestPanicInformationTypeHyperV:
1136 return []byte(`"hyper-v"`), nil
1137 case GuestPanicInformationTypeS390:
1138 return []byte(`"s390"`), nil
1139 default:
1140 fmt.Println("Failed to decode GuestPanicInformationType", s)
1141 }
1142 return nil, errors.New("Failed")
1143 }
1144
1145 func (s *GuestPanicInformationType) UnmarshalJSON(data []byte) error {
1146 var name string
1147
1148 if err := json.Unmarshal(data, &name); err != nil {
1149 return err
1150 }
1151
1152 switch name {
1153 case "hyper-v":
1154 (*s) = GuestPanicInformationTypeHyperV
1155 case "s390":
1156 (*s) = GuestPanicInformationTypeS390
1157 default:
1158 fmt.Println("Failed to decode GuestPanicInformationType", *s)
1159 }
1160 return nil
1161 }
1162
1163
1164
1165
1166 type S390CrashReason int32
1167
1168 const (
1169 S390CrashReasonUnknown S390CrashReason = iota
1170 S390CrashReasonDisabledWait
1171 S390CrashReasonExtintLoop
1172 S390CrashReasonPgmintLoop
1173 S390CrashReasonOpintLoop
1174 )
1175
1176 func (s S390CrashReason) MarshalJSON() ([]byte, error) {
1177 switch s {
1178 case S390CrashReasonUnknown:
1179 return []byte(`"unknown"`), nil
1180 case S390CrashReasonDisabledWait:
1181 return []byte(`"disabled-wait"`), nil
1182 case S390CrashReasonExtintLoop:
1183 return []byte(`"extint-loop"`), nil
1184 case S390CrashReasonPgmintLoop:
1185 return []byte(`"pgmint-loop"`), nil
1186 case S390CrashReasonOpintLoop:
1187 return []byte(`"opint-loop"`), nil
1188 default:
1189 fmt.Println("Failed to decode S390CrashReason", s)
1190 }
1191 return nil, errors.New("Failed")
1192 }
1193
1194 func (s *S390CrashReason) UnmarshalJSON(data []byte) error {
1195 var name string
1196
1197 if err := json.Unmarshal(data, &name); err != nil {
1198 return err
1199 }
1200
1201 switch name {
1202 case "unknown":
1203 (*s) = S390CrashReasonUnknown
1204 case "disabled-wait":
1205 (*s) = S390CrashReasonDisabledWait
1206 case "extint-loop":
1207 (*s) = S390CrashReasonExtintLoop
1208 case "pgmint-loop":
1209 (*s) = S390CrashReasonPgmintLoop
1210 case "opint-loop":
1211 (*s) = S390CrashReasonOpintLoop
1212 default:
1213 fmt.Println("Failed to decode S390CrashReason", *s)
1214 }
1215 return nil
1216 }
1217
1218
1219
1220
1221 type MemoryFailureRecipient int32
1222
1223 const (
1224 MemoryFailureRecipientHypervisor MemoryFailureRecipient = iota
1225 MemoryFailureRecipientGuest
1226 )
1227
1228 func (s MemoryFailureRecipient) MarshalJSON() ([]byte, error) {
1229 switch s {
1230 case MemoryFailureRecipientHypervisor:
1231 return []byte(`"hypervisor"`), nil
1232 case MemoryFailureRecipientGuest:
1233 return []byte(`"guest"`), nil
1234 default:
1235 fmt.Println("Failed to decode MemoryFailureRecipient", s)
1236 }
1237 return nil, errors.New("Failed")
1238 }
1239
1240 func (s *MemoryFailureRecipient) UnmarshalJSON(data []byte) error {
1241 var name string
1242
1243 if err := json.Unmarshal(data, &name); err != nil {
1244 return err
1245 }
1246
1247 switch name {
1248 case "hypervisor":
1249 (*s) = MemoryFailureRecipientHypervisor
1250 case "guest":
1251 (*s) = MemoryFailureRecipientGuest
1252 default:
1253 fmt.Println("Failed to decode MemoryFailureRecipient", *s)
1254 }
1255 return nil
1256 }
1257
1258
1259
1260
1261 type MemoryFailureAction int32
1262
1263 const (
1264 MemoryFailureActionIgnore MemoryFailureAction = iota
1265 MemoryFailureActionInject
1266 MemoryFailureActionFatal
1267 MemoryFailureActionReset
1268 )
1269
1270 func (s MemoryFailureAction) MarshalJSON() ([]byte, error) {
1271 switch s {
1272 case MemoryFailureActionIgnore:
1273 return []byte(`"ignore"`), nil
1274 case MemoryFailureActionInject:
1275 return []byte(`"inject"`), nil
1276 case MemoryFailureActionFatal:
1277 return []byte(`"fatal"`), nil
1278 case MemoryFailureActionReset:
1279 return []byte(`"reset"`), nil
1280 default:
1281 fmt.Println("Failed to decode MemoryFailureAction", s)
1282 }
1283 return nil, errors.New("Failed")
1284 }
1285
1286 func (s *MemoryFailureAction) UnmarshalJSON(data []byte) error {
1287 var name string
1288
1289 if err := json.Unmarshal(data, &name); err != nil {
1290 return err
1291 }
1292
1293 switch name {
1294 case "ignore":
1295 (*s) = MemoryFailureActionIgnore
1296 case "inject":
1297 (*s) = MemoryFailureActionInject
1298 case "fatal":
1299 (*s) = MemoryFailureActionFatal
1300 case "reset":
1301 (*s) = MemoryFailureActionReset
1302 default:
1303 fmt.Println("Failed to decode MemoryFailureAction", *s)
1304 }
1305 return nil
1306 }
1307
1308
1309
1310
1311
1312
1313
1314 type QCryptoTLSCredsEndpoint int32
1315
1316 const (
1317 QCryptoTLSCredsEndpointClient QCryptoTLSCredsEndpoint = iota
1318 QCryptoTLSCredsEndpointServer
1319 )
1320
1321 func (s QCryptoTLSCredsEndpoint) MarshalJSON() ([]byte, error) {
1322 switch s {
1323 case QCryptoTLSCredsEndpointClient:
1324 return []byte(`"client"`), nil
1325 case QCryptoTLSCredsEndpointServer:
1326 return []byte(`"server"`), nil
1327 default:
1328 fmt.Println("Failed to decode QCryptoTLSCredsEndpoint", s)
1329 }
1330 return nil, errors.New("Failed")
1331 }
1332
1333 func (s *QCryptoTLSCredsEndpoint) UnmarshalJSON(data []byte) error {
1334 var name string
1335
1336 if err := json.Unmarshal(data, &name); err != nil {
1337 return err
1338 }
1339
1340 switch name {
1341 case "client":
1342 (*s) = QCryptoTLSCredsEndpointClient
1343 case "server":
1344 (*s) = QCryptoTLSCredsEndpointServer
1345 default:
1346 fmt.Println("Failed to decode QCryptoTLSCredsEndpoint", *s)
1347 }
1348 return nil
1349 }
1350
1351
1352
1353
1354 type QCryptoSecretFormat int32
1355
1356 const (
1357 QCryptoSecretFormatRaw QCryptoSecretFormat = iota
1358 QCryptoSecretFormatBase64
1359 )
1360
1361 func (s QCryptoSecretFormat) MarshalJSON() ([]byte, error) {
1362 switch s {
1363 case QCryptoSecretFormatRaw:
1364 return []byte(`"raw"`), nil
1365 case QCryptoSecretFormatBase64:
1366 return []byte(`"base64"`), nil
1367 default:
1368 fmt.Println("Failed to decode QCryptoSecretFormat", s)
1369 }
1370 return nil, errors.New("Failed")
1371 }
1372
1373 func (s *QCryptoSecretFormat) UnmarshalJSON(data []byte) error {
1374 var name string
1375
1376 if err := json.Unmarshal(data, &name); err != nil {
1377 return err
1378 }
1379
1380 switch name {
1381 case "raw":
1382 (*s) = QCryptoSecretFormatRaw
1383 case "base64":
1384 (*s) = QCryptoSecretFormatBase64
1385 default:
1386 fmt.Println("Failed to decode QCryptoSecretFormat", *s)
1387 }
1388 return nil
1389 }
1390
1391
1392
1393
1394 type QCryptoHashAlgorithm int32
1395
1396 const (
1397 QCryptoHashAlgorithmMd5 QCryptoHashAlgorithm = iota
1398 QCryptoHashAlgorithmSha1
1399 QCryptoHashAlgorithmSha224
1400 QCryptoHashAlgorithmSha256
1401 QCryptoHashAlgorithmSha384
1402 QCryptoHashAlgorithmSha512
1403 QCryptoHashAlgorithmRipemd160
1404 )
1405
1406 func (s QCryptoHashAlgorithm) MarshalJSON() ([]byte, error) {
1407 switch s {
1408 case QCryptoHashAlgorithmMd5:
1409 return []byte(`"md5"`), nil
1410 case QCryptoHashAlgorithmSha1:
1411 return []byte(`"sha1"`), nil
1412 case QCryptoHashAlgorithmSha224:
1413 return []byte(`"sha224"`), nil
1414 case QCryptoHashAlgorithmSha256:
1415 return []byte(`"sha256"`), nil
1416 case QCryptoHashAlgorithmSha384:
1417 return []byte(`"sha384"`), nil
1418 case QCryptoHashAlgorithmSha512:
1419 return []byte(`"sha512"`), nil
1420 case QCryptoHashAlgorithmRipemd160:
1421 return []byte(`"ripemd160"`), nil
1422 default:
1423 fmt.Println("Failed to decode QCryptoHashAlgorithm", s)
1424 }
1425 return nil, errors.New("Failed")
1426 }
1427
1428 func (s *QCryptoHashAlgorithm) UnmarshalJSON(data []byte) error {
1429 var name string
1430
1431 if err := json.Unmarshal(data, &name); err != nil {
1432 return err
1433 }
1434
1435 switch name {
1436 case "md5":
1437 (*s) = QCryptoHashAlgorithmMd5
1438 case "sha1":
1439 (*s) = QCryptoHashAlgorithmSha1
1440 case "sha224":
1441 (*s) = QCryptoHashAlgorithmSha224
1442 case "sha256":
1443 (*s) = QCryptoHashAlgorithmSha256
1444 case "sha384":
1445 (*s) = QCryptoHashAlgorithmSha384
1446 case "sha512":
1447 (*s) = QCryptoHashAlgorithmSha512
1448 case "ripemd160":
1449 (*s) = QCryptoHashAlgorithmRipemd160
1450 default:
1451 fmt.Println("Failed to decode QCryptoHashAlgorithm", *s)
1452 }
1453 return nil
1454 }
1455
1456
1457
1458
1459 type QCryptoCipherAlgorithm int32
1460
1461 const (
1462 QCryptoCipherAlgorithmAes128 QCryptoCipherAlgorithm = iota
1463 QCryptoCipherAlgorithmAes192
1464 QCryptoCipherAlgorithmAes256
1465 QCryptoCipherAlgorithmDes
1466 QCryptoCipherAlgorithm3Des
1467 QCryptoCipherAlgorithmCast5128
1468 QCryptoCipherAlgorithmSerpent128
1469 QCryptoCipherAlgorithmSerpent192
1470 QCryptoCipherAlgorithmSerpent256
1471 QCryptoCipherAlgorithmTwofish128
1472 QCryptoCipherAlgorithmTwofish192
1473 QCryptoCipherAlgorithmTwofish256
1474 )
1475
1476 func (s QCryptoCipherAlgorithm) MarshalJSON() ([]byte, error) {
1477 switch s {
1478 case QCryptoCipherAlgorithmAes128:
1479 return []byte(`"aes-128"`), nil
1480 case QCryptoCipherAlgorithmAes192:
1481 return []byte(`"aes-192"`), nil
1482 case QCryptoCipherAlgorithmAes256:
1483 return []byte(`"aes-256"`), nil
1484 case QCryptoCipherAlgorithmDes:
1485 return []byte(`"des"`), nil
1486 case QCryptoCipherAlgorithm3Des:
1487 return []byte(`"3des"`), nil
1488 case QCryptoCipherAlgorithmCast5128:
1489 return []byte(`"cast5-128"`), nil
1490 case QCryptoCipherAlgorithmSerpent128:
1491 return []byte(`"serpent-128"`), nil
1492 case QCryptoCipherAlgorithmSerpent192:
1493 return []byte(`"serpent-192"`), nil
1494 case QCryptoCipherAlgorithmSerpent256:
1495 return []byte(`"serpent-256"`), nil
1496 case QCryptoCipherAlgorithmTwofish128:
1497 return []byte(`"twofish-128"`), nil
1498 case QCryptoCipherAlgorithmTwofish192:
1499 return []byte(`"twofish-192"`), nil
1500 case QCryptoCipherAlgorithmTwofish256:
1501 return []byte(`"twofish-256"`), nil
1502 default:
1503 fmt.Println("Failed to decode QCryptoCipherAlgorithm", s)
1504 }
1505 return nil, errors.New("Failed")
1506 }
1507
1508 func (s *QCryptoCipherAlgorithm) UnmarshalJSON(data []byte) error {
1509 var name string
1510
1511 if err := json.Unmarshal(data, &name); err != nil {
1512 return err
1513 }
1514
1515 switch name {
1516 case "aes-128":
1517 (*s) = QCryptoCipherAlgorithmAes128
1518 case "aes-192":
1519 (*s) = QCryptoCipherAlgorithmAes192
1520 case "aes-256":
1521 (*s) = QCryptoCipherAlgorithmAes256
1522 case "des":
1523 (*s) = QCryptoCipherAlgorithmDes
1524 case "3des":
1525 (*s) = QCryptoCipherAlgorithm3Des
1526 case "cast5-128":
1527 (*s) = QCryptoCipherAlgorithmCast5128
1528 case "serpent-128":
1529 (*s) = QCryptoCipherAlgorithmSerpent128
1530 case "serpent-192":
1531 (*s) = QCryptoCipherAlgorithmSerpent192
1532 case "serpent-256":
1533 (*s) = QCryptoCipherAlgorithmSerpent256
1534 case "twofish-128":
1535 (*s) = QCryptoCipherAlgorithmTwofish128
1536 case "twofish-192":
1537 (*s) = QCryptoCipherAlgorithmTwofish192
1538 case "twofish-256":
1539 (*s) = QCryptoCipherAlgorithmTwofish256
1540 default:
1541 fmt.Println("Failed to decode QCryptoCipherAlgorithm", *s)
1542 }
1543 return nil
1544 }
1545
1546
1547
1548
1549 type QCryptoCipherMode int32
1550
1551 const (
1552 QCryptoCipherModeEcb QCryptoCipherMode = iota
1553 QCryptoCipherModeCbc
1554 QCryptoCipherModeXts
1555 QCryptoCipherModeCtr
1556 )
1557
1558 func (s QCryptoCipherMode) MarshalJSON() ([]byte, error) {
1559 switch s {
1560 case QCryptoCipherModeEcb:
1561 return []byte(`"ecb"`), nil
1562 case QCryptoCipherModeCbc:
1563 return []byte(`"cbc"`), nil
1564 case QCryptoCipherModeXts:
1565 return []byte(`"xts"`), nil
1566 case QCryptoCipherModeCtr:
1567 return []byte(`"ctr"`), nil
1568 default:
1569 fmt.Println("Failed to decode QCryptoCipherMode", s)
1570 }
1571 return nil, errors.New("Failed")
1572 }
1573
1574 func (s *QCryptoCipherMode) UnmarshalJSON(data []byte) error {
1575 var name string
1576
1577 if err := json.Unmarshal(data, &name); err != nil {
1578 return err
1579 }
1580
1581 switch name {
1582 case "ecb":
1583 (*s) = QCryptoCipherModeEcb
1584 case "cbc":
1585 (*s) = QCryptoCipherModeCbc
1586 case "xts":
1587 (*s) = QCryptoCipherModeXts
1588 case "ctr":
1589 (*s) = QCryptoCipherModeCtr
1590 default:
1591 fmt.Println("Failed to decode QCryptoCipherMode", *s)
1592 }
1593 return nil
1594 }
1595
1596
1597
1598
1599
1600
1601
1602
1603 type QCryptoIVGenAlgorithm int32
1604
1605 const (
1606 QCryptoIVGenAlgorithmPlain QCryptoIVGenAlgorithm = iota
1607 QCryptoIVGenAlgorithmPlain64
1608 QCryptoIVGenAlgorithmEssiv
1609 )
1610
1611 func (s QCryptoIVGenAlgorithm) MarshalJSON() ([]byte, error) {
1612 switch s {
1613 case QCryptoIVGenAlgorithmPlain:
1614 return []byte(`"plain"`), nil
1615 case QCryptoIVGenAlgorithmPlain64:
1616 return []byte(`"plain64"`), nil
1617 case QCryptoIVGenAlgorithmEssiv:
1618 return []byte(`"essiv"`), nil
1619 default:
1620 fmt.Println("Failed to decode QCryptoIVGenAlgorithm", s)
1621 }
1622 return nil, errors.New("Failed")
1623 }
1624
1625 func (s *QCryptoIVGenAlgorithm) UnmarshalJSON(data []byte) error {
1626 var name string
1627
1628 if err := json.Unmarshal(data, &name); err != nil {
1629 return err
1630 }
1631
1632 switch name {
1633 case "plain":
1634 (*s) = QCryptoIVGenAlgorithmPlain
1635 case "plain64":
1636 (*s) = QCryptoIVGenAlgorithmPlain64
1637 case "essiv":
1638 (*s) = QCryptoIVGenAlgorithmEssiv
1639 default:
1640 fmt.Println("Failed to decode QCryptoIVGenAlgorithm", *s)
1641 }
1642 return nil
1643 }
1644
1645
1646
1647
1648 type QCryptoBlockFormat int32
1649
1650 const (
1651 QCryptoBlockFormatQcow QCryptoBlockFormat = iota
1652 QCryptoBlockFormatLuks
1653 )
1654
1655 func (s QCryptoBlockFormat) MarshalJSON() ([]byte, error) {
1656 switch s {
1657 case QCryptoBlockFormatQcow:
1658 return []byte(`"qcow"`), nil
1659 case QCryptoBlockFormatLuks:
1660 return []byte(`"luks"`), nil
1661 default:
1662 fmt.Println("Failed to decode QCryptoBlockFormat", s)
1663 }
1664 return nil, errors.New("Failed")
1665 }
1666
1667 func (s *QCryptoBlockFormat) UnmarshalJSON(data []byte) error {
1668 var name string
1669
1670 if err := json.Unmarshal(data, &name); err != nil {
1671 return err
1672 }
1673
1674 switch name {
1675 case "qcow":
1676 (*s) = QCryptoBlockFormatQcow
1677 case "luks":
1678 (*s) = QCryptoBlockFormatLuks
1679 default:
1680 fmt.Println("Failed to decode QCryptoBlockFormat", *s)
1681 }
1682 return nil
1683 }
1684
1685
1686
1687
1688 type QCryptoBlockLUKSKeyslotState int32
1689
1690 const (
1691 QCryptoBlockLUKSKeyslotStateActive QCryptoBlockLUKSKeyslotState = iota
1692 QCryptoBlockLUKSKeyslotStateInactive
1693 )
1694
1695 func (s QCryptoBlockLUKSKeyslotState) MarshalJSON() ([]byte, error) {
1696 switch s {
1697 case QCryptoBlockLUKSKeyslotStateActive:
1698 return []byte(`"active"`), nil
1699 case QCryptoBlockLUKSKeyslotStateInactive:
1700 return []byte(`"inactive"`), nil
1701 default:
1702 fmt.Println("Failed to decode QCryptoBlockLUKSKeyslotState", s)
1703 }
1704 return nil, errors.New("Failed")
1705 }
1706
1707 func (s *QCryptoBlockLUKSKeyslotState) UnmarshalJSON(data []byte) error {
1708 var name string
1709
1710 if err := json.Unmarshal(data, &name); err != nil {
1711 return err
1712 }
1713
1714 switch name {
1715 case "active":
1716 (*s) = QCryptoBlockLUKSKeyslotStateActive
1717 case "inactive":
1718 (*s) = QCryptoBlockLUKSKeyslotStateInactive
1719 default:
1720 fmt.Println("Failed to decode QCryptoBlockLUKSKeyslotState", *s)
1721 }
1722 return nil
1723 }
1724
1725
1726
1727
1728
1729
1730
1731 type BiosAtaTranslation int32
1732
1733 const (
1734 BiosAtaTranslationAuto BiosAtaTranslation = iota
1735 BiosAtaTranslationNone
1736 BiosAtaTranslationLba
1737 BiosAtaTranslationLarge
1738 BiosAtaTranslationRechs
1739 )
1740
1741 func (s BiosAtaTranslation) MarshalJSON() ([]byte, error) {
1742 switch s {
1743 case BiosAtaTranslationAuto:
1744 return []byte(`"auto"`), nil
1745 case BiosAtaTranslationNone:
1746 return []byte(`"none"`), nil
1747 case BiosAtaTranslationLba:
1748 return []byte(`"lba"`), nil
1749 case BiosAtaTranslationLarge:
1750 return []byte(`"large"`), nil
1751 case BiosAtaTranslationRechs:
1752 return []byte(`"rechs"`), nil
1753 default:
1754 fmt.Println("Failed to decode BiosAtaTranslation", s)
1755 }
1756 return nil, errors.New("Failed")
1757 }
1758
1759 func (s *BiosAtaTranslation) UnmarshalJSON(data []byte) error {
1760 var name string
1761
1762 if err := json.Unmarshal(data, &name); err != nil {
1763 return err
1764 }
1765
1766 switch name {
1767 case "auto":
1768 (*s) = BiosAtaTranslationAuto
1769 case "none":
1770 (*s) = BiosAtaTranslationNone
1771 case "lba":
1772 (*s) = BiosAtaTranslationLba
1773 case "large":
1774 (*s) = BiosAtaTranslationLarge
1775 case "rechs":
1776 (*s) = BiosAtaTranslationRechs
1777 default:
1778 fmt.Println("Failed to decode BiosAtaTranslation", *s)
1779 }
1780 return nil
1781 }
1782
1783
1784
1785
1786 type FloppyDriveType int32
1787
1788 const (
1789 FloppyDriveType144 FloppyDriveType = iota
1790 FloppyDriveType288
1791 FloppyDriveType120
1792 FloppyDriveTypeNone
1793 FloppyDriveTypeAuto
1794 )
1795
1796 func (s FloppyDriveType) MarshalJSON() ([]byte, error) {
1797 switch s {
1798 case FloppyDriveType144:
1799 return []byte(`"144"`), nil
1800 case FloppyDriveType288:
1801 return []byte(`"288"`), nil
1802 case FloppyDriveType120:
1803 return []byte(`"120"`), nil
1804 case FloppyDriveTypeNone:
1805 return []byte(`"none"`), nil
1806 case FloppyDriveTypeAuto:
1807 return []byte(`"auto"`), nil
1808 default:
1809 fmt.Println("Failed to decode FloppyDriveType", s)
1810 }
1811 return nil, errors.New("Failed")
1812 }
1813
1814 func (s *FloppyDriveType) UnmarshalJSON(data []byte) error {
1815 var name string
1816
1817 if err := json.Unmarshal(data, &name); err != nil {
1818 return err
1819 }
1820
1821 switch name {
1822 case "144":
1823 (*s) = FloppyDriveType144
1824 case "288":
1825 (*s) = FloppyDriveType288
1826 case "120":
1827 (*s) = FloppyDriveType120
1828 case "none":
1829 (*s) = FloppyDriveTypeNone
1830 case "auto":
1831 (*s) = FloppyDriveTypeAuto
1832 default:
1833 fmt.Println("Failed to decode FloppyDriveType", *s)
1834 }
1835 return nil
1836 }
1837
1838
1839
1840
1841
1842 type BlockdevChangeReadOnlyMode int32
1843
1844 const (
1845 BlockdevChangeReadOnlyModeRetain BlockdevChangeReadOnlyMode = iota
1846 BlockdevChangeReadOnlyModeReadOnly
1847 BlockdevChangeReadOnlyModeReadWrite
1848 )
1849
1850 func (s BlockdevChangeReadOnlyMode) MarshalJSON() ([]byte, error) {
1851 switch s {
1852 case BlockdevChangeReadOnlyModeRetain:
1853 return []byte(`"retain"`), nil
1854 case BlockdevChangeReadOnlyModeReadOnly:
1855 return []byte(`"read-only"`), nil
1856 case BlockdevChangeReadOnlyModeReadWrite:
1857 return []byte(`"read-write"`), nil
1858 default:
1859 fmt.Println("Failed to decode BlockdevChangeReadOnlyMode", s)
1860 }
1861 return nil, errors.New("Failed")
1862 }
1863
1864 func (s *BlockdevChangeReadOnlyMode) UnmarshalJSON(data []byte) error {
1865 var name string
1866
1867 if err := json.Unmarshal(data, &name); err != nil {
1868 return err
1869 }
1870
1871 switch name {
1872 case "retain":
1873 (*s) = BlockdevChangeReadOnlyModeRetain
1874 case "read-only":
1875 (*s) = BlockdevChangeReadOnlyModeReadOnly
1876 case "read-write":
1877 (*s) = BlockdevChangeReadOnlyModeReadWrite
1878 default:
1879 fmt.Println("Failed to decode BlockdevChangeReadOnlyMode", *s)
1880 }
1881 return nil
1882 }
1883
1884
1885 type ImageInfoSpecificKind int32
1886
1887 const (
1888 ImageInfoSpecificKindQcow2 ImageInfoSpecificKind = iota
1889 ImageInfoSpecificKindVmdk
1890 ImageInfoSpecificKindLuks
1891 ImageInfoSpecificKindRbd
1892 )
1893
1894 func (s ImageInfoSpecificKind) MarshalJSON() ([]byte, error) {
1895 switch s {
1896 case ImageInfoSpecificKindQcow2:
1897 return []byte(`"qcow2"`), nil
1898 case ImageInfoSpecificKindVmdk:
1899 return []byte(`"vmdk"`), nil
1900 case ImageInfoSpecificKindLuks:
1901 return []byte(`"luks"`), nil
1902 case ImageInfoSpecificKindRbd:
1903 return []byte(`"rbd"`), nil
1904 default:
1905 fmt.Println("Failed to decode ImageInfoSpecificKind", s)
1906 }
1907 return nil, errors.New("Failed")
1908 }
1909
1910 func (s *ImageInfoSpecificKind) UnmarshalJSON(data []byte) error {
1911 var name string
1912
1913 if err := json.Unmarshal(data, &name); err != nil {
1914 return err
1915 }
1916
1917 switch name {
1918 case "qcow2":
1919 (*s) = ImageInfoSpecificKindQcow2
1920 case "vmdk":
1921 (*s) = ImageInfoSpecificKindVmdk
1922 case "luks":
1923 (*s) = ImageInfoSpecificKindLuks
1924 case "rbd":
1925 (*s) = ImageInfoSpecificKindRbd
1926 default:
1927 fmt.Println("Failed to decode ImageInfoSpecificKind", *s)
1928 }
1929 return nil
1930 }
1931
1932
1933
1934
1935 type BlockDeviceIoStatus int32
1936
1937 const (
1938 BlockDeviceIoStatusOk BlockDeviceIoStatus = iota
1939 BlockDeviceIoStatusFailed
1940 BlockDeviceIoStatusNospace
1941 )
1942
1943 func (s BlockDeviceIoStatus) MarshalJSON() ([]byte, error) {
1944 switch s {
1945 case BlockDeviceIoStatusOk:
1946 return []byte(`"ok"`), nil
1947 case BlockDeviceIoStatusFailed:
1948 return []byte(`"failed"`), nil
1949 case BlockDeviceIoStatusNospace:
1950 return []byte(`"nospace"`), nil
1951 default:
1952 fmt.Println("Failed to decode BlockDeviceIoStatus", s)
1953 }
1954 return nil, errors.New("Failed")
1955 }
1956
1957 func (s *BlockDeviceIoStatus) UnmarshalJSON(data []byte) error {
1958 var name string
1959
1960 if err := json.Unmarshal(data, &name); err != nil {
1961 return err
1962 }
1963
1964 switch name {
1965 case "ok":
1966 (*s) = BlockDeviceIoStatusOk
1967 case "failed":
1968 (*s) = BlockDeviceIoStatusFailed
1969 case "nospace":
1970 (*s) = BlockDeviceIoStatusNospace
1971 default:
1972 fmt.Println("Failed to decode BlockDeviceIoStatus", *s)
1973 }
1974 return nil
1975 }
1976
1977
1978
1979
1980 type Qcow2BitmapInfoFlags int32
1981
1982 const (
1983 Qcow2BitmapInfoFlagsInUse Qcow2BitmapInfoFlags = iota
1984 Qcow2BitmapInfoFlagsAuto
1985 )
1986
1987 func (s Qcow2BitmapInfoFlags) MarshalJSON() ([]byte, error) {
1988 switch s {
1989 case Qcow2BitmapInfoFlagsInUse:
1990 return []byte(`"in-use"`), nil
1991 case Qcow2BitmapInfoFlagsAuto:
1992 return []byte(`"auto"`), nil
1993 default:
1994 fmt.Println("Failed to decode Qcow2BitmapInfoFlags", s)
1995 }
1996 return nil, errors.New("Failed")
1997 }
1998
1999 func (s *Qcow2BitmapInfoFlags) UnmarshalJSON(data []byte) error {
2000 var name string
2001
2002 if err := json.Unmarshal(data, &name); err != nil {
2003 return err
2004 }
2005
2006 switch name {
2007 case "in-use":
2008 (*s) = Qcow2BitmapInfoFlagsInUse
2009 case "auto":
2010 (*s) = Qcow2BitmapInfoFlagsAuto
2011 default:
2012 fmt.Println("Failed to decode Qcow2BitmapInfoFlags", *s)
2013 }
2014 return nil
2015 }
2016
2017
2018
2019
2020
2021
2022 type BlockdevOnError int32
2023
2024 const (
2025 BlockdevOnErrorReport BlockdevOnError = iota
2026 BlockdevOnErrorIgnore
2027 BlockdevOnErrorEnospc
2028 BlockdevOnErrorStop
2029 BlockdevOnErrorAuto
2030 )
2031
2032 func (s BlockdevOnError) MarshalJSON() ([]byte, error) {
2033 switch s {
2034 case BlockdevOnErrorReport:
2035 return []byte(`"report"`), nil
2036 case BlockdevOnErrorIgnore:
2037 return []byte(`"ignore"`), nil
2038 case BlockdevOnErrorEnospc:
2039 return []byte(`"enospc"`), nil
2040 case BlockdevOnErrorStop:
2041 return []byte(`"stop"`), nil
2042 case BlockdevOnErrorAuto:
2043 return []byte(`"auto"`), nil
2044 default:
2045 fmt.Println("Failed to decode BlockdevOnError", s)
2046 }
2047 return nil, errors.New("Failed")
2048 }
2049
2050 func (s *BlockdevOnError) UnmarshalJSON(data []byte) error {
2051 var name string
2052
2053 if err := json.Unmarshal(data, &name); err != nil {
2054 return err
2055 }
2056
2057 switch name {
2058 case "report":
2059 (*s) = BlockdevOnErrorReport
2060 case "ignore":
2061 (*s) = BlockdevOnErrorIgnore
2062 case "enospc":
2063 (*s) = BlockdevOnErrorEnospc
2064 case "stop":
2065 (*s) = BlockdevOnErrorStop
2066 case "auto":
2067 (*s) = BlockdevOnErrorAuto
2068 default:
2069 fmt.Println("Failed to decode BlockdevOnError", *s)
2070 }
2071 return nil
2072 }
2073
2074
2075
2076
2077
2078 type MirrorSyncMode int32
2079
2080 const (
2081 MirrorSyncModeTop MirrorSyncMode = iota
2082 MirrorSyncModeFull
2083 MirrorSyncModeNone
2084 MirrorSyncModeIncremental
2085 MirrorSyncModeBitmap
2086 )
2087
2088 func (s MirrorSyncMode) MarshalJSON() ([]byte, error) {
2089 switch s {
2090 case MirrorSyncModeTop:
2091 return []byte(`"top"`), nil
2092 case MirrorSyncModeFull:
2093 return []byte(`"full"`), nil
2094 case MirrorSyncModeNone:
2095 return []byte(`"none"`), nil
2096 case MirrorSyncModeIncremental:
2097 return []byte(`"incremental"`), nil
2098 case MirrorSyncModeBitmap:
2099 return []byte(`"bitmap"`), nil
2100 default:
2101 fmt.Println("Failed to decode MirrorSyncMode", s)
2102 }
2103 return nil, errors.New("Failed")
2104 }
2105
2106 func (s *MirrorSyncMode) UnmarshalJSON(data []byte) error {
2107 var name string
2108
2109 if err := json.Unmarshal(data, &name); err != nil {
2110 return err
2111 }
2112
2113 switch name {
2114 case "top":
2115 (*s) = MirrorSyncModeTop
2116 case "full":
2117 (*s) = MirrorSyncModeFull
2118 case "none":
2119 (*s) = MirrorSyncModeNone
2120 case "incremental":
2121 (*s) = MirrorSyncModeIncremental
2122 case "bitmap":
2123 (*s) = MirrorSyncModeBitmap
2124 default:
2125 fmt.Println("Failed to decode MirrorSyncMode", *s)
2126 }
2127 return nil
2128 }
2129
2130
2131
2132
2133
2134 type BitmapSyncMode int32
2135
2136 const (
2137 BitmapSyncModeOnSuccess BitmapSyncMode = iota
2138 BitmapSyncModeNever
2139 BitmapSyncModeAlways
2140 )
2141
2142 func (s BitmapSyncMode) MarshalJSON() ([]byte, error) {
2143 switch s {
2144 case BitmapSyncModeOnSuccess:
2145 return []byte(`"on-success"`), nil
2146 case BitmapSyncModeNever:
2147 return []byte(`"never"`), nil
2148 case BitmapSyncModeAlways:
2149 return []byte(`"always"`), nil
2150 default:
2151 fmt.Println("Failed to decode BitmapSyncMode", s)
2152 }
2153 return nil, errors.New("Failed")
2154 }
2155
2156 func (s *BitmapSyncMode) UnmarshalJSON(data []byte) error {
2157 var name string
2158
2159 if err := json.Unmarshal(data, &name); err != nil {
2160 return err
2161 }
2162
2163 switch name {
2164 case "on-success":
2165 (*s) = BitmapSyncModeOnSuccess
2166 case "never":
2167 (*s) = BitmapSyncModeNever
2168 case "always":
2169 (*s) = BitmapSyncModeAlways
2170 default:
2171 fmt.Println("Failed to decode BitmapSyncMode", *s)
2172 }
2173 return nil
2174 }
2175
2176
2177
2178
2179
2180 type MirrorCopyMode int32
2181
2182 const (
2183 MirrorCopyModeBackground MirrorCopyMode = iota
2184 MirrorCopyModeWriteBlocking
2185 )
2186
2187 func (s MirrorCopyMode) MarshalJSON() ([]byte, error) {
2188 switch s {
2189 case MirrorCopyModeBackground:
2190 return []byte(`"background"`), nil
2191 case MirrorCopyModeWriteBlocking:
2192 return []byte(`"write-blocking"`), nil
2193 default:
2194 fmt.Println("Failed to decode MirrorCopyMode", s)
2195 }
2196 return nil, errors.New("Failed")
2197 }
2198
2199 func (s *MirrorCopyMode) UnmarshalJSON(data []byte) error {
2200 var name string
2201
2202 if err := json.Unmarshal(data, &name); err != nil {
2203 return err
2204 }
2205
2206 switch name {
2207 case "background":
2208 (*s) = MirrorCopyModeBackground
2209 case "write-blocking":
2210 (*s) = MirrorCopyModeWriteBlocking
2211 default:
2212 fmt.Println("Failed to decode MirrorCopyMode", *s)
2213 }
2214 return nil
2215 }
2216
2217
2218
2219
2220
2221 type NewImageMode int32
2222
2223 const (
2224 NewImageModeExisting NewImageMode = iota
2225 NewImageModeAbsolutePaths
2226 )
2227
2228 func (s NewImageMode) MarshalJSON() ([]byte, error) {
2229 switch s {
2230 case NewImageModeExisting:
2231 return []byte(`"existing"`), nil
2232 case NewImageModeAbsolutePaths:
2233 return []byte(`"absolute-paths"`), nil
2234 default:
2235 fmt.Println("Failed to decode NewImageMode", s)
2236 }
2237 return nil, errors.New("Failed")
2238 }
2239
2240 func (s *NewImageMode) UnmarshalJSON(data []byte) error {
2241 var name string
2242
2243 if err := json.Unmarshal(data, &name); err != nil {
2244 return err
2245 }
2246
2247 switch name {
2248 case "existing":
2249 (*s) = NewImageModeExisting
2250 case "absolute-paths":
2251 (*s) = NewImageModeAbsolutePaths
2252 default:
2253 fmt.Println("Failed to decode NewImageMode", *s)
2254 }
2255 return nil
2256 }
2257
2258
2259 type XDbgBlockGraphNodeType int32
2260
2261 const (
2262 XDbgBlockGraphNodeTypeBlockBackend XDbgBlockGraphNodeType = iota
2263 XDbgBlockGraphNodeTypeBlockJob
2264 XDbgBlockGraphNodeTypeBlockDriver
2265 )
2266
2267 func (s XDbgBlockGraphNodeType) MarshalJSON() ([]byte, error) {
2268 switch s {
2269 case XDbgBlockGraphNodeTypeBlockBackend:
2270 return []byte(`"block-backend"`), nil
2271 case XDbgBlockGraphNodeTypeBlockJob:
2272 return []byte(`"block-job"`), nil
2273 case XDbgBlockGraphNodeTypeBlockDriver:
2274 return []byte(`"block-driver"`), nil
2275 default:
2276 fmt.Println("Failed to decode XDbgBlockGraphNodeType", s)
2277 }
2278 return nil, errors.New("Failed")
2279 }
2280
2281 func (s *XDbgBlockGraphNodeType) UnmarshalJSON(data []byte) error {
2282 var name string
2283
2284 if err := json.Unmarshal(data, &name); err != nil {
2285 return err
2286 }
2287
2288 switch name {
2289 case "block-backend":
2290 (*s) = XDbgBlockGraphNodeTypeBlockBackend
2291 case "block-job":
2292 (*s) = XDbgBlockGraphNodeTypeBlockJob
2293 case "block-driver":
2294 (*s) = XDbgBlockGraphNodeTypeBlockDriver
2295 default:
2296 fmt.Println("Failed to decode XDbgBlockGraphNodeType", *s)
2297 }
2298 return nil
2299 }
2300
2301
2302
2303
2304 type BlockPermission int32
2305
2306 const (
2307 BlockPermissionConsistentRead BlockPermission = iota
2308 BlockPermissionWrite
2309 BlockPermissionWriteUnchanged
2310 BlockPermissionResize
2311 )
2312
2313 func (s BlockPermission) MarshalJSON() ([]byte, error) {
2314 switch s {
2315 case BlockPermissionConsistentRead:
2316 return []byte(`"consistent-read"`), nil
2317 case BlockPermissionWrite:
2318 return []byte(`"write"`), nil
2319 case BlockPermissionWriteUnchanged:
2320 return []byte(`"write-unchanged"`), nil
2321 case BlockPermissionResize:
2322 return []byte(`"resize"`), nil
2323 default:
2324 fmt.Println("Failed to decode BlockPermission", s)
2325 }
2326 return nil, errors.New("Failed")
2327 }
2328
2329 func (s *BlockPermission) UnmarshalJSON(data []byte) error {
2330 var name string
2331
2332 if err := json.Unmarshal(data, &name); err != nil {
2333 return err
2334 }
2335
2336 switch name {
2337 case "consistent-read":
2338 (*s) = BlockPermissionConsistentRead
2339 case "write":
2340 (*s) = BlockPermissionWrite
2341 case "write-unchanged":
2342 (*s) = BlockPermissionWriteUnchanged
2343 case "resize":
2344 (*s) = BlockPermissionResize
2345 default:
2346 fmt.Println("Failed to decode BlockPermission", *s)
2347 }
2348 return nil
2349 }
2350
2351
2352
2353
2354 type BlockdevDiscardOptions int32
2355
2356 const (
2357 BlockdevDiscardOptionsIgnore BlockdevDiscardOptions = iota
2358 BlockdevDiscardOptionsUnmap
2359 )
2360
2361 func (s BlockdevDiscardOptions) MarshalJSON() ([]byte, error) {
2362 switch s {
2363 case BlockdevDiscardOptionsIgnore:
2364 return []byte(`"ignore"`), nil
2365 case BlockdevDiscardOptionsUnmap:
2366 return []byte(`"unmap"`), nil
2367 default:
2368 fmt.Println("Failed to decode BlockdevDiscardOptions", s)
2369 }
2370 return nil, errors.New("Failed")
2371 }
2372
2373 func (s *BlockdevDiscardOptions) UnmarshalJSON(data []byte) error {
2374 var name string
2375
2376 if err := json.Unmarshal(data, &name); err != nil {
2377 return err
2378 }
2379
2380 switch name {
2381 case "ignore":
2382 (*s) = BlockdevDiscardOptionsIgnore
2383 case "unmap":
2384 (*s) = BlockdevDiscardOptionsUnmap
2385 default:
2386 fmt.Println("Failed to decode BlockdevDiscardOptions", *s)
2387 }
2388 return nil
2389 }
2390
2391
2392
2393
2394
2395 type BlockdevDetectZeroesOptions int32
2396
2397 const (
2398 BlockdevDetectZeroesOptionsOff BlockdevDetectZeroesOptions = iota
2399 BlockdevDetectZeroesOptionsOn
2400 BlockdevDetectZeroesOptionsUnmap
2401 )
2402
2403 func (s BlockdevDetectZeroesOptions) MarshalJSON() ([]byte, error) {
2404 switch s {
2405 case BlockdevDetectZeroesOptionsOff:
2406 return []byte(`"off"`), nil
2407 case BlockdevDetectZeroesOptionsOn:
2408 return []byte(`"on"`), nil
2409 case BlockdevDetectZeroesOptionsUnmap:
2410 return []byte(`"unmap"`), nil
2411 default:
2412 fmt.Println("Failed to decode BlockdevDetectZeroesOptions", s)
2413 }
2414 return nil, errors.New("Failed")
2415 }
2416
2417 func (s *BlockdevDetectZeroesOptions) UnmarshalJSON(data []byte) error {
2418 var name string
2419
2420 if err := json.Unmarshal(data, &name); err != nil {
2421 return err
2422 }
2423
2424 switch name {
2425 case "off":
2426 (*s) = BlockdevDetectZeroesOptionsOff
2427 case "on":
2428 (*s) = BlockdevDetectZeroesOptionsOn
2429 case "unmap":
2430 (*s) = BlockdevDetectZeroesOptionsUnmap
2431 default:
2432 fmt.Println("Failed to decode BlockdevDetectZeroesOptions", *s)
2433 }
2434 return nil
2435 }
2436
2437
2438
2439
2440 type BlockdevAioOptions int32
2441
2442 const (
2443 BlockdevAioOptionsThreads BlockdevAioOptions = iota
2444 BlockdevAioOptionsNative
2445 BlockdevAioOptionsIo_Uring
2446 )
2447
2448 func (s BlockdevAioOptions) MarshalJSON() ([]byte, error) {
2449 switch s {
2450 case BlockdevAioOptionsThreads:
2451 return []byte(`"threads"`), nil
2452 case BlockdevAioOptionsNative:
2453 return []byte(`"native"`), nil
2454 case BlockdevAioOptionsIo_Uring:
2455 return []byte(`"io_uring"`), nil
2456 default:
2457 fmt.Println("Failed to decode BlockdevAioOptions", s)
2458 }
2459 return nil, errors.New("Failed")
2460 }
2461
2462 func (s *BlockdevAioOptions) UnmarshalJSON(data []byte) error {
2463 var name string
2464
2465 if err := json.Unmarshal(data, &name); err != nil {
2466 return err
2467 }
2468
2469 switch name {
2470 case "threads":
2471 (*s) = BlockdevAioOptionsThreads
2472 case "native":
2473 (*s) = BlockdevAioOptionsNative
2474 case "io_uring":
2475 (*s) = BlockdevAioOptionsIo_Uring
2476 default:
2477 fmt.Println("Failed to decode BlockdevAioOptions", *s)
2478 }
2479 return nil
2480 }
2481
2482
2483
2484
2485 type BlockdevDriver int32
2486
2487 const (
2488 BlockdevDriverBlkdebug BlockdevDriver = iota
2489 BlockdevDriverBlklogwrites
2490 BlockdevDriverBlkreplay
2491 BlockdevDriverBlkverify
2492 BlockdevDriverBochs
2493 BlockdevDriverCloop
2494 BlockdevDriverCompress
2495 BlockdevDriverCopyBeforeWrite
2496 BlockdevDriverCopyOnRead
2497 BlockdevDriverDmg
2498 BlockdevDriverFile
2499 BlockdevDriverSnapshotAccess
2500 BlockdevDriverFtp
2501 BlockdevDriverFtps
2502 BlockdevDriverGluster
2503 BlockdevDriverHost_Cdrom
2504 BlockdevDriverHost_Device
2505 BlockdevDriverHttp
2506 BlockdevDriverHttps
2507 BlockdevDriverIscsi
2508 BlockdevDriverLuks
2509 BlockdevDriverNbd
2510 BlockdevDriverNfs
2511 BlockdevDriverNullAio
2512 BlockdevDriverNullCo
2513 BlockdevDriverNvme
2514 BlockdevDriverParallels
2515 BlockdevDriverPreallocate
2516 BlockdevDriverQcow
2517 BlockdevDriverQcow2
2518 BlockdevDriverQed
2519 BlockdevDriverQuorum
2520 BlockdevDriverRaw
2521 BlockdevDriverRbd
2522 BlockdevDriverReplication
2523 BlockdevDriverSsh
2524 BlockdevDriverThrottle
2525 BlockdevDriverVdi
2526 BlockdevDriverVhdx
2527 BlockdevDriverVmdk
2528 BlockdevDriverVpc
2529 BlockdevDriverVvfat
2530 )
2531
2532 func (s BlockdevDriver) MarshalJSON() ([]byte, error) {
2533 switch s {
2534 case BlockdevDriverBlkdebug:
2535 return []byte(`"blkdebug"`), nil
2536 case BlockdevDriverBlklogwrites:
2537 return []byte(`"blklogwrites"`), nil
2538 case BlockdevDriverBlkreplay:
2539 return []byte(`"blkreplay"`), nil
2540 case BlockdevDriverBlkverify:
2541 return []byte(`"blkverify"`), nil
2542 case BlockdevDriverBochs:
2543 return []byte(`"bochs"`), nil
2544 case BlockdevDriverCloop:
2545 return []byte(`"cloop"`), nil
2546 case BlockdevDriverCompress:
2547 return []byte(`"compress"`), nil
2548 case BlockdevDriverCopyBeforeWrite:
2549 return []byte(`"copy-before-write"`), nil
2550 case BlockdevDriverCopyOnRead:
2551 return []byte(`"copy-on-read"`), nil
2552 case BlockdevDriverDmg:
2553 return []byte(`"dmg"`), nil
2554 case BlockdevDriverFile:
2555 return []byte(`"file"`), nil
2556 case BlockdevDriverSnapshotAccess:
2557 return []byte(`"snapshot-access"`), nil
2558 case BlockdevDriverFtp:
2559 return []byte(`"ftp"`), nil
2560 case BlockdevDriverFtps:
2561 return []byte(`"ftps"`), nil
2562 case BlockdevDriverGluster:
2563 return []byte(`"gluster"`), nil
2564 case BlockdevDriverHost_Cdrom:
2565 return []byte(`"host_cdrom"`), nil
2566 case BlockdevDriverHost_Device:
2567 return []byte(`"host_device"`), nil
2568 case BlockdevDriverHttp:
2569 return []byte(`"http"`), nil
2570 case BlockdevDriverHttps:
2571 return []byte(`"https"`), nil
2572 case BlockdevDriverIscsi:
2573 return []byte(`"iscsi"`), nil
2574 case BlockdevDriverLuks:
2575 return []byte(`"luks"`), nil
2576 case BlockdevDriverNbd:
2577 return []byte(`"nbd"`), nil
2578 case BlockdevDriverNfs:
2579 return []byte(`"nfs"`), nil
2580 case BlockdevDriverNullAio:
2581 return []byte(`"null-aio"`), nil
2582 case BlockdevDriverNullCo:
2583 return []byte(`"null-co"`), nil
2584 case BlockdevDriverNvme:
2585 return []byte(`"nvme"`), nil
2586 case BlockdevDriverParallels:
2587 return []byte(`"parallels"`), nil
2588 case BlockdevDriverPreallocate:
2589 return []byte(`"preallocate"`), nil
2590 case BlockdevDriverQcow:
2591 return []byte(`"qcow"`), nil
2592 case BlockdevDriverQcow2:
2593 return []byte(`"qcow2"`), nil
2594 case BlockdevDriverQed:
2595 return []byte(`"qed"`), nil
2596 case BlockdevDriverQuorum:
2597 return []byte(`"quorum"`), nil
2598 case BlockdevDriverRaw:
2599 return []byte(`"raw"`), nil
2600 case BlockdevDriverRbd:
2601 return []byte(`"rbd"`), nil
2602 case BlockdevDriverReplication:
2603 return []byte(`"replication"`), nil
2604 case BlockdevDriverSsh:
2605 return []byte(`"ssh"`), nil
2606 case BlockdevDriverThrottle:
2607 return []byte(`"throttle"`), nil
2608 case BlockdevDriverVdi:
2609 return []byte(`"vdi"`), nil
2610 case BlockdevDriverVhdx:
2611 return []byte(`"vhdx"`), nil
2612 case BlockdevDriverVmdk:
2613 return []byte(`"vmdk"`), nil
2614 case BlockdevDriverVpc:
2615 return []byte(`"vpc"`), nil
2616 case BlockdevDriverVvfat:
2617 return []byte(`"vvfat"`), nil
2618 default:
2619 fmt.Println("Failed to decode BlockdevDriver", s)
2620 }
2621 return nil, errors.New("Failed")
2622 }
2623
2624 func (s *BlockdevDriver) UnmarshalJSON(data []byte) error {
2625 var name string
2626
2627 if err := json.Unmarshal(data, &name); err != nil {
2628 return err
2629 }
2630
2631 switch name {
2632 case "blkdebug":
2633 (*s) = BlockdevDriverBlkdebug
2634 case "blklogwrites":
2635 (*s) = BlockdevDriverBlklogwrites
2636 case "blkreplay":
2637 (*s) = BlockdevDriverBlkreplay
2638 case "blkverify":
2639 (*s) = BlockdevDriverBlkverify
2640 case "bochs":
2641 (*s) = BlockdevDriverBochs
2642 case "cloop":
2643 (*s) = BlockdevDriverCloop
2644 case "compress":
2645 (*s) = BlockdevDriverCompress
2646 case "copy-before-write":
2647 (*s) = BlockdevDriverCopyBeforeWrite
2648 case "copy-on-read":
2649 (*s) = BlockdevDriverCopyOnRead
2650 case "dmg":
2651 (*s) = BlockdevDriverDmg
2652 case "file":
2653 (*s) = BlockdevDriverFile
2654 case "snapshot-access":
2655 (*s) = BlockdevDriverSnapshotAccess
2656 case "ftp":
2657 (*s) = BlockdevDriverFtp
2658 case "ftps":
2659 (*s) = BlockdevDriverFtps
2660 case "gluster":
2661 (*s) = BlockdevDriverGluster
2662 case "host_cdrom":
2663 (*s) = BlockdevDriverHost_Cdrom
2664 case "host_device":
2665 (*s) = BlockdevDriverHost_Device
2666 case "http":
2667 (*s) = BlockdevDriverHttp
2668 case "https":
2669 (*s) = BlockdevDriverHttps
2670 case "iscsi":
2671 (*s) = BlockdevDriverIscsi
2672 case "luks":
2673 (*s) = BlockdevDriverLuks
2674 case "nbd":
2675 (*s) = BlockdevDriverNbd
2676 case "nfs":
2677 (*s) = BlockdevDriverNfs
2678 case "null-aio":
2679 (*s) = BlockdevDriverNullAio
2680 case "null-co":
2681 (*s) = BlockdevDriverNullCo
2682 case "nvme":
2683 (*s) = BlockdevDriverNvme
2684 case "parallels":
2685 (*s) = BlockdevDriverParallels
2686 case "preallocate":
2687 (*s) = BlockdevDriverPreallocate
2688 case "qcow":
2689 (*s) = BlockdevDriverQcow
2690 case "qcow2":
2691 (*s) = BlockdevDriverQcow2
2692 case "qed":
2693 (*s) = BlockdevDriverQed
2694 case "quorum":
2695 (*s) = BlockdevDriverQuorum
2696 case "raw":
2697 (*s) = BlockdevDriverRaw
2698 case "rbd":
2699 (*s) = BlockdevDriverRbd
2700 case "replication":
2701 (*s) = BlockdevDriverReplication
2702 case "ssh":
2703 (*s) = BlockdevDriverSsh
2704 case "throttle":
2705 (*s) = BlockdevDriverThrottle
2706 case "vdi":
2707 (*s) = BlockdevDriverVdi
2708 case "vhdx":
2709 (*s) = BlockdevDriverVhdx
2710 case "vmdk":
2711 (*s) = BlockdevDriverVmdk
2712 case "vpc":
2713 (*s) = BlockdevDriverVpc
2714 case "vvfat":
2715 (*s) = BlockdevDriverVvfat
2716 default:
2717 fmt.Println("Failed to decode BlockdevDriver", *s)
2718 }
2719 return nil
2720 }
2721
2722
2723
2724
2725 type Qcow2OverlapCheckMode int32
2726
2727 const (
2728 Qcow2OverlapCheckModeNone Qcow2OverlapCheckMode = iota
2729 Qcow2OverlapCheckModeConstant
2730 Qcow2OverlapCheckModeCached
2731 Qcow2OverlapCheckModeAll
2732 )
2733
2734 func (s Qcow2OverlapCheckMode) MarshalJSON() ([]byte, error) {
2735 switch s {
2736 case Qcow2OverlapCheckModeNone:
2737 return []byte(`"none"`), nil
2738 case Qcow2OverlapCheckModeConstant:
2739 return []byte(`"constant"`), nil
2740 case Qcow2OverlapCheckModeCached:
2741 return []byte(`"cached"`), nil
2742 case Qcow2OverlapCheckModeAll:
2743 return []byte(`"all"`), nil
2744 default:
2745 fmt.Println("Failed to decode Qcow2OverlapCheckMode", s)
2746 }
2747 return nil, errors.New("Failed")
2748 }
2749
2750 func (s *Qcow2OverlapCheckMode) UnmarshalJSON(data []byte) error {
2751 var name string
2752
2753 if err := json.Unmarshal(data, &name); err != nil {
2754 return err
2755 }
2756
2757 switch name {
2758 case "none":
2759 (*s) = Qcow2OverlapCheckModeNone
2760 case "constant":
2761 (*s) = Qcow2OverlapCheckModeConstant
2762 case "cached":
2763 (*s) = Qcow2OverlapCheckModeCached
2764 case "all":
2765 (*s) = Qcow2OverlapCheckModeAll
2766 default:
2767 fmt.Println("Failed to decode Qcow2OverlapCheckMode", *s)
2768 }
2769 return nil
2770 }
2771
2772
2773 type BlockdevQcowEncryptionFormat int32
2774
2775 const (
2776 BlockdevQcowEncryptionFormatAes BlockdevQcowEncryptionFormat = iota
2777 )
2778
2779 func (s BlockdevQcowEncryptionFormat) MarshalJSON() ([]byte, error) {
2780 switch s {
2781 case BlockdevQcowEncryptionFormatAes:
2782 return []byte(`"aes"`), nil
2783 default:
2784 fmt.Println("Failed to decode BlockdevQcowEncryptionFormat", s)
2785 }
2786 return nil, errors.New("Failed")
2787 }
2788
2789 func (s *BlockdevQcowEncryptionFormat) UnmarshalJSON(data []byte) error {
2790 var name string
2791
2792 if err := json.Unmarshal(data, &name); err != nil {
2793 return err
2794 }
2795
2796 switch name {
2797 case "aes":
2798 (*s) = BlockdevQcowEncryptionFormatAes
2799 default:
2800 fmt.Println("Failed to decode BlockdevQcowEncryptionFormat", *s)
2801 }
2802 return nil
2803 }
2804
2805
2806 type BlockdevQcow2EncryptionFormat int32
2807
2808 const (
2809 BlockdevQcow2EncryptionFormatAes BlockdevQcow2EncryptionFormat = iota
2810 BlockdevQcow2EncryptionFormatLuks
2811 )
2812
2813 func (s BlockdevQcow2EncryptionFormat) MarshalJSON() ([]byte, error) {
2814 switch s {
2815 case BlockdevQcow2EncryptionFormatAes:
2816 return []byte(`"aes"`), nil
2817 case BlockdevQcow2EncryptionFormatLuks:
2818 return []byte(`"luks"`), nil
2819 default:
2820 fmt.Println("Failed to decode BlockdevQcow2EncryptionFormat", s)
2821 }
2822 return nil, errors.New("Failed")
2823 }
2824
2825 func (s *BlockdevQcow2EncryptionFormat) UnmarshalJSON(data []byte) error {
2826 var name string
2827
2828 if err := json.Unmarshal(data, &name); err != nil {
2829 return err
2830 }
2831
2832 switch name {
2833 case "aes":
2834 (*s) = BlockdevQcow2EncryptionFormatAes
2835 case "luks":
2836 (*s) = BlockdevQcow2EncryptionFormatLuks
2837 default:
2838 fmt.Println("Failed to decode BlockdevQcow2EncryptionFormat", *s)
2839 }
2840 return nil
2841 }
2842
2843
2844 type SshHostKeyCheckMode int32
2845
2846 const (
2847 SshHostKeyCheckModeNone SshHostKeyCheckMode = iota
2848 SshHostKeyCheckModeHash
2849 SshHostKeyCheckModeKnown_Hosts
2850 )
2851
2852 func (s SshHostKeyCheckMode) MarshalJSON() ([]byte, error) {
2853 switch s {
2854 case SshHostKeyCheckModeNone:
2855 return []byte(`"none"`), nil
2856 case SshHostKeyCheckModeHash:
2857 return []byte(`"hash"`), nil
2858 case SshHostKeyCheckModeKnown_Hosts:
2859 return []byte(`"known_hosts"`), nil
2860 default:
2861 fmt.Println("Failed to decode SshHostKeyCheckMode", s)
2862 }
2863 return nil, errors.New("Failed")
2864 }
2865
2866 func (s *SshHostKeyCheckMode) UnmarshalJSON(data []byte) error {
2867 var name string
2868
2869 if err := json.Unmarshal(data, &name); err != nil {
2870 return err
2871 }
2872
2873 switch name {
2874 case "none":
2875 (*s) = SshHostKeyCheckModeNone
2876 case "hash":
2877 (*s) = SshHostKeyCheckModeHash
2878 case "known_hosts":
2879 (*s) = SshHostKeyCheckModeKnown_Hosts
2880 default:
2881 fmt.Println("Failed to decode SshHostKeyCheckMode", *s)
2882 }
2883 return nil
2884 }
2885
2886
2887 type SshHostKeyCheckHashType int32
2888
2889 const (
2890 SshHostKeyCheckHashTypeMd5 SshHostKeyCheckHashType = iota
2891 SshHostKeyCheckHashTypeSha1
2892 SshHostKeyCheckHashTypeSha256
2893 )
2894
2895 func (s SshHostKeyCheckHashType) MarshalJSON() ([]byte, error) {
2896 switch s {
2897 case SshHostKeyCheckHashTypeMd5:
2898 return []byte(`"md5"`), nil
2899 case SshHostKeyCheckHashTypeSha1:
2900 return []byte(`"sha1"`), nil
2901 case SshHostKeyCheckHashTypeSha256:
2902 return []byte(`"sha256"`), nil
2903 default:
2904 fmt.Println("Failed to decode SshHostKeyCheckHashType", s)
2905 }
2906 return nil, errors.New("Failed")
2907 }
2908
2909 func (s *SshHostKeyCheckHashType) UnmarshalJSON(data []byte) error {
2910 var name string
2911
2912 if err := json.Unmarshal(data, &name); err != nil {
2913 return err
2914 }
2915
2916 switch name {
2917 case "md5":
2918 (*s) = SshHostKeyCheckHashTypeMd5
2919 case "sha1":
2920 (*s) = SshHostKeyCheckHashTypeSha1
2921 case "sha256":
2922 (*s) = SshHostKeyCheckHashTypeSha256
2923 default:
2924 fmt.Println("Failed to decode SshHostKeyCheckHashType", *s)
2925 }
2926 return nil
2927 }
2928
2929
2930
2931
2932 type BlkdebugEvent int32
2933
2934 const (
2935 BlkdebugEventL1_Update BlkdebugEvent = iota
2936 BlkdebugEventL1_Grow_Alloc_Table
2937 BlkdebugEventL1_Grow_Write_Table
2938 BlkdebugEventL1_Grow_Activate_Table
2939 BlkdebugEventL2_Load
2940 BlkdebugEventL2_Update
2941 BlkdebugEventL2_Update_Compressed
2942 BlkdebugEventL2_Alloc_Cow_Read
2943 BlkdebugEventL2_Alloc_Write
2944 BlkdebugEventRead_Aio
2945 BlkdebugEventRead_Backing_Aio
2946 BlkdebugEventRead_Compressed
2947 BlkdebugEventWrite_Aio
2948 BlkdebugEventWrite_Compressed
2949 BlkdebugEventVmstate_Load
2950 BlkdebugEventVmstate_Save
2951 BlkdebugEventCow_Read
2952 BlkdebugEventCow_Write
2953 BlkdebugEventReftable_Load
2954 BlkdebugEventReftable_Grow
2955 BlkdebugEventReftable_Update
2956 BlkdebugEventRefblock_Load
2957 BlkdebugEventRefblock_Update
2958 BlkdebugEventRefblock_Update_Part
2959 BlkdebugEventRefblock_Alloc
2960 BlkdebugEventRefblock_Alloc_Hookup
2961 BlkdebugEventRefblock_Alloc_Write
2962 BlkdebugEventRefblock_Alloc_Write_Blocks
2963 BlkdebugEventRefblock_Alloc_Write_Table
2964 BlkdebugEventRefblock_Alloc_Switch_Table
2965 BlkdebugEventCluster_Alloc
2966 BlkdebugEventCluster_Alloc_Bytes
2967 BlkdebugEventCluster_Free
2968 BlkdebugEventFlush_To_Os
2969 BlkdebugEventFlush_To_Disk
2970 BlkdebugEventPwritev_Rmw_Head
2971 BlkdebugEventPwritev_Rmw_After_Head
2972 BlkdebugEventPwritev_Rmw_Tail
2973 BlkdebugEventPwritev_Rmw_After_Tail
2974 BlkdebugEventPwritev
2975 BlkdebugEventPwritev_Zero
2976 BlkdebugEventPwritev_Done
2977 BlkdebugEventEmpty_Image_Prepare
2978 BlkdebugEventL1_Shrink_Write_Table
2979 BlkdebugEventL1_Shrink_Free_L2_Clusters
2980 BlkdebugEventCor_Write
2981 BlkdebugEventCluster_Alloc_Space
2982 BlkdebugEventNone
2983 )
2984
2985 func (s BlkdebugEvent) MarshalJSON() ([]byte, error) {
2986 switch s {
2987 case BlkdebugEventL1_Update:
2988 return []byte(`"l1_update"`), nil
2989 case BlkdebugEventL1_Grow_Alloc_Table:
2990 return []byte(`"l1_grow_alloc_table"`), nil
2991 case BlkdebugEventL1_Grow_Write_Table:
2992 return []byte(`"l1_grow_write_table"`), nil
2993 case BlkdebugEventL1_Grow_Activate_Table:
2994 return []byte(`"l1_grow_activate_table"`), nil
2995 case BlkdebugEventL2_Load:
2996 return []byte(`"l2_load"`), nil
2997 case BlkdebugEventL2_Update:
2998 return []byte(`"l2_update"`), nil
2999 case BlkdebugEventL2_Update_Compressed:
3000 return []byte(`"l2_update_compressed"`), nil
3001 case BlkdebugEventL2_Alloc_Cow_Read:
3002 return []byte(`"l2_alloc_cow_read"`), nil
3003 case BlkdebugEventL2_Alloc_Write:
3004 return []byte(`"l2_alloc_write"`), nil
3005 case BlkdebugEventRead_Aio:
3006 return []byte(`"read_aio"`), nil
3007 case BlkdebugEventRead_Backing_Aio:
3008 return []byte(`"read_backing_aio"`), nil
3009 case BlkdebugEventRead_Compressed:
3010 return []byte(`"read_compressed"`), nil
3011 case BlkdebugEventWrite_Aio:
3012 return []byte(`"write_aio"`), nil
3013 case BlkdebugEventWrite_Compressed:
3014 return []byte(`"write_compressed"`), nil
3015 case BlkdebugEventVmstate_Load:
3016 return []byte(`"vmstate_load"`), nil
3017 case BlkdebugEventVmstate_Save:
3018 return []byte(`"vmstate_save"`), nil
3019 case BlkdebugEventCow_Read:
3020 return []byte(`"cow_read"`), nil
3021 case BlkdebugEventCow_Write:
3022 return []byte(`"cow_write"`), nil
3023 case BlkdebugEventReftable_Load:
3024 return []byte(`"reftable_load"`), nil
3025 case BlkdebugEventReftable_Grow:
3026 return []byte(`"reftable_grow"`), nil
3027 case BlkdebugEventReftable_Update:
3028 return []byte(`"reftable_update"`), nil
3029 case BlkdebugEventRefblock_Load:
3030 return []byte(`"refblock_load"`), nil
3031 case BlkdebugEventRefblock_Update:
3032 return []byte(`"refblock_update"`), nil
3033 case BlkdebugEventRefblock_Update_Part:
3034 return []byte(`"refblock_update_part"`), nil
3035 case BlkdebugEventRefblock_Alloc:
3036 return []byte(`"refblock_alloc"`), nil
3037 case BlkdebugEventRefblock_Alloc_Hookup:
3038 return []byte(`"refblock_alloc_hookup"`), nil
3039 case BlkdebugEventRefblock_Alloc_Write:
3040 return []byte(`"refblock_alloc_write"`), nil
3041 case BlkdebugEventRefblock_Alloc_Write_Blocks:
3042 return []byte(`"refblock_alloc_write_blocks"`), nil
3043 case BlkdebugEventRefblock_Alloc_Write_Table:
3044 return []byte(`"refblock_alloc_write_table"`), nil
3045 case BlkdebugEventRefblock_Alloc_Switch_Table:
3046 return []byte(`"refblock_alloc_switch_table"`), nil
3047 case BlkdebugEventCluster_Alloc:
3048 return []byte(`"cluster_alloc"`), nil
3049 case BlkdebugEventCluster_Alloc_Bytes:
3050 return []byte(`"cluster_alloc_bytes"`), nil
3051 case BlkdebugEventCluster_Free:
3052 return []byte(`"cluster_free"`), nil
3053 case BlkdebugEventFlush_To_Os:
3054 return []byte(`"flush_to_os"`), nil
3055 case BlkdebugEventFlush_To_Disk:
3056 return []byte(`"flush_to_disk"`), nil
3057 case BlkdebugEventPwritev_Rmw_Head:
3058 return []byte(`"pwritev_rmw_head"`), nil
3059 case BlkdebugEventPwritev_Rmw_After_Head:
3060 return []byte(`"pwritev_rmw_after_head"`), nil
3061 case BlkdebugEventPwritev_Rmw_Tail:
3062 return []byte(`"pwritev_rmw_tail"`), nil
3063 case BlkdebugEventPwritev_Rmw_After_Tail:
3064 return []byte(`"pwritev_rmw_after_tail"`), nil
3065 case BlkdebugEventPwritev:
3066 return []byte(`"pwritev"`), nil
3067 case BlkdebugEventPwritev_Zero:
3068 return []byte(`"pwritev_zero"`), nil
3069 case BlkdebugEventPwritev_Done:
3070 return []byte(`"pwritev_done"`), nil
3071 case BlkdebugEventEmpty_Image_Prepare:
3072 return []byte(`"empty_image_prepare"`), nil
3073 case BlkdebugEventL1_Shrink_Write_Table:
3074 return []byte(`"l1_shrink_write_table"`), nil
3075 case BlkdebugEventL1_Shrink_Free_L2_Clusters:
3076 return []byte(`"l1_shrink_free_l2_clusters"`), nil
3077 case BlkdebugEventCor_Write:
3078 return []byte(`"cor_write"`), nil
3079 case BlkdebugEventCluster_Alloc_Space:
3080 return []byte(`"cluster_alloc_space"`), nil
3081 case BlkdebugEventNone:
3082 return []byte(`"none"`), nil
3083 default:
3084 fmt.Println("Failed to decode BlkdebugEvent", s)
3085 }
3086 return nil, errors.New("Failed")
3087 }
3088
3089 func (s *BlkdebugEvent) UnmarshalJSON(data []byte) error {
3090 var name string
3091
3092 if err := json.Unmarshal(data, &name); err != nil {
3093 return err
3094 }
3095
3096 switch name {
3097 case "l1_update":
3098 (*s) = BlkdebugEventL1_Update
3099 case "l1_grow_alloc_table":
3100 (*s) = BlkdebugEventL1_Grow_Alloc_Table
3101 case "l1_grow_write_table":
3102 (*s) = BlkdebugEventL1_Grow_Write_Table
3103 case "l1_grow_activate_table":
3104 (*s) = BlkdebugEventL1_Grow_Activate_Table
3105 case "l2_load":
3106 (*s) = BlkdebugEventL2_Load
3107 case "l2_update":
3108 (*s) = BlkdebugEventL2_Update
3109 case "l2_update_compressed":
3110 (*s) = BlkdebugEventL2_Update_Compressed
3111 case "l2_alloc_cow_read":
3112 (*s) = BlkdebugEventL2_Alloc_Cow_Read
3113 case "l2_alloc_write":
3114 (*s) = BlkdebugEventL2_Alloc_Write
3115 case "read_aio":
3116 (*s) = BlkdebugEventRead_Aio
3117 case "read_backing_aio":
3118 (*s) = BlkdebugEventRead_Backing_Aio
3119 case "read_compressed":
3120 (*s) = BlkdebugEventRead_Compressed
3121 case "write_aio":
3122 (*s) = BlkdebugEventWrite_Aio
3123 case "write_compressed":
3124 (*s) = BlkdebugEventWrite_Compressed
3125 case "vmstate_load":
3126 (*s) = BlkdebugEventVmstate_Load
3127 case "vmstate_save":
3128 (*s) = BlkdebugEventVmstate_Save
3129 case "cow_read":
3130 (*s) = BlkdebugEventCow_Read
3131 case "cow_write":
3132 (*s) = BlkdebugEventCow_Write
3133 case "reftable_load":
3134 (*s) = BlkdebugEventReftable_Load
3135 case "reftable_grow":
3136 (*s) = BlkdebugEventReftable_Grow
3137 case "reftable_update":
3138 (*s) = BlkdebugEventReftable_Update
3139 case "refblock_load":
3140 (*s) = BlkdebugEventRefblock_Load
3141 case "refblock_update":
3142 (*s) = BlkdebugEventRefblock_Update
3143 case "refblock_update_part":
3144 (*s) = BlkdebugEventRefblock_Update_Part
3145 case "refblock_alloc":
3146 (*s) = BlkdebugEventRefblock_Alloc
3147 case "refblock_alloc_hookup":
3148 (*s) = BlkdebugEventRefblock_Alloc_Hookup
3149 case "refblock_alloc_write":
3150 (*s) = BlkdebugEventRefblock_Alloc_Write
3151 case "refblock_alloc_write_blocks":
3152 (*s) = BlkdebugEventRefblock_Alloc_Write_Blocks
3153 case "refblock_alloc_write_table":
3154 (*s) = BlkdebugEventRefblock_Alloc_Write_Table
3155 case "refblock_alloc_switch_table":
3156 (*s) = BlkdebugEventRefblock_Alloc_Switch_Table
3157 case "cluster_alloc":
3158 (*s) = BlkdebugEventCluster_Alloc
3159 case "cluster_alloc_bytes":
3160 (*s) = BlkdebugEventCluster_Alloc_Bytes
3161 case "cluster_free":
3162 (*s) = BlkdebugEventCluster_Free
3163 case "flush_to_os":
3164 (*s) = BlkdebugEventFlush_To_Os
3165 case "flush_to_disk":
3166 (*s) = BlkdebugEventFlush_To_Disk
3167 case "pwritev_rmw_head":
3168 (*s) = BlkdebugEventPwritev_Rmw_Head
3169 case "pwritev_rmw_after_head":
3170 (*s) = BlkdebugEventPwritev_Rmw_After_Head
3171 case "pwritev_rmw_tail":
3172 (*s) = BlkdebugEventPwritev_Rmw_Tail
3173 case "pwritev_rmw_after_tail":
3174 (*s) = BlkdebugEventPwritev_Rmw_After_Tail
3175 case "pwritev":
3176 (*s) = BlkdebugEventPwritev
3177 case "pwritev_zero":
3178 (*s) = BlkdebugEventPwritev_Zero
3179 case "pwritev_done":
3180 (*s) = BlkdebugEventPwritev_Done
3181 case "empty_image_prepare":
3182 (*s) = BlkdebugEventEmpty_Image_Prepare
3183 case "l1_shrink_write_table":
3184 (*s) = BlkdebugEventL1_Shrink_Write_Table
3185 case "l1_shrink_free_l2_clusters":
3186 (*s) = BlkdebugEventL1_Shrink_Free_L2_Clusters
3187 case "cor_write":
3188 (*s) = BlkdebugEventCor_Write
3189 case "cluster_alloc_space":
3190 (*s) = BlkdebugEventCluster_Alloc_Space
3191 case "none":
3192 (*s) = BlkdebugEventNone
3193 default:
3194 fmt.Println("Failed to decode BlkdebugEvent", *s)
3195 }
3196 return nil
3197 }
3198
3199
3200
3201
3202 type BlkdebugIOType int32
3203
3204 const (
3205 BlkdebugIOTypeRead BlkdebugIOType = iota
3206 BlkdebugIOTypeWrite
3207 BlkdebugIOTypeWriteZeroes
3208 BlkdebugIOTypeDiscard
3209 BlkdebugIOTypeFlush
3210 BlkdebugIOTypeBlockStatus
3211 )
3212
3213 func (s BlkdebugIOType) MarshalJSON() ([]byte, error) {
3214 switch s {
3215 case BlkdebugIOTypeRead:
3216 return []byte(`"read"`), nil
3217 case BlkdebugIOTypeWrite:
3218 return []byte(`"write"`), nil
3219 case BlkdebugIOTypeWriteZeroes:
3220 return []byte(`"write-zeroes"`), nil
3221 case BlkdebugIOTypeDiscard:
3222 return []byte(`"discard"`), nil
3223 case BlkdebugIOTypeFlush:
3224 return []byte(`"flush"`), nil
3225 case BlkdebugIOTypeBlockStatus:
3226 return []byte(`"block-status"`), nil
3227 default:
3228 fmt.Println("Failed to decode BlkdebugIOType", s)
3229 }
3230 return nil, errors.New("Failed")
3231 }
3232
3233 func (s *BlkdebugIOType) UnmarshalJSON(data []byte) error {
3234 var name string
3235
3236 if err := json.Unmarshal(data, &name); err != nil {
3237 return err
3238 }
3239
3240 switch name {
3241 case "read":
3242 (*s) = BlkdebugIOTypeRead
3243 case "write":
3244 (*s) = BlkdebugIOTypeWrite
3245 case "write-zeroes":
3246 (*s) = BlkdebugIOTypeWriteZeroes
3247 case "discard":
3248 (*s) = BlkdebugIOTypeDiscard
3249 case "flush":
3250 (*s) = BlkdebugIOTypeFlush
3251 case "block-status":
3252 (*s) = BlkdebugIOTypeBlockStatus
3253 default:
3254 fmt.Println("Failed to decode BlkdebugIOType", *s)
3255 }
3256 return nil
3257 }
3258
3259
3260
3261
3262 type QuorumReadPattern int32
3263
3264 const (
3265 QuorumReadPatternQuorum QuorumReadPattern = iota
3266 QuorumReadPatternFifo
3267 )
3268
3269 func (s QuorumReadPattern) MarshalJSON() ([]byte, error) {
3270 switch s {
3271 case QuorumReadPatternQuorum:
3272 return []byte(`"quorum"`), nil
3273 case QuorumReadPatternFifo:
3274 return []byte(`"fifo"`), nil
3275 default:
3276 fmt.Println("Failed to decode QuorumReadPattern", s)
3277 }
3278 return nil, errors.New("Failed")
3279 }
3280
3281 func (s *QuorumReadPattern) UnmarshalJSON(data []byte) error {
3282 var name string
3283
3284 if err := json.Unmarshal(data, &name); err != nil {
3285 return err
3286 }
3287
3288 switch name {
3289 case "quorum":
3290 (*s) = QuorumReadPatternQuorum
3291 case "fifo":
3292 (*s) = QuorumReadPatternFifo
3293 default:
3294 fmt.Println("Failed to decode QuorumReadPattern", *s)
3295 }
3296 return nil
3297 }
3298
3299
3300
3301
3302 type IscsiTransport int32
3303
3304 const (
3305 IscsiTransportTcp IscsiTransport = iota
3306 IscsiTransportIser
3307 )
3308
3309 func (s IscsiTransport) MarshalJSON() ([]byte, error) {
3310 switch s {
3311 case IscsiTransportTcp:
3312 return []byte(`"tcp"`), nil
3313 case IscsiTransportIser:
3314 return []byte(`"iser"`), nil
3315 default:
3316 fmt.Println("Failed to decode IscsiTransport", s)
3317 }
3318 return nil, errors.New("Failed")
3319 }
3320
3321 func (s *IscsiTransport) UnmarshalJSON(data []byte) error {
3322 var name string
3323
3324 if err := json.Unmarshal(data, &name); err != nil {
3325 return err
3326 }
3327
3328 switch name {
3329 case "tcp":
3330 (*s) = IscsiTransportTcp
3331 case "iser":
3332 (*s) = IscsiTransportIser
3333 default:
3334 fmt.Println("Failed to decode IscsiTransport", *s)
3335 }
3336 return nil
3337 }
3338
3339
3340
3341
3342 type IscsiHeaderDigest int32
3343
3344 const (
3345 IscsiHeaderDigestCrc32C IscsiHeaderDigest = iota
3346 IscsiHeaderDigestNone
3347 IscsiHeaderDigestCrc32CNone
3348 IscsiHeaderDigestNoneCrc32C
3349 )
3350
3351 func (s IscsiHeaderDigest) MarshalJSON() ([]byte, error) {
3352 switch s {
3353 case IscsiHeaderDigestCrc32C:
3354 return []byte(`"crc32c"`), nil
3355 case IscsiHeaderDigestNone:
3356 return []byte(`"none"`), nil
3357 case IscsiHeaderDigestCrc32CNone:
3358 return []byte(`"crc32c-none"`), nil
3359 case IscsiHeaderDigestNoneCrc32C:
3360 return []byte(`"none-crc32c"`), nil
3361 default:
3362 fmt.Println("Failed to decode IscsiHeaderDigest", s)
3363 }
3364 return nil, errors.New("Failed")
3365 }
3366
3367 func (s *IscsiHeaderDigest) UnmarshalJSON(data []byte) error {
3368 var name string
3369
3370 if err := json.Unmarshal(data, &name); err != nil {
3371 return err
3372 }
3373
3374 switch name {
3375 case "crc32c":
3376 (*s) = IscsiHeaderDigestCrc32C
3377 case "none":
3378 (*s) = IscsiHeaderDigestNone
3379 case "crc32c-none":
3380 (*s) = IscsiHeaderDigestCrc32CNone
3381 case "none-crc32c":
3382 (*s) = IscsiHeaderDigestNoneCrc32C
3383 default:
3384 fmt.Println("Failed to decode IscsiHeaderDigest", *s)
3385 }
3386 return nil
3387 }
3388
3389
3390 type RbdAuthMode int32
3391
3392 const (
3393 RbdAuthModeCephx RbdAuthMode = iota
3394 RbdAuthModeNone
3395 )
3396
3397 func (s RbdAuthMode) MarshalJSON() ([]byte, error) {
3398 switch s {
3399 case RbdAuthModeCephx:
3400 return []byte(`"cephx"`), nil
3401 case RbdAuthModeNone:
3402 return []byte(`"none"`), nil
3403 default:
3404 fmt.Println("Failed to decode RbdAuthMode", s)
3405 }
3406 return nil, errors.New("Failed")
3407 }
3408
3409 func (s *RbdAuthMode) UnmarshalJSON(data []byte) error {
3410 var name string
3411
3412 if err := json.Unmarshal(data, &name); err != nil {
3413 return err
3414 }
3415
3416 switch name {
3417 case "cephx":
3418 (*s) = RbdAuthModeCephx
3419 case "none":
3420 (*s) = RbdAuthModeNone
3421 default:
3422 fmt.Println("Failed to decode RbdAuthMode", *s)
3423 }
3424 return nil
3425 }
3426
3427
3428 type RbdImageEncryptionFormat int32
3429
3430 const (
3431 RbdImageEncryptionFormatLuks RbdImageEncryptionFormat = iota
3432 RbdImageEncryptionFormatLuks2
3433 )
3434
3435 func (s RbdImageEncryptionFormat) MarshalJSON() ([]byte, error) {
3436 switch s {
3437 case RbdImageEncryptionFormatLuks:
3438 return []byte(`"luks"`), nil
3439 case RbdImageEncryptionFormatLuks2:
3440 return []byte(`"luks2"`), nil
3441 default:
3442 fmt.Println("Failed to decode RbdImageEncryptionFormat", s)
3443 }
3444 return nil, errors.New("Failed")
3445 }
3446
3447 func (s *RbdImageEncryptionFormat) UnmarshalJSON(data []byte) error {
3448 var name string
3449
3450 if err := json.Unmarshal(data, &name); err != nil {
3451 return err
3452 }
3453
3454 switch name {
3455 case "luks":
3456 (*s) = RbdImageEncryptionFormatLuks
3457 case "luks2":
3458 (*s) = RbdImageEncryptionFormatLuks2
3459 default:
3460 fmt.Println("Failed to decode RbdImageEncryptionFormat", *s)
3461 }
3462 return nil
3463 }
3464
3465
3466
3467
3468 type ReplicationMode int32
3469
3470 const (
3471 ReplicationModePrimary ReplicationMode = iota
3472 ReplicationModeSecondary
3473 )
3474
3475 func (s ReplicationMode) MarshalJSON() ([]byte, error) {
3476 switch s {
3477 case ReplicationModePrimary:
3478 return []byte(`"primary"`), nil
3479 case ReplicationModeSecondary:
3480 return []byte(`"secondary"`), nil
3481 default:
3482 fmt.Println("Failed to decode ReplicationMode", s)
3483 }
3484 return nil, errors.New("Failed")
3485 }
3486
3487 func (s *ReplicationMode) UnmarshalJSON(data []byte) error {
3488 var name string
3489
3490 if err := json.Unmarshal(data, &name); err != nil {
3491 return err
3492 }
3493
3494 switch name {
3495 case "primary":
3496 (*s) = ReplicationModePrimary
3497 case "secondary":
3498 (*s) = ReplicationModeSecondary
3499 default:
3500 fmt.Println("Failed to decode ReplicationMode", *s)
3501 }
3502 return nil
3503 }
3504
3505
3506
3507
3508 type NFSTransport int32
3509
3510 const (
3511 NFSTransportInet NFSTransport = iota
3512 )
3513
3514 func (s NFSTransport) MarshalJSON() ([]byte, error) {
3515 switch s {
3516 case NFSTransportInet:
3517 return []byte(`"inet"`), nil
3518 default:
3519 fmt.Println("Failed to decode NFSTransport", s)
3520 }
3521 return nil, errors.New("Failed")
3522 }
3523
3524 func (s *NFSTransport) UnmarshalJSON(data []byte) error {
3525 var name string
3526
3527 if err := json.Unmarshal(data, &name); err != nil {
3528 return err
3529 }
3530
3531 switch name {
3532 case "inet":
3533 (*s) = NFSTransportInet
3534 default:
3535 fmt.Println("Failed to decode NFSTransport", *s)
3536 }
3537 return nil
3538 }
3539
3540
3541 type BlockdevQcow2Version int32
3542
3543 const (
3544 BlockdevQcow2VersionV2 BlockdevQcow2Version = iota
3545 BlockdevQcow2VersionV3
3546 )
3547
3548 func (s BlockdevQcow2Version) MarshalJSON() ([]byte, error) {
3549 switch s {
3550 case BlockdevQcow2VersionV2:
3551 return []byte(`"v2"`), nil
3552 case BlockdevQcow2VersionV3:
3553 return []byte(`"v3"`), nil
3554 default:
3555 fmt.Println("Failed to decode BlockdevQcow2Version", s)
3556 }
3557 return nil, errors.New("Failed")
3558 }
3559
3560 func (s *BlockdevQcow2Version) UnmarshalJSON(data []byte) error {
3561 var name string
3562
3563 if err := json.Unmarshal(data, &name); err != nil {
3564 return err
3565 }
3566
3567 switch name {
3568 case "v2":
3569 (*s) = BlockdevQcow2VersionV2
3570 case "v3":
3571 (*s) = BlockdevQcow2VersionV3
3572 default:
3573 fmt.Println("Failed to decode BlockdevQcow2Version", *s)
3574 }
3575 return nil
3576 }
3577
3578
3579
3580
3581 type Qcow2CompressionType int32
3582
3583 const (
3584 Qcow2CompressionTypeZlib Qcow2CompressionType = iota
3585 Qcow2CompressionTypeZstd
3586 )
3587
3588 func (s Qcow2CompressionType) MarshalJSON() ([]byte, error) {
3589 switch s {
3590 case Qcow2CompressionTypeZlib:
3591 return []byte(`"zlib"`), nil
3592 case Qcow2CompressionTypeZstd:
3593 return []byte(`"zstd"`), nil
3594 default:
3595 fmt.Println("Failed to decode Qcow2CompressionType", s)
3596 }
3597 return nil, errors.New("Failed")
3598 }
3599
3600 func (s *Qcow2CompressionType) UnmarshalJSON(data []byte) error {
3601 var name string
3602
3603 if err := json.Unmarshal(data, &name); err != nil {
3604 return err
3605 }
3606
3607 switch name {
3608 case "zlib":
3609 (*s) = Qcow2CompressionTypeZlib
3610 case "zstd":
3611 (*s) = Qcow2CompressionTypeZstd
3612 default:
3613 fmt.Println("Failed to decode Qcow2CompressionType", *s)
3614 }
3615 return nil
3616 }
3617
3618
3619
3620
3621 type BlockdevVmdkSubformat int32
3622
3623 const (
3624 BlockdevVmdkSubformatMonolithicsparse BlockdevVmdkSubformat = iota
3625 BlockdevVmdkSubformatMonolithicflat
3626 BlockdevVmdkSubformatTwogbmaxextentsparse
3627 BlockdevVmdkSubformatTwogbmaxextentflat
3628 BlockdevVmdkSubformatStreamoptimized
3629 )
3630
3631 func (s BlockdevVmdkSubformat) MarshalJSON() ([]byte, error) {
3632 switch s {
3633 case BlockdevVmdkSubformatMonolithicsparse:
3634 return []byte(`"monolithicSparse"`), nil
3635 case BlockdevVmdkSubformatMonolithicflat:
3636 return []byte(`"monolithicFlat"`), nil
3637 case BlockdevVmdkSubformatTwogbmaxextentsparse:
3638 return []byte(`"twoGbMaxExtentSparse"`), nil
3639 case BlockdevVmdkSubformatTwogbmaxextentflat:
3640 return []byte(`"twoGbMaxExtentFlat"`), nil
3641 case BlockdevVmdkSubformatStreamoptimized:
3642 return []byte(`"streamOptimized"`), nil
3643 default:
3644 fmt.Println("Failed to decode BlockdevVmdkSubformat", s)
3645 }
3646 return nil, errors.New("Failed")
3647 }
3648
3649 func (s *BlockdevVmdkSubformat) UnmarshalJSON(data []byte) error {
3650 var name string
3651
3652 if err := json.Unmarshal(data, &name); err != nil {
3653 return err
3654 }
3655
3656 switch name {
3657 case "monolithicSparse":
3658 (*s) = BlockdevVmdkSubformatMonolithicsparse
3659 case "monolithicFlat":
3660 (*s) = BlockdevVmdkSubformatMonolithicflat
3661 case "twoGbMaxExtentSparse":
3662 (*s) = BlockdevVmdkSubformatTwogbmaxextentsparse
3663 case "twoGbMaxExtentFlat":
3664 (*s) = BlockdevVmdkSubformatTwogbmaxextentflat
3665 case "streamOptimized":
3666 (*s) = BlockdevVmdkSubformatStreamoptimized
3667 default:
3668 fmt.Println("Failed to decode BlockdevVmdkSubformat", *s)
3669 }
3670 return nil
3671 }
3672
3673
3674
3675
3676 type BlockdevVmdkAdapterType int32
3677
3678 const (
3679 BlockdevVmdkAdapterTypeIde BlockdevVmdkAdapterType = iota
3680 BlockdevVmdkAdapterTypeBuslogic
3681 BlockdevVmdkAdapterTypeLsilogic
3682 BlockdevVmdkAdapterTypeLegacyesx
3683 )
3684
3685 func (s BlockdevVmdkAdapterType) MarshalJSON() ([]byte, error) {
3686 switch s {
3687 case BlockdevVmdkAdapterTypeIde:
3688 return []byte(`"ide"`), nil
3689 case BlockdevVmdkAdapterTypeBuslogic:
3690 return []byte(`"buslogic"`), nil
3691 case BlockdevVmdkAdapterTypeLsilogic:
3692 return []byte(`"lsilogic"`), nil
3693 case BlockdevVmdkAdapterTypeLegacyesx:
3694 return []byte(`"legacyESX"`), nil
3695 default:
3696 fmt.Println("Failed to decode BlockdevVmdkAdapterType", s)
3697 }
3698 return nil, errors.New("Failed")
3699 }
3700
3701 func (s *BlockdevVmdkAdapterType) UnmarshalJSON(data []byte) error {
3702 var name string
3703
3704 if err := json.Unmarshal(data, &name); err != nil {
3705 return err
3706 }
3707
3708 switch name {
3709 case "ide":
3710 (*s) = BlockdevVmdkAdapterTypeIde
3711 case "buslogic":
3712 (*s) = BlockdevVmdkAdapterTypeBuslogic
3713 case "lsilogic":
3714 (*s) = BlockdevVmdkAdapterTypeLsilogic
3715 case "legacyESX":
3716 (*s) = BlockdevVmdkAdapterTypeLegacyesx
3717 default:
3718 fmt.Println("Failed to decode BlockdevVmdkAdapterType", *s)
3719 }
3720 return nil
3721 }
3722
3723
3724 type BlockdevVhdxSubformat int32
3725
3726 const (
3727 BlockdevVhdxSubformatDynamic BlockdevVhdxSubformat = iota
3728 BlockdevVhdxSubformatFixed
3729 )
3730
3731 func (s BlockdevVhdxSubformat) MarshalJSON() ([]byte, error) {
3732 switch s {
3733 case BlockdevVhdxSubformatDynamic:
3734 return []byte(`"dynamic"`), nil
3735 case BlockdevVhdxSubformatFixed:
3736 return []byte(`"fixed"`), nil
3737 default:
3738 fmt.Println("Failed to decode BlockdevVhdxSubformat", s)
3739 }
3740 return nil, errors.New("Failed")
3741 }
3742
3743 func (s *BlockdevVhdxSubformat) UnmarshalJSON(data []byte) error {
3744 var name string
3745
3746 if err := json.Unmarshal(data, &name); err != nil {
3747 return err
3748 }
3749
3750 switch name {
3751 case "dynamic":
3752 (*s) = BlockdevVhdxSubformatDynamic
3753 case "fixed":
3754 (*s) = BlockdevVhdxSubformatFixed
3755 default:
3756 fmt.Println("Failed to decode BlockdevVhdxSubformat", *s)
3757 }
3758 return nil
3759 }
3760
3761
3762 type BlockdevVpcSubformat int32
3763
3764 const (
3765 BlockdevVpcSubformatDynamic BlockdevVpcSubformat = iota
3766 BlockdevVpcSubformatFixed
3767 )
3768
3769 func (s BlockdevVpcSubformat) MarshalJSON() ([]byte, error) {
3770 switch s {
3771 case BlockdevVpcSubformatDynamic:
3772 return []byte(`"dynamic"`), nil
3773 case BlockdevVpcSubformatFixed:
3774 return []byte(`"fixed"`), nil
3775 default:
3776 fmt.Println("Failed to decode BlockdevVpcSubformat", s)
3777 }
3778 return nil, errors.New("Failed")
3779 }
3780
3781 func (s *BlockdevVpcSubformat) UnmarshalJSON(data []byte) error {
3782 var name string
3783
3784 if err := json.Unmarshal(data, &name); err != nil {
3785 return err
3786 }
3787
3788 switch name {
3789 case "dynamic":
3790 (*s) = BlockdevVpcSubformatDynamic
3791 case "fixed":
3792 (*s) = BlockdevVpcSubformatFixed
3793 default:
3794 fmt.Println("Failed to decode BlockdevVpcSubformat", *s)
3795 }
3796 return nil
3797 }
3798
3799
3800
3801
3802 type BlockErrorAction int32
3803
3804 const (
3805 BlockErrorActionIgnore BlockErrorAction = iota
3806 BlockErrorActionReport
3807 BlockErrorActionStop
3808 )
3809
3810 func (s BlockErrorAction) MarshalJSON() ([]byte, error) {
3811 switch s {
3812 case BlockErrorActionIgnore:
3813 return []byte(`"ignore"`), nil
3814 case BlockErrorActionReport:
3815 return []byte(`"report"`), nil
3816 case BlockErrorActionStop:
3817 return []byte(`"stop"`), nil
3818 default:
3819 fmt.Println("Failed to decode BlockErrorAction", s)
3820 }
3821 return nil, errors.New("Failed")
3822 }
3823
3824 func (s *BlockErrorAction) UnmarshalJSON(data []byte) error {
3825 var name string
3826
3827 if err := json.Unmarshal(data, &name); err != nil {
3828 return err
3829 }
3830
3831 switch name {
3832 case "ignore":
3833 (*s) = BlockErrorActionIgnore
3834 case "report":
3835 (*s) = BlockErrorActionReport
3836 case "stop":
3837 (*s) = BlockErrorActionStop
3838 default:
3839 fmt.Println("Failed to decode BlockErrorAction", *s)
3840 }
3841 return nil
3842 }
3843
3844
3845
3846
3847 type PreallocMode int32
3848
3849 const (
3850 PreallocModeOff PreallocMode = iota
3851 PreallocModeMetadata
3852 PreallocModeFalloc
3853 PreallocModeFull
3854 )
3855
3856 func (s PreallocMode) MarshalJSON() ([]byte, error) {
3857 switch s {
3858 case PreallocModeOff:
3859 return []byte(`"off"`), nil
3860 case PreallocModeMetadata:
3861 return []byte(`"metadata"`), nil
3862 case PreallocModeFalloc:
3863 return []byte(`"falloc"`), nil
3864 case PreallocModeFull:
3865 return []byte(`"full"`), nil
3866 default:
3867 fmt.Println("Failed to decode PreallocMode", s)
3868 }
3869 return nil, errors.New("Failed")
3870 }
3871
3872 func (s *PreallocMode) UnmarshalJSON(data []byte) error {
3873 var name string
3874
3875 if err := json.Unmarshal(data, &name); err != nil {
3876 return err
3877 }
3878
3879 switch name {
3880 case "off":
3881 (*s) = PreallocModeOff
3882 case "metadata":
3883 (*s) = PreallocModeMetadata
3884 case "falloc":
3885 (*s) = PreallocModeFalloc
3886 case "full":
3887 (*s) = PreallocModeFull
3888 default:
3889 fmt.Println("Failed to decode PreallocMode", *s)
3890 }
3891 return nil
3892 }
3893
3894
3895
3896
3897 type QuorumOpType int32
3898
3899 const (
3900 QuorumOpTypeRead QuorumOpType = iota
3901 QuorumOpTypeWrite
3902 QuorumOpTypeFlush
3903 )
3904
3905 func (s QuorumOpType) MarshalJSON() ([]byte, error) {
3906 switch s {
3907 case QuorumOpTypeRead:
3908 return []byte(`"read"`), nil
3909 case QuorumOpTypeWrite:
3910 return []byte(`"write"`), nil
3911 case QuorumOpTypeFlush:
3912 return []byte(`"flush"`), nil
3913 default:
3914 fmt.Println("Failed to decode QuorumOpType", s)
3915 }
3916 return nil, errors.New("Failed")
3917 }
3918
3919 func (s *QuorumOpType) UnmarshalJSON(data []byte) error {
3920 var name string
3921
3922 if err := json.Unmarshal(data, &name); err != nil {
3923 return err
3924 }
3925
3926 switch name {
3927 case "read":
3928 (*s) = QuorumOpTypeRead
3929 case "write":
3930 (*s) = QuorumOpTypeWrite
3931 case "flush":
3932 (*s) = QuorumOpTypeFlush
3933 default:
3934 fmt.Println("Failed to decode QuorumOpType", *s)
3935 }
3936 return nil
3937 }
3938
3939
3940
3941
3942 type JobType int32
3943
3944 const (
3945 JobTypeCommit JobType = iota
3946 JobTypeStream
3947 JobTypeMirror
3948 JobTypeBackup
3949 JobTypeCreate
3950 JobTypeAmend
3951 JobTypeSnapshotLoad
3952 JobTypeSnapshotSave
3953 JobTypeSnapshotDelete
3954 )
3955
3956 func (s JobType) MarshalJSON() ([]byte, error) {
3957 switch s {
3958 case JobTypeCommit:
3959 return []byte(`"commit"`), nil
3960 case JobTypeStream:
3961 return []byte(`"stream"`), nil
3962 case JobTypeMirror:
3963 return []byte(`"mirror"`), nil
3964 case JobTypeBackup:
3965 return []byte(`"backup"`), nil
3966 case JobTypeCreate:
3967 return []byte(`"create"`), nil
3968 case JobTypeAmend:
3969 return []byte(`"amend"`), nil
3970 case JobTypeSnapshotLoad:
3971 return []byte(`"snapshot-load"`), nil
3972 case JobTypeSnapshotSave:
3973 return []byte(`"snapshot-save"`), nil
3974 case JobTypeSnapshotDelete:
3975 return []byte(`"snapshot-delete"`), nil
3976 default:
3977 fmt.Println("Failed to decode JobType", s)
3978 }
3979 return nil, errors.New("Failed")
3980 }
3981
3982 func (s *JobType) UnmarshalJSON(data []byte) error {
3983 var name string
3984
3985 if err := json.Unmarshal(data, &name); err != nil {
3986 return err
3987 }
3988
3989 switch name {
3990 case "commit":
3991 (*s) = JobTypeCommit
3992 case "stream":
3993 (*s) = JobTypeStream
3994 case "mirror":
3995 (*s) = JobTypeMirror
3996 case "backup":
3997 (*s) = JobTypeBackup
3998 case "create":
3999 (*s) = JobTypeCreate
4000 case "amend":
4001 (*s) = JobTypeAmend
4002 case "snapshot-load":
4003 (*s) = JobTypeSnapshotLoad
4004 case "snapshot-save":
4005 (*s) = JobTypeSnapshotSave
4006 case "snapshot-delete":
4007 (*s) = JobTypeSnapshotDelete
4008 default:
4009 fmt.Println("Failed to decode JobType", *s)
4010 }
4011 return nil
4012 }
4013
4014
4015
4016
4017 type JobStatus int32
4018
4019 const (
4020 JobStatusUndefined JobStatus = iota
4021 JobStatusCreated
4022 JobStatusRunning
4023 JobStatusPaused
4024 JobStatusReady
4025 JobStatusStandby
4026 JobStatusWaiting
4027 JobStatusPending
4028 JobStatusAborting
4029 JobStatusConcluded
4030 JobStatusNull
4031 )
4032
4033 func (s JobStatus) MarshalJSON() ([]byte, error) {
4034 switch s {
4035 case JobStatusUndefined:
4036 return []byte(`"undefined"`), nil
4037 case JobStatusCreated:
4038 return []byte(`"created"`), nil
4039 case JobStatusRunning:
4040 return []byte(`"running"`), nil
4041 case JobStatusPaused:
4042 return []byte(`"paused"`), nil
4043 case JobStatusReady:
4044 return []byte(`"ready"`), nil
4045 case JobStatusStandby:
4046 return []byte(`"standby"`), nil
4047 case JobStatusWaiting:
4048 return []byte(`"waiting"`), nil
4049 case JobStatusPending:
4050 return []byte(`"pending"`), nil
4051 case JobStatusAborting:
4052 return []byte(`"aborting"`), nil
4053 case JobStatusConcluded:
4054 return []byte(`"concluded"`), nil
4055 case JobStatusNull:
4056 return []byte(`"null"`), nil
4057 default:
4058 fmt.Println("Failed to decode JobStatus", s)
4059 }
4060 return nil, errors.New("Failed")
4061 }
4062
4063 func (s *JobStatus) UnmarshalJSON(data []byte) error {
4064 var name string
4065
4066 if err := json.Unmarshal(data, &name); err != nil {
4067 return err
4068 }
4069
4070 switch name {
4071 case "undefined":
4072 (*s) = JobStatusUndefined
4073 case "created":
4074 (*s) = JobStatusCreated
4075 case "running":
4076 (*s) = JobStatusRunning
4077 case "paused":
4078 (*s) = JobStatusPaused
4079 case "ready":
4080 (*s) = JobStatusReady
4081 case "standby":
4082 (*s) = JobStatusStandby
4083 case "waiting":
4084 (*s) = JobStatusWaiting
4085 case "pending":
4086 (*s) = JobStatusPending
4087 case "aborting":
4088 (*s) = JobStatusAborting
4089 case "concluded":
4090 (*s) = JobStatusConcluded
4091 case "null":
4092 (*s) = JobStatusNull
4093 default:
4094 fmt.Println("Failed to decode JobStatus", *s)
4095 }
4096 return nil
4097 }
4098
4099
4100
4101
4102 type JobVerb int32
4103
4104 const (
4105 JobVerbCancel JobVerb = iota
4106 JobVerbPause
4107 JobVerbResume
4108 JobVerbSetSpeed
4109 JobVerbComplete
4110 JobVerbDismiss
4111 JobVerbFinalize
4112 )
4113
4114 func (s JobVerb) MarshalJSON() ([]byte, error) {
4115 switch s {
4116 case JobVerbCancel:
4117 return []byte(`"cancel"`), nil
4118 case JobVerbPause:
4119 return []byte(`"pause"`), nil
4120 case JobVerbResume:
4121 return []byte(`"resume"`), nil
4122 case JobVerbSetSpeed:
4123 return []byte(`"set-speed"`), nil
4124 case JobVerbComplete:
4125 return []byte(`"complete"`), nil
4126 case JobVerbDismiss:
4127 return []byte(`"dismiss"`), nil
4128 case JobVerbFinalize:
4129 return []byte(`"finalize"`), nil
4130 default:
4131 fmt.Println("Failed to decode JobVerb", s)
4132 }
4133 return nil, errors.New("Failed")
4134 }
4135
4136 func (s *JobVerb) UnmarshalJSON(data []byte) error {
4137 var name string
4138
4139 if err := json.Unmarshal(data, &name); err != nil {
4140 return err
4141 }
4142
4143 switch name {
4144 case "cancel":
4145 (*s) = JobVerbCancel
4146 case "pause":
4147 (*s) = JobVerbPause
4148 case "resume":
4149 (*s) = JobVerbResume
4150 case "set-speed":
4151 (*s) = JobVerbSetSpeed
4152 case "complete":
4153 (*s) = JobVerbComplete
4154 case "dismiss":
4155 (*s) = JobVerbDismiss
4156 case "finalize":
4157 (*s) = JobVerbFinalize
4158 default:
4159 fmt.Println("Failed to decode JobVerb", *s)
4160 }
4161 return nil
4162 }
4163
4164
4165
4166
4167 type FuseExportAllowOther int32
4168
4169 const (
4170 FuseExportAllowOtherOff FuseExportAllowOther = iota
4171 FuseExportAllowOtherOn
4172 FuseExportAllowOtherAuto
4173 )
4174
4175 func (s FuseExportAllowOther) MarshalJSON() ([]byte, error) {
4176 switch s {
4177 case FuseExportAllowOtherOff:
4178 return []byte(`"off"`), nil
4179 case FuseExportAllowOtherOn:
4180 return []byte(`"on"`), nil
4181 case FuseExportAllowOtherAuto:
4182 return []byte(`"auto"`), nil
4183 default:
4184 fmt.Println("Failed to decode FuseExportAllowOther", s)
4185 }
4186 return nil, errors.New("Failed")
4187 }
4188
4189 func (s *FuseExportAllowOther) UnmarshalJSON(data []byte) error {
4190 var name string
4191
4192 if err := json.Unmarshal(data, &name); err != nil {
4193 return err
4194 }
4195
4196 switch name {
4197 case "off":
4198 (*s) = FuseExportAllowOtherOff
4199 case "on":
4200 (*s) = FuseExportAllowOtherOn
4201 case "auto":
4202 (*s) = FuseExportAllowOtherAuto
4203 default:
4204 fmt.Println("Failed to decode FuseExportAllowOther", *s)
4205 }
4206 return nil
4207 }
4208
4209
4210
4211
4212
4213
4214
4215
4216
4217
4218
4219
4220 type BlockExportRemoveMode int32
4221
4222 const (
4223 BlockExportRemoveModeSafe BlockExportRemoveMode = iota
4224 BlockExportRemoveModeHard
4225 )
4226
4227 func (s BlockExportRemoveMode) MarshalJSON() ([]byte, error) {
4228 switch s {
4229 case BlockExportRemoveModeSafe:
4230 return []byte(`"safe"`), nil
4231 case BlockExportRemoveModeHard:
4232 return []byte(`"hard"`), nil
4233 default:
4234 fmt.Println("Failed to decode BlockExportRemoveMode", s)
4235 }
4236 return nil, errors.New("Failed")
4237 }
4238
4239 func (s *BlockExportRemoveMode) UnmarshalJSON(data []byte) error {
4240 var name string
4241
4242 if err := json.Unmarshal(data, &name); err != nil {
4243 return err
4244 }
4245
4246 switch name {
4247 case "safe":
4248 (*s) = BlockExportRemoveModeSafe
4249 case "hard":
4250 (*s) = BlockExportRemoveModeHard
4251 default:
4252 fmt.Println("Failed to decode BlockExportRemoveMode", *s)
4253 }
4254 return nil
4255 }
4256
4257
4258
4259
4260 type BlockExportType int32
4261
4262 const (
4263 BlockExportTypeNbd BlockExportType = iota
4264 BlockExportTypeVhostUserBlk
4265 BlockExportTypeFuse
4266 )
4267
4268 func (s BlockExportType) MarshalJSON() ([]byte, error) {
4269 switch s {
4270 case BlockExportTypeNbd:
4271 return []byte(`"nbd"`), nil
4272 case BlockExportTypeVhostUserBlk:
4273 return []byte(`"vhost-user-blk"`), nil
4274 case BlockExportTypeFuse:
4275 return []byte(`"fuse"`), nil
4276 default:
4277 fmt.Println("Failed to decode BlockExportType", s)
4278 }
4279 return nil, errors.New("Failed")
4280 }
4281
4282 func (s *BlockExportType) UnmarshalJSON(data []byte) error {
4283 var name string
4284
4285 if err := json.Unmarshal(data, &name); err != nil {
4286 return err
4287 }
4288
4289 switch name {
4290 case "nbd":
4291 (*s) = BlockExportTypeNbd
4292 case "vhost-user-blk":
4293 (*s) = BlockExportTypeVhostUserBlk
4294 case "fuse":
4295 (*s) = BlockExportTypeFuse
4296 default:
4297 fmt.Println("Failed to decode BlockExportType", *s)
4298 }
4299 return nil
4300 }
4301
4302
4303
4304
4305 type DataFormat int32
4306
4307 const (
4308 DataFormatUtf8 DataFormat = iota
4309 DataFormatBase64
4310 )
4311
4312 func (s DataFormat) MarshalJSON() ([]byte, error) {
4313 switch s {
4314 case DataFormatUtf8:
4315 return []byte(`"utf8"`), nil
4316 case DataFormatBase64:
4317 return []byte(`"base64"`), nil
4318 default:
4319 fmt.Println("Failed to decode DataFormat", s)
4320 }
4321 return nil, errors.New("Failed")
4322 }
4323
4324 func (s *DataFormat) UnmarshalJSON(data []byte) error {
4325 var name string
4326
4327 if err := json.Unmarshal(data, &name); err != nil {
4328 return err
4329 }
4330
4331 switch name {
4332 case "utf8":
4333 (*s) = DataFormatUtf8
4334 case "base64":
4335 (*s) = DataFormatBase64
4336 default:
4337 fmt.Println("Failed to decode DataFormat", *s)
4338 }
4339 return nil
4340 }
4341
4342
4343 type ChardevBackendKind int32
4344
4345 const (
4346 ChardevBackendKindFile ChardevBackendKind = iota
4347 ChardevBackendKindSerial
4348 ChardevBackendKindParallel
4349 ChardevBackendKindPipe
4350 ChardevBackendKindSocket
4351 ChardevBackendKindUdp
4352 ChardevBackendKindPty
4353 ChardevBackendKindNull
4354 ChardevBackendKindMux
4355 ChardevBackendKindMsmouse
4356 ChardevBackendKindWctablet
4357 ChardevBackendKindBraille
4358 ChardevBackendKindTestdev
4359 ChardevBackendKindStdio
4360 ChardevBackendKindConsole
4361 ChardevBackendKindSpicevmc
4362 ChardevBackendKindSpiceport
4363 ChardevBackendKindQemuVdagent
4364 ChardevBackendKindDbus
4365 ChardevBackendKindVc
4366 ChardevBackendKindRingbuf
4367 ChardevBackendKindMemory
4368 )
4369
4370 func (s ChardevBackendKind) MarshalJSON() ([]byte, error) {
4371 switch s {
4372 case ChardevBackendKindFile:
4373 return []byte(`"file"`), nil
4374 case ChardevBackendKindSerial:
4375 return []byte(`"serial"`), nil
4376 case ChardevBackendKindParallel:
4377 return []byte(`"parallel"`), nil
4378 case ChardevBackendKindPipe:
4379 return []byte(`"pipe"`), nil
4380 case ChardevBackendKindSocket:
4381 return []byte(`"socket"`), nil
4382 case ChardevBackendKindUdp:
4383 return []byte(`"udp"`), nil
4384 case ChardevBackendKindPty:
4385 return []byte(`"pty"`), nil
4386 case ChardevBackendKindNull:
4387 return []byte(`"null"`), nil
4388 case ChardevBackendKindMux:
4389 return []byte(`"mux"`), nil
4390 case ChardevBackendKindMsmouse:
4391 return []byte(`"msmouse"`), nil
4392 case ChardevBackendKindWctablet:
4393 return []byte(`"wctablet"`), nil
4394 case ChardevBackendKindBraille:
4395 return []byte(`"braille"`), nil
4396 case ChardevBackendKindTestdev:
4397 return []byte(`"testdev"`), nil
4398 case ChardevBackendKindStdio:
4399 return []byte(`"stdio"`), nil
4400 case ChardevBackendKindConsole:
4401 return []byte(`"console"`), nil
4402 case ChardevBackendKindSpicevmc:
4403 return []byte(`"spicevmc"`), nil
4404 case ChardevBackendKindSpiceport:
4405 return []byte(`"spiceport"`), nil
4406 case ChardevBackendKindQemuVdagent:
4407 return []byte(`"qemu-vdagent"`), nil
4408 case ChardevBackendKindDbus:
4409 return []byte(`"dbus"`), nil
4410 case ChardevBackendKindVc:
4411 return []byte(`"vc"`), nil
4412 case ChardevBackendKindRingbuf:
4413 return []byte(`"ringbuf"`), nil
4414 case ChardevBackendKindMemory:
4415 return []byte(`"memory"`), nil
4416 default:
4417 fmt.Println("Failed to decode ChardevBackendKind", s)
4418 }
4419 return nil, errors.New("Failed")
4420 }
4421
4422 func (s *ChardevBackendKind) UnmarshalJSON(data []byte) error {
4423 var name string
4424
4425 if err := json.Unmarshal(data, &name); err != nil {
4426 return err
4427 }
4428
4429 switch name {
4430 case "file":
4431 (*s) = ChardevBackendKindFile
4432 case "serial":
4433 (*s) = ChardevBackendKindSerial
4434 case "parallel":
4435 (*s) = ChardevBackendKindParallel
4436 case "pipe":
4437 (*s) = ChardevBackendKindPipe
4438 case "socket":
4439 (*s) = ChardevBackendKindSocket
4440 case "udp":
4441 (*s) = ChardevBackendKindUdp
4442 case "pty":
4443 (*s) = ChardevBackendKindPty
4444 case "null":
4445 (*s) = ChardevBackendKindNull
4446 case "mux":
4447 (*s) = ChardevBackendKindMux
4448 case "msmouse":
4449 (*s) = ChardevBackendKindMsmouse
4450 case "wctablet":
4451 (*s) = ChardevBackendKindWctablet
4452 case "braille":
4453 (*s) = ChardevBackendKindBraille
4454 case "testdev":
4455 (*s) = ChardevBackendKindTestdev
4456 case "stdio":
4457 (*s) = ChardevBackendKindStdio
4458 case "console":
4459 (*s) = ChardevBackendKindConsole
4460 case "spicevmc":
4461 (*s) = ChardevBackendKindSpicevmc
4462 case "spiceport":
4463 (*s) = ChardevBackendKindSpiceport
4464 case "qemu-vdagent":
4465 (*s) = ChardevBackendKindQemuVdagent
4466 case "dbus":
4467 (*s) = ChardevBackendKindDbus
4468 case "vc":
4469 (*s) = ChardevBackendKindVc
4470 case "ringbuf":
4471 (*s) = ChardevBackendKindRingbuf
4472 case "memory":
4473 (*s) = ChardevBackendKindMemory
4474 default:
4475 fmt.Println("Failed to decode ChardevBackendKind", *s)
4476 }
4477 return nil
4478 }
4479
4480
4481
4482
4483 type DumpGuestMemoryFormat int32
4484
4485 const (
4486 DumpGuestMemoryFormatElf DumpGuestMemoryFormat = iota
4487 DumpGuestMemoryFormatKdumpZlib
4488 DumpGuestMemoryFormatKdumpLzo
4489 DumpGuestMemoryFormatKdumpSnappy
4490 DumpGuestMemoryFormatWinDmp
4491 )
4492
4493 func (s DumpGuestMemoryFormat) MarshalJSON() ([]byte, error) {
4494 switch s {
4495 case DumpGuestMemoryFormatElf:
4496 return []byte(`"elf"`), nil
4497 case DumpGuestMemoryFormatKdumpZlib:
4498 return []byte(`"kdump-zlib"`), nil
4499 case DumpGuestMemoryFormatKdumpLzo:
4500 return []byte(`"kdump-lzo"`), nil
4501 case DumpGuestMemoryFormatKdumpSnappy:
4502 return []byte(`"kdump-snappy"`), nil
4503 case DumpGuestMemoryFormatWinDmp:
4504 return []byte(`"win-dmp"`), nil
4505 default:
4506 fmt.Println("Failed to decode DumpGuestMemoryFormat", s)
4507 }
4508 return nil, errors.New("Failed")
4509 }
4510
4511 func (s *DumpGuestMemoryFormat) UnmarshalJSON(data []byte) error {
4512 var name string
4513
4514 if err := json.Unmarshal(data, &name); err != nil {
4515 return err
4516 }
4517
4518 switch name {
4519 case "elf":
4520 (*s) = DumpGuestMemoryFormatElf
4521 case "kdump-zlib":
4522 (*s) = DumpGuestMemoryFormatKdumpZlib
4523 case "kdump-lzo":
4524 (*s) = DumpGuestMemoryFormatKdumpLzo
4525 case "kdump-snappy":
4526 (*s) = DumpGuestMemoryFormatKdumpSnappy
4527 case "win-dmp":
4528 (*s) = DumpGuestMemoryFormatWinDmp
4529 default:
4530 fmt.Println("Failed to decode DumpGuestMemoryFormat", *s)
4531 }
4532 return nil
4533 }
4534
4535
4536
4537
4538 type DumpStatus int32
4539
4540 const (
4541 DumpStatusNone DumpStatus = iota
4542 DumpStatusActive
4543 DumpStatusCompleted
4544 DumpStatusFailed
4545 )
4546
4547 func (s DumpStatus) MarshalJSON() ([]byte, error) {
4548 switch s {
4549 case DumpStatusNone:
4550 return []byte(`"none"`), nil
4551 case DumpStatusActive:
4552 return []byte(`"active"`), nil
4553 case DumpStatusCompleted:
4554 return []byte(`"completed"`), nil
4555 case DumpStatusFailed:
4556 return []byte(`"failed"`), nil
4557 default:
4558 fmt.Println("Failed to decode DumpStatus", s)
4559 }
4560 return nil, errors.New("Failed")
4561 }
4562
4563 func (s *DumpStatus) UnmarshalJSON(data []byte) error {
4564 var name string
4565
4566 if err := json.Unmarshal(data, &name); err != nil {
4567 return err
4568 }
4569
4570 switch name {
4571 case "none":
4572 (*s) = DumpStatusNone
4573 case "active":
4574 (*s) = DumpStatusActive
4575 case "completed":
4576 (*s) = DumpStatusCompleted
4577 case "failed":
4578 (*s) = DumpStatusFailed
4579 default:
4580 fmt.Println("Failed to decode DumpStatus", *s)
4581 }
4582 return nil
4583 }
4584
4585
4586
4587
4588
4589
4590 type NetClientDriver int32
4591
4592 const (
4593 NetClientDriverNone NetClientDriver = iota
4594 NetClientDriverNic
4595 NetClientDriverUser
4596 NetClientDriverTap
4597 NetClientDriverL2Tpv3
4598 NetClientDriverSocket
4599 NetClientDriverVde
4600 NetClientDriverBridge
4601 NetClientDriverHubport
4602 NetClientDriverNetmap
4603 NetClientDriverVhostUser
4604 NetClientDriverVhostVdpa
4605 )
4606
4607 func (s NetClientDriver) MarshalJSON() ([]byte, error) {
4608 switch s {
4609 case NetClientDriverNone:
4610 return []byte(`"none"`), nil
4611 case NetClientDriverNic:
4612 return []byte(`"nic"`), nil
4613 case NetClientDriverUser:
4614 return []byte(`"user"`), nil
4615 case NetClientDriverTap:
4616 return []byte(`"tap"`), nil
4617 case NetClientDriverL2Tpv3:
4618 return []byte(`"l2tpv3"`), nil
4619 case NetClientDriverSocket:
4620 return []byte(`"socket"`), nil
4621 case NetClientDriverVde:
4622 return []byte(`"vde"`), nil
4623 case NetClientDriverBridge:
4624 return []byte(`"bridge"`), nil
4625 case NetClientDriverHubport:
4626 return []byte(`"hubport"`), nil
4627 case NetClientDriverNetmap:
4628 return []byte(`"netmap"`), nil
4629 case NetClientDriverVhostUser:
4630 return []byte(`"vhost-user"`), nil
4631 case NetClientDriverVhostVdpa:
4632 return []byte(`"vhost-vdpa"`), nil
4633 default:
4634 fmt.Println("Failed to decode NetClientDriver", s)
4635 }
4636 return nil, errors.New("Failed")
4637 }
4638
4639 func (s *NetClientDriver) UnmarshalJSON(data []byte) error {
4640 var name string
4641
4642 if err := json.Unmarshal(data, &name); err != nil {
4643 return err
4644 }
4645
4646 switch name {
4647 case "none":
4648 (*s) = NetClientDriverNone
4649 case "nic":
4650 (*s) = NetClientDriverNic
4651 case "user":
4652 (*s) = NetClientDriverUser
4653 case "tap":
4654 (*s) = NetClientDriverTap
4655 case "l2tpv3":
4656 (*s) = NetClientDriverL2Tpv3
4657 case "socket":
4658 (*s) = NetClientDriverSocket
4659 case "vde":
4660 (*s) = NetClientDriverVde
4661 case "bridge":
4662 (*s) = NetClientDriverBridge
4663 case "hubport":
4664 (*s) = NetClientDriverHubport
4665 case "netmap":
4666 (*s) = NetClientDriverNetmap
4667 case "vhost-user":
4668 (*s) = NetClientDriverVhostUser
4669 case "vhost-vdpa":
4670 (*s) = NetClientDriverVhostVdpa
4671 default:
4672 fmt.Println("Failed to decode NetClientDriver", *s)
4673 }
4674 return nil
4675 }
4676
4677
4678
4679
4680 type RxState int32
4681
4682 const (
4683 RxStateNormal RxState = iota
4684 RxStateNone
4685 RxStateAll
4686 )
4687
4688 func (s RxState) MarshalJSON() ([]byte, error) {
4689 switch s {
4690 case RxStateNormal:
4691 return []byte(`"normal"`), nil
4692 case RxStateNone:
4693 return []byte(`"none"`), nil
4694 case RxStateAll:
4695 return []byte(`"all"`), nil
4696 default:
4697 fmt.Println("Failed to decode RxState", s)
4698 }
4699 return nil, errors.New("Failed")
4700 }
4701
4702 func (s *RxState) UnmarshalJSON(data []byte) error {
4703 var name string
4704
4705 if err := json.Unmarshal(data, &name); err != nil {
4706 return err
4707 }
4708
4709 switch name {
4710 case "normal":
4711 (*s) = RxStateNormal
4712 case "none":
4713 (*s) = RxStateNone
4714 case "all":
4715 (*s) = RxStateAll
4716 default:
4717 fmt.Println("Failed to decode RxState", *s)
4718 }
4719 return nil
4720 }
4721
4722
4723
4724
4725 type RockerPortDuplex int32
4726
4727 const (
4728 RockerPortDuplexHalf RockerPortDuplex = iota
4729 RockerPortDuplexFull
4730 )
4731
4732 func (s RockerPortDuplex) MarshalJSON() ([]byte, error) {
4733 switch s {
4734 case RockerPortDuplexHalf:
4735 return []byte(`"half"`), nil
4736 case RockerPortDuplexFull:
4737 return []byte(`"full"`), nil
4738 default:
4739 fmt.Println("Failed to decode RockerPortDuplex", s)
4740 }
4741 return nil, errors.New("Failed")
4742 }
4743
4744 func (s *RockerPortDuplex) UnmarshalJSON(data []byte) error {
4745 var name string
4746
4747 if err := json.Unmarshal(data, &name); err != nil {
4748 return err
4749 }
4750
4751 switch name {
4752 case "half":
4753 (*s) = RockerPortDuplexHalf
4754 case "full":
4755 (*s) = RockerPortDuplexFull
4756 default:
4757 fmt.Println("Failed to decode RockerPortDuplex", *s)
4758 }
4759 return nil
4760 }
4761
4762
4763
4764
4765 type RockerPortAutoneg int32
4766
4767 const (
4768 RockerPortAutonegOff RockerPortAutoneg = iota
4769 RockerPortAutonegOn
4770 )
4771
4772 func (s RockerPortAutoneg) MarshalJSON() ([]byte, error) {
4773 switch s {
4774 case RockerPortAutonegOff:
4775 return []byte(`"off"`), nil
4776 case RockerPortAutonegOn:
4777 return []byte(`"on"`), nil
4778 default:
4779 fmt.Println("Failed to decode RockerPortAutoneg", s)
4780 }
4781 return nil, errors.New("Failed")
4782 }
4783
4784 func (s *RockerPortAutoneg) UnmarshalJSON(data []byte) error {
4785 var name string
4786
4787 if err := json.Unmarshal(data, &name); err != nil {
4788 return err
4789 }
4790
4791 switch name {
4792 case "off":
4793 (*s) = RockerPortAutonegOff
4794 case "on":
4795 (*s) = RockerPortAutonegOn
4796 default:
4797 fmt.Println("Failed to decode RockerPortAutoneg", *s)
4798 }
4799 return nil
4800 }
4801
4802
4803
4804
4805 type TpmModel int32
4806
4807 const (
4808 TpmModelTpmTis TpmModel = iota
4809 TpmModelTpmCrb
4810 TpmModelTpmSpapr
4811 )
4812
4813 func (s TpmModel) MarshalJSON() ([]byte, error) {
4814 switch s {
4815 case TpmModelTpmTis:
4816 return []byte(`"tpm-tis"`), nil
4817 case TpmModelTpmCrb:
4818 return []byte(`"tpm-crb"`), nil
4819 case TpmModelTpmSpapr:
4820 return []byte(`"tpm-spapr"`), nil
4821 default:
4822 fmt.Println("Failed to decode TpmModel", s)
4823 }
4824 return nil, errors.New("Failed")
4825 }
4826
4827 func (s *TpmModel) UnmarshalJSON(data []byte) error {
4828 var name string
4829
4830 if err := json.Unmarshal(data, &name); err != nil {
4831 return err
4832 }
4833
4834 switch name {
4835 case "tpm-tis":
4836 (*s) = TpmModelTpmTis
4837 case "tpm-crb":
4838 (*s) = TpmModelTpmCrb
4839 case "tpm-spapr":
4840 (*s) = TpmModelTpmSpapr
4841 default:
4842 fmt.Println("Failed to decode TpmModel", *s)
4843 }
4844 return nil
4845 }
4846
4847
4848
4849
4850 type TpmType int32
4851
4852 const (
4853 TpmTypePassthrough TpmType = iota
4854 TpmTypeEmulator
4855 )
4856
4857 func (s TpmType) MarshalJSON() ([]byte, error) {
4858 switch s {
4859 case TpmTypePassthrough:
4860 return []byte(`"passthrough"`), nil
4861 case TpmTypeEmulator:
4862 return []byte(`"emulator"`), nil
4863 default:
4864 fmt.Println("Failed to decode TpmType", s)
4865 }
4866 return nil, errors.New("Failed")
4867 }
4868
4869 func (s *TpmType) UnmarshalJSON(data []byte) error {
4870 var name string
4871
4872 if err := json.Unmarshal(data, &name); err != nil {
4873 return err
4874 }
4875
4876 switch name {
4877 case "passthrough":
4878 (*s) = TpmTypePassthrough
4879 case "emulator":
4880 (*s) = TpmTypeEmulator
4881 default:
4882 fmt.Println("Failed to decode TpmType", *s)
4883 }
4884 return nil
4885 }
4886
4887
4888
4889
4890 type DisplayProtocol int32
4891
4892 const (
4893 DisplayProtocolVnc DisplayProtocol = iota
4894 DisplayProtocolSpice
4895 )
4896
4897 func (s DisplayProtocol) MarshalJSON() ([]byte, error) {
4898 switch s {
4899 case DisplayProtocolVnc:
4900 return []byte(`"vnc"`), nil
4901 case DisplayProtocolSpice:
4902 return []byte(`"spice"`), nil
4903 default:
4904 fmt.Println("Failed to decode DisplayProtocol", s)
4905 }
4906 return nil, errors.New("Failed")
4907 }
4908
4909 func (s *DisplayProtocol) UnmarshalJSON(data []byte) error {
4910 var name string
4911
4912 if err := json.Unmarshal(data, &name); err != nil {
4913 return err
4914 }
4915
4916 switch name {
4917 case "vnc":
4918 (*s) = DisplayProtocolVnc
4919 case "spice":
4920 (*s) = DisplayProtocolSpice
4921 default:
4922 fmt.Println("Failed to decode DisplayProtocol", *s)
4923 }
4924 return nil
4925 }
4926
4927
4928
4929
4930 type SetPasswordAction int32
4931
4932 const (
4933 SetPasswordActionKeep SetPasswordAction = iota
4934 SetPasswordActionFail
4935 SetPasswordActionDisconnect
4936 )
4937
4938 func (s SetPasswordAction) MarshalJSON() ([]byte, error) {
4939 switch s {
4940 case SetPasswordActionKeep:
4941 return []byte(`"keep"`), nil
4942 case SetPasswordActionFail:
4943 return []byte(`"fail"`), nil
4944 case SetPasswordActionDisconnect:
4945 return []byte(`"disconnect"`), nil
4946 default:
4947 fmt.Println("Failed to decode SetPasswordAction", s)
4948 }
4949 return nil, errors.New("Failed")
4950 }
4951
4952 func (s *SetPasswordAction) UnmarshalJSON(data []byte) error {
4953 var name string
4954
4955 if err := json.Unmarshal(data, &name); err != nil {
4956 return err
4957 }
4958
4959 switch name {
4960 case "keep":
4961 (*s) = SetPasswordActionKeep
4962 case "fail":
4963 (*s) = SetPasswordActionFail
4964 case "disconnect":
4965 (*s) = SetPasswordActionDisconnect
4966 default:
4967 fmt.Println("Failed to decode SetPasswordAction", *s)
4968 }
4969 return nil
4970 }
4971
4972
4973
4974
4975
4976
4977 type SpiceQueryMouseMode int32
4978
4979 const (
4980 SpiceQueryMouseModeClient SpiceQueryMouseMode = iota
4981 SpiceQueryMouseModeServer
4982 SpiceQueryMouseModeUnknown
4983 )
4984
4985 func (s SpiceQueryMouseMode) MarshalJSON() ([]byte, error) {
4986 switch s {
4987 case SpiceQueryMouseModeClient:
4988 return []byte(`"client"`), nil
4989 case SpiceQueryMouseModeServer:
4990 return []byte(`"server"`), nil
4991 case SpiceQueryMouseModeUnknown:
4992 return []byte(`"unknown"`), nil
4993 default:
4994 fmt.Println("Failed to decode SpiceQueryMouseMode", s)
4995 }
4996 return nil, errors.New("Failed")
4997 }
4998
4999 func (s *SpiceQueryMouseMode) UnmarshalJSON(data []byte) error {
5000 var name string
5001
5002 if err := json.Unmarshal(data, &name); err != nil {
5003 return err
5004 }
5005
5006 switch name {
5007 case "client":
5008 (*s) = SpiceQueryMouseModeClient
5009 case "server":
5010 (*s) = SpiceQueryMouseModeServer
5011 case "unknown":
5012 (*s) = SpiceQueryMouseModeUnknown
5013 default:
5014 fmt.Println("Failed to decode SpiceQueryMouseMode", *s)
5015 }
5016 return nil
5017 }
5018
5019
5020
5021
5022 type VncPrimaryAuth int32
5023
5024 const (
5025 VncPrimaryAuthNone VncPrimaryAuth = iota
5026 VncPrimaryAuthVnc
5027 VncPrimaryAuthRa2
5028 VncPrimaryAuthRa2Ne
5029 VncPrimaryAuthTight
5030 VncPrimaryAuthUltra
5031 VncPrimaryAuthTls
5032 VncPrimaryAuthVencrypt
5033 VncPrimaryAuthSasl
5034 )
5035
5036 func (s VncPrimaryAuth) MarshalJSON() ([]byte, error) {
5037 switch s {
5038 case VncPrimaryAuthNone:
5039 return []byte(`"none"`), nil
5040 case VncPrimaryAuthVnc:
5041 return []byte(`"vnc"`), nil
5042 case VncPrimaryAuthRa2:
5043 return []byte(`"ra2"`), nil
5044 case VncPrimaryAuthRa2Ne:
5045 return []byte(`"ra2ne"`), nil
5046 case VncPrimaryAuthTight:
5047 return []byte(`"tight"`), nil
5048 case VncPrimaryAuthUltra:
5049 return []byte(`"ultra"`), nil
5050 case VncPrimaryAuthTls:
5051 return []byte(`"tls"`), nil
5052 case VncPrimaryAuthVencrypt:
5053 return []byte(`"vencrypt"`), nil
5054 case VncPrimaryAuthSasl:
5055 return []byte(`"sasl"`), nil
5056 default:
5057 fmt.Println("Failed to decode VncPrimaryAuth", s)
5058 }
5059 return nil, errors.New("Failed")
5060 }
5061
5062 func (s *VncPrimaryAuth) UnmarshalJSON(data []byte) error {
5063 var name string
5064
5065 if err := json.Unmarshal(data, &name); err != nil {
5066 return err
5067 }
5068
5069 switch name {
5070 case "none":
5071 (*s) = VncPrimaryAuthNone
5072 case "vnc":
5073 (*s) = VncPrimaryAuthVnc
5074 case "ra2":
5075 (*s) = VncPrimaryAuthRa2
5076 case "ra2ne":
5077 (*s) = VncPrimaryAuthRa2Ne
5078 case "tight":
5079 (*s) = VncPrimaryAuthTight
5080 case "ultra":
5081 (*s) = VncPrimaryAuthUltra
5082 case "tls":
5083 (*s) = VncPrimaryAuthTls
5084 case "vencrypt":
5085 (*s) = VncPrimaryAuthVencrypt
5086 case "sasl":
5087 (*s) = VncPrimaryAuthSasl
5088 default:
5089 fmt.Println("Failed to decode VncPrimaryAuth", *s)
5090 }
5091 return nil
5092 }
5093
5094
5095
5096
5097 type VncVencryptSubAuth int32
5098
5099 const (
5100 VncVencryptSubAuthPlain VncVencryptSubAuth = iota
5101 VncVencryptSubAuthTlsNone
5102 VncVencryptSubAuthX509None
5103 VncVencryptSubAuthTlsVnc
5104 VncVencryptSubAuthX509Vnc
5105 VncVencryptSubAuthTlsPlain
5106 VncVencryptSubAuthX509Plain
5107 VncVencryptSubAuthTlsSasl
5108 VncVencryptSubAuthX509Sasl
5109 )
5110
5111 func (s VncVencryptSubAuth) MarshalJSON() ([]byte, error) {
5112 switch s {
5113 case VncVencryptSubAuthPlain:
5114 return []byte(`"plain"`), nil
5115 case VncVencryptSubAuthTlsNone:
5116 return []byte(`"tls-none"`), nil
5117 case VncVencryptSubAuthX509None:
5118 return []byte(`"x509-none"`), nil
5119 case VncVencryptSubAuthTlsVnc:
5120 return []byte(`"tls-vnc"`), nil
5121 case VncVencryptSubAuthX509Vnc:
5122 return []byte(`"x509-vnc"`), nil
5123 case VncVencryptSubAuthTlsPlain:
5124 return []byte(`"tls-plain"`), nil
5125 case VncVencryptSubAuthX509Plain:
5126 return []byte(`"x509-plain"`), nil
5127 case VncVencryptSubAuthTlsSasl:
5128 return []byte(`"tls-sasl"`), nil
5129 case VncVencryptSubAuthX509Sasl:
5130 return []byte(`"x509-sasl"`), nil
5131 default:
5132 fmt.Println("Failed to decode VncVencryptSubAuth", s)
5133 }
5134 return nil, errors.New("Failed")
5135 }
5136
5137 func (s *VncVencryptSubAuth) UnmarshalJSON(data []byte) error {
5138 var name string
5139
5140 if err := json.Unmarshal(data, &name); err != nil {
5141 return err
5142 }
5143
5144 switch name {
5145 case "plain":
5146 (*s) = VncVencryptSubAuthPlain
5147 case "tls-none":
5148 (*s) = VncVencryptSubAuthTlsNone
5149 case "x509-none":
5150 (*s) = VncVencryptSubAuthX509None
5151 case "tls-vnc":
5152 (*s) = VncVencryptSubAuthTlsVnc
5153 case "x509-vnc":
5154 (*s) = VncVencryptSubAuthX509Vnc
5155 case "tls-plain":
5156 (*s) = VncVencryptSubAuthTlsPlain
5157 case "x509-plain":
5158 (*s) = VncVencryptSubAuthX509Plain
5159 case "tls-sasl":
5160 (*s) = VncVencryptSubAuthTlsSasl
5161 case "x509-sasl":
5162 (*s) = VncVencryptSubAuthX509Sasl
5163 default:
5164 fmt.Println("Failed to decode VncVencryptSubAuth", *s)
5165 }
5166 return nil
5167 }
5168
5169
5170
5171
5172
5173
5174
5175
5176
5177
5178
5179
5180
5181 type QKeyCode int32
5182
5183 const (
5184 QKeyCodeUnmapped QKeyCode = iota
5185 QKeyCodeShift
5186 QKeyCodeShift_R
5187 QKeyCodeAlt
5188 QKeyCodeAlt_R
5189 QKeyCodeCtrl
5190 QKeyCodeCtrl_R
5191 QKeyCodeMenu
5192 QKeyCodeEsc
5193 QKeyCode1
5194 QKeyCode2
5195 QKeyCode3
5196 QKeyCode4
5197 QKeyCode5
5198 QKeyCode6
5199 QKeyCode7
5200 QKeyCode8
5201 QKeyCode9
5202 QKeyCode0
5203 QKeyCodeMinus
5204 QKeyCodeEqual
5205 QKeyCodeBackspace
5206 QKeyCodeTab
5207 QKeyCodeQ
5208 QKeyCodeW
5209 QKeyCodeE
5210 QKeyCodeR
5211 QKeyCodeT
5212 QKeyCodeY
5213 QKeyCodeU
5214 QKeyCodeI
5215 QKeyCodeO
5216 QKeyCodeP
5217 QKeyCodeBracket_Left
5218 QKeyCodeBracket_Right
5219 QKeyCodeRet
5220 QKeyCodeA
5221 QKeyCodeS
5222 QKeyCodeD
5223 QKeyCodeF
5224 QKeyCodeG
5225 QKeyCodeH
5226 QKeyCodeJ
5227 QKeyCodeK
5228 QKeyCodeL
5229 QKeyCodeSemicolon
5230 QKeyCodeApostrophe
5231 QKeyCodeGrave_Accent
5232 QKeyCodeBackslash
5233 QKeyCodeZ
5234 QKeyCodeX
5235 QKeyCodeC
5236 QKeyCodeV
5237 QKeyCodeB
5238 QKeyCodeN
5239 QKeyCodeM
5240 QKeyCodeComma
5241 QKeyCodeDot
5242 QKeyCodeSlash
5243 QKeyCodeAsterisk
5244 QKeyCodeSpc
5245 QKeyCodeCaps_Lock
5246 QKeyCodeF1
5247 QKeyCodeF2
5248 QKeyCodeF3
5249 QKeyCodeF4
5250 QKeyCodeF5
5251 QKeyCodeF6
5252 QKeyCodeF7
5253 QKeyCodeF8
5254 QKeyCodeF9
5255 QKeyCodeF10
5256 QKeyCodeNum_Lock
5257 QKeyCodeScroll_Lock
5258 QKeyCodeKp_Divide
5259 QKeyCodeKp_Multiply
5260 QKeyCodeKp_Subtract
5261 QKeyCodeKp_Add
5262 QKeyCodeKp_Enter
5263 QKeyCodeKp_Decimal
5264 QKeyCodeSysrq
5265 QKeyCodeKp_0
5266 QKeyCodeKp_1
5267 QKeyCodeKp_2
5268 QKeyCodeKp_3
5269 QKeyCodeKp_4
5270 QKeyCodeKp_5
5271 QKeyCodeKp_6
5272 QKeyCodeKp_7
5273 QKeyCodeKp_8
5274 QKeyCodeKp_9
5275 QKeyCodeLess
5276 QKeyCodeF11
5277 QKeyCodeF12
5278 QKeyCodePrint
5279 QKeyCodeHome
5280 QKeyCodePgup
5281 QKeyCodePgdn
5282 QKeyCodeEnd
5283 QKeyCodeLeft
5284 QKeyCodeUp
5285 QKeyCodeDown
5286 QKeyCodeRight
5287 QKeyCodeInsert
5288 QKeyCodeDelete
5289 QKeyCodeStop
5290 QKeyCodeAgain
5291 QKeyCodeProps
5292 QKeyCodeUndo
5293 QKeyCodeFront
5294 QKeyCodeCopy
5295 QKeyCodeOpen
5296 QKeyCodePaste
5297 QKeyCodeFind
5298 QKeyCodeCut
5299 QKeyCodeLf
5300 QKeyCodeHelp
5301 QKeyCodeMeta_L
5302 QKeyCodeMeta_R
5303 QKeyCodeCompose
5304 QKeyCodePause
5305 QKeyCodeRo
5306 QKeyCodeHiragana
5307 QKeyCodeHenkan
5308 QKeyCodeYen
5309 QKeyCodeMuhenkan
5310 QKeyCodeKatakanahiragana
5311 QKeyCodeKp_Comma
5312 QKeyCodeKp_Equals
5313 QKeyCodePower
5314 QKeyCodeSleep
5315 QKeyCodeWake
5316 QKeyCodeAudionext
5317 QKeyCodeAudioprev
5318 QKeyCodeAudiostop
5319 QKeyCodeAudioplay
5320 QKeyCodeAudiomute
5321 QKeyCodeVolumeup
5322 QKeyCodeVolumedown
5323 QKeyCodeMediaselect
5324 QKeyCodeMail
5325 QKeyCodeCalculator
5326 QKeyCodeComputer
5327 QKeyCodeAc_Home
5328 QKeyCodeAc_Back
5329 QKeyCodeAc_Forward
5330 QKeyCodeAc_Refresh
5331 QKeyCodeAc_Bookmarks
5332 QKeyCodeLang1
5333 QKeyCodeLang2
5334 )
5335
5336 func (s QKeyCode) MarshalJSON() ([]byte, error) {
5337 switch s {
5338 case QKeyCodeUnmapped:
5339 return []byte(`"unmapped"`), nil
5340 case QKeyCodeShift:
5341 return []byte(`"shift"`), nil
5342 case QKeyCodeShift_R:
5343 return []byte(`"shift_r"`), nil
5344 case QKeyCodeAlt:
5345 return []byte(`"alt"`), nil
5346 case QKeyCodeAlt_R:
5347 return []byte(`"alt_r"`), nil
5348 case QKeyCodeCtrl:
5349 return []byte(`"ctrl"`), nil
5350 case QKeyCodeCtrl_R:
5351 return []byte(`"ctrl_r"`), nil
5352 case QKeyCodeMenu:
5353 return []byte(`"menu"`), nil
5354 case QKeyCodeEsc:
5355 return []byte(`"esc"`), nil
5356 case QKeyCode1:
5357 return []byte(`"1"`), nil
5358 case QKeyCode2:
5359 return []byte(`"2"`), nil
5360 case QKeyCode3:
5361 return []byte(`"3"`), nil
5362 case QKeyCode4:
5363 return []byte(`"4"`), nil
5364 case QKeyCode5:
5365 return []byte(`"5"`), nil
5366 case QKeyCode6:
5367 return []byte(`"6"`), nil
5368 case QKeyCode7:
5369 return []byte(`"7"`), nil
5370 case QKeyCode8:
5371 return []byte(`"8"`), nil
5372 case QKeyCode9:
5373 return []byte(`"9"`), nil
5374 case QKeyCode0:
5375 return []byte(`"0"`), nil
5376 case QKeyCodeMinus:
5377 return []byte(`"minus"`), nil
5378 case QKeyCodeEqual:
5379 return []byte(`"equal"`), nil
5380 case QKeyCodeBackspace:
5381 return []byte(`"backspace"`), nil
5382 case QKeyCodeTab:
5383 return []byte(`"tab"`), nil
5384 case QKeyCodeQ:
5385 return []byte(`"q"`), nil
5386 case QKeyCodeW:
5387 return []byte(`"w"`), nil
5388 case QKeyCodeE:
5389 return []byte(`"e"`), nil
5390 case QKeyCodeR:
5391 return []byte(`"r"`), nil
5392 case QKeyCodeT:
5393 return []byte(`"t"`), nil
5394 case QKeyCodeY:
5395 return []byte(`"y"`), nil
5396 case QKeyCodeU:
5397 return []byte(`"u"`), nil
5398 case QKeyCodeI:
5399 return []byte(`"i"`), nil
5400 case QKeyCodeO:
5401 return []byte(`"o"`), nil
5402 case QKeyCodeP:
5403 return []byte(`"p"`), nil
5404 case QKeyCodeBracket_Left:
5405 return []byte(`"bracket_left"`), nil
5406 case QKeyCodeBracket_Right:
5407 return []byte(`"bracket_right"`), nil
5408 case QKeyCodeRet:
5409 return []byte(`"ret"`), nil
5410 case QKeyCodeA:
5411 return []byte(`"a"`), nil
5412 case QKeyCodeS:
5413 return []byte(`"s"`), nil
5414 case QKeyCodeD:
5415 return []byte(`"d"`), nil
5416 case QKeyCodeF:
5417 return []byte(`"f"`), nil
5418 case QKeyCodeG:
5419 return []byte(`"g"`), nil
5420 case QKeyCodeH:
5421 return []byte(`"h"`), nil
5422 case QKeyCodeJ:
5423 return []byte(`"j"`), nil
5424 case QKeyCodeK:
5425 return []byte(`"k"`), nil
5426 case QKeyCodeL:
5427 return []byte(`"l"`), nil
5428 case QKeyCodeSemicolon:
5429 return []byte(`"semicolon"`), nil
5430 case QKeyCodeApostrophe:
5431 return []byte(`"apostrophe"`), nil
5432 case QKeyCodeGrave_Accent:
5433 return []byte(`"grave_accent"`), nil
5434 case QKeyCodeBackslash:
5435 return []byte(`"backslash"`), nil
5436 case QKeyCodeZ:
5437 return []byte(`"z"`), nil
5438 case QKeyCodeX:
5439 return []byte(`"x"`), nil
5440 case QKeyCodeC:
5441 return []byte(`"c"`), nil
5442 case QKeyCodeV:
5443 return []byte(`"v"`), nil
5444 case QKeyCodeB:
5445 return []byte(`"b"`), nil
5446 case QKeyCodeN:
5447 return []byte(`"n"`), nil
5448 case QKeyCodeM:
5449 return []byte(`"m"`), nil
5450 case QKeyCodeComma:
5451 return []byte(`"comma"`), nil
5452 case QKeyCodeDot:
5453 return []byte(`"dot"`), nil
5454 case QKeyCodeSlash:
5455 return []byte(`"slash"`), nil
5456 case QKeyCodeAsterisk:
5457 return []byte(`"asterisk"`), nil
5458 case QKeyCodeSpc:
5459 return []byte(`"spc"`), nil
5460 case QKeyCodeCaps_Lock:
5461 return []byte(`"caps_lock"`), nil
5462 case QKeyCodeF1:
5463 return []byte(`"f1"`), nil
5464 case QKeyCodeF2:
5465 return []byte(`"f2"`), nil
5466 case QKeyCodeF3:
5467 return []byte(`"f3"`), nil
5468 case QKeyCodeF4:
5469 return []byte(`"f4"`), nil
5470 case QKeyCodeF5:
5471 return []byte(`"f5"`), nil
5472 case QKeyCodeF6:
5473 return []byte(`"f6"`), nil
5474 case QKeyCodeF7:
5475 return []byte(`"f7"`), nil
5476 case QKeyCodeF8:
5477 return []byte(`"f8"`), nil
5478 case QKeyCodeF9:
5479 return []byte(`"f9"`), nil
5480 case QKeyCodeF10:
5481 return []byte(`"f10"`), nil
5482 case QKeyCodeNum_Lock:
5483 return []byte(`"num_lock"`), nil
5484 case QKeyCodeScroll_Lock:
5485 return []byte(`"scroll_lock"`), nil
5486 case QKeyCodeKp_Divide:
5487 return []byte(`"kp_divide"`), nil
5488 case QKeyCodeKp_Multiply:
5489 return []byte(`"kp_multiply"`), nil
5490 case QKeyCodeKp_Subtract:
5491 return []byte(`"kp_subtract"`), nil
5492 case QKeyCodeKp_Add:
5493 return []byte(`"kp_add"`), nil
5494 case QKeyCodeKp_Enter:
5495 return []byte(`"kp_enter"`), nil
5496 case QKeyCodeKp_Decimal:
5497 return []byte(`"kp_decimal"`), nil
5498 case QKeyCodeSysrq:
5499 return []byte(`"sysrq"`), nil
5500 case QKeyCodeKp_0:
5501 return []byte(`"kp_0"`), nil
5502 case QKeyCodeKp_1:
5503 return []byte(`"kp_1"`), nil
5504 case QKeyCodeKp_2:
5505 return []byte(`"kp_2"`), nil
5506 case QKeyCodeKp_3:
5507 return []byte(`"kp_3"`), nil
5508 case QKeyCodeKp_4:
5509 return []byte(`"kp_4"`), nil
5510 case QKeyCodeKp_5:
5511 return []byte(`"kp_5"`), nil
5512 case QKeyCodeKp_6:
5513 return []byte(`"kp_6"`), nil
5514 case QKeyCodeKp_7:
5515 return []byte(`"kp_7"`), nil
5516 case QKeyCodeKp_8:
5517 return []byte(`"kp_8"`), nil
5518 case QKeyCodeKp_9:
5519 return []byte(`"kp_9"`), nil
5520 case QKeyCodeLess:
5521 return []byte(`"less"`), nil
5522 case QKeyCodeF11:
5523 return []byte(`"f11"`), nil
5524 case QKeyCodeF12:
5525 return []byte(`"f12"`), nil
5526 case QKeyCodePrint:
5527 return []byte(`"print"`), nil
5528 case QKeyCodeHome:
5529 return []byte(`"home"`), nil
5530 case QKeyCodePgup:
5531 return []byte(`"pgup"`), nil
5532 case QKeyCodePgdn:
5533 return []byte(`"pgdn"`), nil
5534 case QKeyCodeEnd:
5535 return []byte(`"end"`), nil
5536 case QKeyCodeLeft:
5537 return []byte(`"left"`), nil
5538 case QKeyCodeUp:
5539 return []byte(`"up"`), nil
5540 case QKeyCodeDown:
5541 return []byte(`"down"`), nil
5542 case QKeyCodeRight:
5543 return []byte(`"right"`), nil
5544 case QKeyCodeInsert:
5545 return []byte(`"insert"`), nil
5546 case QKeyCodeDelete:
5547 return []byte(`"delete"`), nil
5548 case QKeyCodeStop:
5549 return []byte(`"stop"`), nil
5550 case QKeyCodeAgain:
5551 return []byte(`"again"`), nil
5552 case QKeyCodeProps:
5553 return []byte(`"props"`), nil
5554 case QKeyCodeUndo:
5555 return []byte(`"undo"`), nil
5556 case QKeyCodeFront:
5557 return []byte(`"front"`), nil
5558 case QKeyCodeCopy:
5559 return []byte(`"copy"`), nil
5560 case QKeyCodeOpen:
5561 return []byte(`"open"`), nil
5562 case QKeyCodePaste:
5563 return []byte(`"paste"`), nil
5564 case QKeyCodeFind:
5565 return []byte(`"find"`), nil
5566 case QKeyCodeCut:
5567 return []byte(`"cut"`), nil
5568 case QKeyCodeLf:
5569 return []byte(`"lf"`), nil
5570 case QKeyCodeHelp:
5571 return []byte(`"help"`), nil
5572 case QKeyCodeMeta_L:
5573 return []byte(`"meta_l"`), nil
5574 case QKeyCodeMeta_R:
5575 return []byte(`"meta_r"`), nil
5576 case QKeyCodeCompose:
5577 return []byte(`"compose"`), nil
5578 case QKeyCodePause:
5579 return []byte(`"pause"`), nil
5580 case QKeyCodeRo:
5581 return []byte(`"ro"`), nil
5582 case QKeyCodeHiragana:
5583 return []byte(`"hiragana"`), nil
5584 case QKeyCodeHenkan:
5585 return []byte(`"henkan"`), nil
5586 case QKeyCodeYen:
5587 return []byte(`"yen"`), nil
5588 case QKeyCodeMuhenkan:
5589 return []byte(`"muhenkan"`), nil
5590 case QKeyCodeKatakanahiragana:
5591 return []byte(`"katakanahiragana"`), nil
5592 case QKeyCodeKp_Comma:
5593 return []byte(`"kp_comma"`), nil
5594 case QKeyCodeKp_Equals:
5595 return []byte(`"kp_equals"`), nil
5596 case QKeyCodePower:
5597 return []byte(`"power"`), nil
5598 case QKeyCodeSleep:
5599 return []byte(`"sleep"`), nil
5600 case QKeyCodeWake:
5601 return []byte(`"wake"`), nil
5602 case QKeyCodeAudionext:
5603 return []byte(`"audionext"`), nil
5604 case QKeyCodeAudioprev:
5605 return []byte(`"audioprev"`), nil
5606 case QKeyCodeAudiostop:
5607 return []byte(`"audiostop"`), nil
5608 case QKeyCodeAudioplay:
5609 return []byte(`"audioplay"`), nil
5610 case QKeyCodeAudiomute:
5611 return []byte(`"audiomute"`), nil
5612 case QKeyCodeVolumeup:
5613 return []byte(`"volumeup"`), nil
5614 case QKeyCodeVolumedown:
5615 return []byte(`"volumedown"`), nil
5616 case QKeyCodeMediaselect:
5617 return []byte(`"mediaselect"`), nil
5618 case QKeyCodeMail:
5619 return []byte(`"mail"`), nil
5620 case QKeyCodeCalculator:
5621 return []byte(`"calculator"`), nil
5622 case QKeyCodeComputer:
5623 return []byte(`"computer"`), nil
5624 case QKeyCodeAc_Home:
5625 return []byte(`"ac_home"`), nil
5626 case QKeyCodeAc_Back:
5627 return []byte(`"ac_back"`), nil
5628 case QKeyCodeAc_Forward:
5629 return []byte(`"ac_forward"`), nil
5630 case QKeyCodeAc_Refresh:
5631 return []byte(`"ac_refresh"`), nil
5632 case QKeyCodeAc_Bookmarks:
5633 return []byte(`"ac_bookmarks"`), nil
5634 case QKeyCodeLang1:
5635 return []byte(`"lang1"`), nil
5636 case QKeyCodeLang2:
5637 return []byte(`"lang2"`), nil
5638 default:
5639 fmt.Println("Failed to decode QKeyCode", s)
5640 }
5641 return nil, errors.New("Failed")
5642 }
5643
5644 func (s *QKeyCode) UnmarshalJSON(data []byte) error {
5645 var name string
5646
5647 if err := json.Unmarshal(data, &name); err != nil {
5648 return err
5649 }
5650
5651 switch name {
5652 case "unmapped":
5653 (*s) = QKeyCodeUnmapped
5654 case "shift":
5655 (*s) = QKeyCodeShift
5656 case "shift_r":
5657 (*s) = QKeyCodeShift_R
5658 case "alt":
5659 (*s) = QKeyCodeAlt
5660 case "alt_r":
5661 (*s) = QKeyCodeAlt_R
5662 case "ctrl":
5663 (*s) = QKeyCodeCtrl
5664 case "ctrl_r":
5665 (*s) = QKeyCodeCtrl_R
5666 case "menu":
5667 (*s) = QKeyCodeMenu
5668 case "esc":
5669 (*s) = QKeyCodeEsc
5670 case "1":
5671 (*s) = QKeyCode1
5672 case "2":
5673 (*s) = QKeyCode2
5674 case "3":
5675 (*s) = QKeyCode3
5676 case "4":
5677 (*s) = QKeyCode4
5678 case "5":
5679 (*s) = QKeyCode5
5680 case "6":
5681 (*s) = QKeyCode6
5682 case "7":
5683 (*s) = QKeyCode7
5684 case "8":
5685 (*s) = QKeyCode8
5686 case "9":
5687 (*s) = QKeyCode9
5688 case "0":
5689 (*s) = QKeyCode0
5690 case "minus":
5691 (*s) = QKeyCodeMinus
5692 case "equal":
5693 (*s) = QKeyCodeEqual
5694 case "backspace":
5695 (*s) = QKeyCodeBackspace
5696 case "tab":
5697 (*s) = QKeyCodeTab
5698 case "q":
5699 (*s) = QKeyCodeQ
5700 case "w":
5701 (*s) = QKeyCodeW
5702 case "e":
5703 (*s) = QKeyCodeE
5704 case "r":
5705 (*s) = QKeyCodeR
5706 case "t":
5707 (*s) = QKeyCodeT
5708 case "y":
5709 (*s) = QKeyCodeY
5710 case "u":
5711 (*s) = QKeyCodeU
5712 case "i":
5713 (*s) = QKeyCodeI
5714 case "o":
5715 (*s) = QKeyCodeO
5716 case "p":
5717 (*s) = QKeyCodeP
5718 case "bracket_left":
5719 (*s) = QKeyCodeBracket_Left
5720 case "bracket_right":
5721 (*s) = QKeyCodeBracket_Right
5722 case "ret":
5723 (*s) = QKeyCodeRet
5724 case "a":
5725 (*s) = QKeyCodeA
5726 case "s":
5727 (*s) = QKeyCodeS
5728 case "d":
5729 (*s) = QKeyCodeD
5730 case "f":
5731 (*s) = QKeyCodeF
5732 case "g":
5733 (*s) = QKeyCodeG
5734 case "h":
5735 (*s) = QKeyCodeH
5736 case "j":
5737 (*s) = QKeyCodeJ
5738 case "k":
5739 (*s) = QKeyCodeK
5740 case "l":
5741 (*s) = QKeyCodeL
5742 case "semicolon":
5743 (*s) = QKeyCodeSemicolon
5744 case "apostrophe":
5745 (*s) = QKeyCodeApostrophe
5746 case "grave_accent":
5747 (*s) = QKeyCodeGrave_Accent
5748 case "backslash":
5749 (*s) = QKeyCodeBackslash
5750 case "z":
5751 (*s) = QKeyCodeZ
5752 case "x":
5753 (*s) = QKeyCodeX
5754 case "c":
5755 (*s) = QKeyCodeC
5756 case "v":
5757 (*s) = QKeyCodeV
5758 case "b":
5759 (*s) = QKeyCodeB
5760 case "n":
5761 (*s) = QKeyCodeN
5762 case "m":
5763 (*s) = QKeyCodeM
5764 case "comma":
5765 (*s) = QKeyCodeComma
5766 case "dot":
5767 (*s) = QKeyCodeDot
5768 case "slash":
5769 (*s) = QKeyCodeSlash
5770 case "asterisk":
5771 (*s) = QKeyCodeAsterisk
5772 case "spc":
5773 (*s) = QKeyCodeSpc
5774 case "caps_lock":
5775 (*s) = QKeyCodeCaps_Lock
5776 case "f1":
5777 (*s) = QKeyCodeF1
5778 case "f2":
5779 (*s) = QKeyCodeF2
5780 case "f3":
5781 (*s) = QKeyCodeF3
5782 case "f4":
5783 (*s) = QKeyCodeF4
5784 case "f5":
5785 (*s) = QKeyCodeF5
5786 case "f6":
5787 (*s) = QKeyCodeF6
5788 case "f7":
5789 (*s) = QKeyCodeF7
5790 case "f8":
5791 (*s) = QKeyCodeF8
5792 case "f9":
5793 (*s) = QKeyCodeF9
5794 case "f10":
5795 (*s) = QKeyCodeF10
5796 case "num_lock":
5797 (*s) = QKeyCodeNum_Lock
5798 case "scroll_lock":
5799 (*s) = QKeyCodeScroll_Lock
5800 case "kp_divide":
5801 (*s) = QKeyCodeKp_Divide
5802 case "kp_multiply":
5803 (*s) = QKeyCodeKp_Multiply
5804 case "kp_subtract":
5805 (*s) = QKeyCodeKp_Subtract
5806 case "kp_add":
5807 (*s) = QKeyCodeKp_Add
5808 case "kp_enter":
5809 (*s) = QKeyCodeKp_Enter
5810 case "kp_decimal":
5811 (*s) = QKeyCodeKp_Decimal
5812 case "sysrq":
5813 (*s) = QKeyCodeSysrq
5814 case "kp_0":
5815 (*s) = QKeyCodeKp_0
5816 case "kp_1":
5817 (*s) = QKeyCodeKp_1
5818 case "kp_2":
5819 (*s) = QKeyCodeKp_2
5820 case "kp_3":
5821 (*s) = QKeyCodeKp_3
5822 case "kp_4":
5823 (*s) = QKeyCodeKp_4
5824 case "kp_5":
5825 (*s) = QKeyCodeKp_5
5826 case "kp_6":
5827 (*s) = QKeyCodeKp_6
5828 case "kp_7":
5829 (*s) = QKeyCodeKp_7
5830 case "kp_8":
5831 (*s) = QKeyCodeKp_8
5832 case "kp_9":
5833 (*s) = QKeyCodeKp_9
5834 case "less":
5835 (*s) = QKeyCodeLess
5836 case "f11":
5837 (*s) = QKeyCodeF11
5838 case "f12":
5839 (*s) = QKeyCodeF12
5840 case "print":
5841 (*s) = QKeyCodePrint
5842 case "home":
5843 (*s) = QKeyCodeHome
5844 case "pgup":
5845 (*s) = QKeyCodePgup
5846 case "pgdn":
5847 (*s) = QKeyCodePgdn
5848 case "end":
5849 (*s) = QKeyCodeEnd
5850 case "left":
5851 (*s) = QKeyCodeLeft
5852 case "up":
5853 (*s) = QKeyCodeUp
5854 case "down":
5855 (*s) = QKeyCodeDown
5856 case "right":
5857 (*s) = QKeyCodeRight
5858 case "insert":
5859 (*s) = QKeyCodeInsert
5860 case "delete":
5861 (*s) = QKeyCodeDelete
5862 case "stop":
5863 (*s) = QKeyCodeStop
5864 case "again":
5865 (*s) = QKeyCodeAgain
5866 case "props":
5867 (*s) = QKeyCodeProps
5868 case "undo":
5869 (*s) = QKeyCodeUndo
5870 case "front":
5871 (*s) = QKeyCodeFront
5872 case "copy":
5873 (*s) = QKeyCodeCopy
5874 case "open":
5875 (*s) = QKeyCodeOpen
5876 case "paste":
5877 (*s) = QKeyCodePaste
5878 case "find":
5879 (*s) = QKeyCodeFind
5880 case "cut":
5881 (*s) = QKeyCodeCut
5882 case "lf":
5883 (*s) = QKeyCodeLf
5884 case "help":
5885 (*s) = QKeyCodeHelp
5886 case "meta_l":
5887 (*s) = QKeyCodeMeta_L
5888 case "meta_r":
5889 (*s) = QKeyCodeMeta_R
5890 case "compose":
5891 (*s) = QKeyCodeCompose
5892 case "pause":
5893 (*s) = QKeyCodePause
5894 case "ro":
5895 (*s) = QKeyCodeRo
5896 case "hiragana":
5897 (*s) = QKeyCodeHiragana
5898 case "henkan":
5899 (*s) = QKeyCodeHenkan
5900 case "yen":
5901 (*s) = QKeyCodeYen
5902 case "muhenkan":
5903 (*s) = QKeyCodeMuhenkan
5904 case "katakanahiragana":
5905 (*s) = QKeyCodeKatakanahiragana
5906 case "kp_comma":
5907 (*s) = QKeyCodeKp_Comma
5908 case "kp_equals":
5909 (*s) = QKeyCodeKp_Equals
5910 case "power":
5911 (*s) = QKeyCodePower
5912 case "sleep":
5913 (*s) = QKeyCodeSleep
5914 case "wake":
5915 (*s) = QKeyCodeWake
5916 case "audionext":
5917 (*s) = QKeyCodeAudionext
5918 case "audioprev":
5919 (*s) = QKeyCodeAudioprev
5920 case "audiostop":
5921 (*s) = QKeyCodeAudiostop
5922 case "audioplay":
5923 (*s) = QKeyCodeAudioplay
5924 case "audiomute":
5925 (*s) = QKeyCodeAudiomute
5926 case "volumeup":
5927 (*s) = QKeyCodeVolumeup
5928 case "volumedown":
5929 (*s) = QKeyCodeVolumedown
5930 case "mediaselect":
5931 (*s) = QKeyCodeMediaselect
5932 case "mail":
5933 (*s) = QKeyCodeMail
5934 case "calculator":
5935 (*s) = QKeyCodeCalculator
5936 case "computer":
5937 (*s) = QKeyCodeComputer
5938 case "ac_home":
5939 (*s) = QKeyCodeAc_Home
5940 case "ac_back":
5941 (*s) = QKeyCodeAc_Back
5942 case "ac_forward":
5943 (*s) = QKeyCodeAc_Forward
5944 case "ac_refresh":
5945 (*s) = QKeyCodeAc_Refresh
5946 case "ac_bookmarks":
5947 (*s) = QKeyCodeAc_Bookmarks
5948 case "lang1":
5949 (*s) = QKeyCodeLang1
5950 case "lang2":
5951 (*s) = QKeyCodeLang2
5952 default:
5953 fmt.Println("Failed to decode QKeyCode", *s)
5954 }
5955 return nil
5956 }
5957
5958
5959 type KeyValueKind int32
5960
5961 const (
5962 KeyValueKindNumber KeyValueKind = iota
5963 KeyValueKindQcode
5964 )
5965
5966 func (s KeyValueKind) MarshalJSON() ([]byte, error) {
5967 switch s {
5968 case KeyValueKindNumber:
5969 return []byte(`"number"`), nil
5970 case KeyValueKindQcode:
5971 return []byte(`"qcode"`), nil
5972 default:
5973 fmt.Println("Failed to decode KeyValueKind", s)
5974 }
5975 return nil, errors.New("Failed")
5976 }
5977
5978 func (s *KeyValueKind) UnmarshalJSON(data []byte) error {
5979 var name string
5980
5981 if err := json.Unmarshal(data, &name); err != nil {
5982 return err
5983 }
5984
5985 switch name {
5986 case "number":
5987 (*s) = KeyValueKindNumber
5988 case "qcode":
5989 (*s) = KeyValueKindQcode
5990 default:
5991 fmt.Println("Failed to decode KeyValueKind", *s)
5992 }
5993 return nil
5994 }
5995
5996
5997
5998
5999 type InputButton int32
6000
6001 const (
6002 InputButtonLeft InputButton = iota
6003 InputButtonMiddle
6004 InputButtonRight
6005 InputButtonWheelUp
6006 InputButtonWheelDown
6007 InputButtonSide
6008 InputButtonExtra
6009 InputButtonWheelLeft
6010 InputButtonWheelRight
6011 )
6012
6013 func (s InputButton) MarshalJSON() ([]byte, error) {
6014 switch s {
6015 case InputButtonLeft:
6016 return []byte(`"left"`), nil
6017 case InputButtonMiddle:
6018 return []byte(`"middle"`), nil
6019 case InputButtonRight:
6020 return []byte(`"right"`), nil
6021 case InputButtonWheelUp:
6022 return []byte(`"wheel-up"`), nil
6023 case InputButtonWheelDown:
6024 return []byte(`"wheel-down"`), nil
6025 case InputButtonSide:
6026 return []byte(`"side"`), nil
6027 case InputButtonExtra:
6028 return []byte(`"extra"`), nil
6029 case InputButtonWheelLeft:
6030 return []byte(`"wheel-left"`), nil
6031 case InputButtonWheelRight:
6032 return []byte(`"wheel-right"`), nil
6033 default:
6034 fmt.Println("Failed to decode InputButton", s)
6035 }
6036 return nil, errors.New("Failed")
6037 }
6038
6039 func (s *InputButton) UnmarshalJSON(data []byte) error {
6040 var name string
6041
6042 if err := json.Unmarshal(data, &name); err != nil {
6043 return err
6044 }
6045
6046 switch name {
6047 case "left":
6048 (*s) = InputButtonLeft
6049 case "middle":
6050 (*s) = InputButtonMiddle
6051 case "right":
6052 (*s) = InputButtonRight
6053 case "wheel-up":
6054 (*s) = InputButtonWheelUp
6055 case "wheel-down":
6056 (*s) = InputButtonWheelDown
6057 case "side":
6058 (*s) = InputButtonSide
6059 case "extra":
6060 (*s) = InputButtonExtra
6061 case "wheel-left":
6062 (*s) = InputButtonWheelLeft
6063 case "wheel-right":
6064 (*s) = InputButtonWheelRight
6065 default:
6066 fmt.Println("Failed to decode InputButton", *s)
6067 }
6068 return nil
6069 }
6070
6071
6072
6073
6074 type InputAxis int32
6075
6076 const (
6077 InputAxisX InputAxis = iota
6078 InputAxisY
6079 )
6080
6081 func (s InputAxis) MarshalJSON() ([]byte, error) {
6082 switch s {
6083 case InputAxisX:
6084 return []byte(`"x"`), nil
6085 case InputAxisY:
6086 return []byte(`"y"`), nil
6087 default:
6088 fmt.Println("Failed to decode InputAxis", s)
6089 }
6090 return nil, errors.New("Failed")
6091 }
6092
6093 func (s *InputAxis) UnmarshalJSON(data []byte) error {
6094 var name string
6095
6096 if err := json.Unmarshal(data, &name); err != nil {
6097 return err
6098 }
6099
6100 switch name {
6101 case "x":
6102 (*s) = InputAxisX
6103 case "y":
6104 (*s) = InputAxisY
6105 default:
6106 fmt.Println("Failed to decode InputAxis", *s)
6107 }
6108 return nil
6109 }
6110
6111
6112 type InputEventKind int32
6113
6114 const (
6115 InputEventKindKey InputEventKind = iota
6116 InputEventKindBtn
6117 InputEventKindRel
6118 InputEventKindAbs
6119 )
6120
6121 func (s InputEventKind) MarshalJSON() ([]byte, error) {
6122 switch s {
6123 case InputEventKindKey:
6124 return []byte(`"key"`), nil
6125 case InputEventKindBtn:
6126 return []byte(`"btn"`), nil
6127 case InputEventKindRel:
6128 return []byte(`"rel"`), nil
6129 case InputEventKindAbs:
6130 return []byte(`"abs"`), nil
6131 default:
6132 fmt.Println("Failed to decode InputEventKind", s)
6133 }
6134 return nil, errors.New("Failed")
6135 }
6136
6137 func (s *InputEventKind) UnmarshalJSON(data []byte) error {
6138 var name string
6139
6140 if err := json.Unmarshal(data, &name); err != nil {
6141 return err
6142 }
6143
6144 switch name {
6145 case "key":
6146 (*s) = InputEventKindKey
6147 case "btn":
6148 (*s) = InputEventKindBtn
6149 case "rel":
6150 (*s) = InputEventKindRel
6151 case "abs":
6152 (*s) = InputEventKindAbs
6153 default:
6154 fmt.Println("Failed to decode InputEventKind", *s)
6155 }
6156 return nil
6157 }
6158
6159
6160
6161
6162 type DisplayGLMode int32
6163
6164 const (
6165 DisplayGLModeOff DisplayGLMode = iota
6166 DisplayGLModeOn
6167 DisplayGLModeCore
6168 DisplayGLModeEs
6169 )
6170
6171 func (s DisplayGLMode) MarshalJSON() ([]byte, error) {
6172 switch s {
6173 case DisplayGLModeOff:
6174 return []byte(`"off"`), nil
6175 case DisplayGLModeOn:
6176 return []byte(`"on"`), nil
6177 case DisplayGLModeCore:
6178 return []byte(`"core"`), nil
6179 case DisplayGLModeEs:
6180 return []byte(`"es"`), nil
6181 default:
6182 fmt.Println("Failed to decode DisplayGLMode", s)
6183 }
6184 return nil, errors.New("Failed")
6185 }
6186
6187 func (s *DisplayGLMode) UnmarshalJSON(data []byte) error {
6188 var name string
6189
6190 if err := json.Unmarshal(data, &name); err != nil {
6191 return err
6192 }
6193
6194 switch name {
6195 case "off":
6196 (*s) = DisplayGLModeOff
6197 case "on":
6198 (*s) = DisplayGLModeOn
6199 case "core":
6200 (*s) = DisplayGLModeCore
6201 case "es":
6202 (*s) = DisplayGLModeEs
6203 default:
6204 fmt.Println("Failed to decode DisplayGLMode", *s)
6205 }
6206 return nil
6207 }
6208
6209
6210
6211
6212 type DisplayType int32
6213
6214 const (
6215 DisplayTypeDefault DisplayType = iota
6216 DisplayTypeNone
6217 DisplayTypeGtk
6218 DisplayTypeSdl
6219 DisplayTypeEglHeadless
6220 DisplayTypeCurses
6221 DisplayTypeCocoa
6222 DisplayTypeSpiceApp
6223 DisplayTypeDbus
6224 )
6225
6226 func (s DisplayType) MarshalJSON() ([]byte, error) {
6227 switch s {
6228 case DisplayTypeDefault:
6229 return []byte(`"default"`), nil
6230 case DisplayTypeNone:
6231 return []byte(`"none"`), nil
6232 case DisplayTypeGtk:
6233 return []byte(`"gtk"`), nil
6234 case DisplayTypeSdl:
6235 return []byte(`"sdl"`), nil
6236 case DisplayTypeEglHeadless:
6237 return []byte(`"egl-headless"`), nil
6238 case DisplayTypeCurses:
6239 return []byte(`"curses"`), nil
6240 case DisplayTypeCocoa:
6241 return []byte(`"cocoa"`), nil
6242 case DisplayTypeSpiceApp:
6243 return []byte(`"spice-app"`), nil
6244 case DisplayTypeDbus:
6245 return []byte(`"dbus"`), nil
6246 default:
6247 fmt.Println("Failed to decode DisplayType", s)
6248 }
6249 return nil, errors.New("Failed")
6250 }
6251
6252 func (s *DisplayType) UnmarshalJSON(data []byte) error {
6253 var name string
6254
6255 if err := json.Unmarshal(data, &name); err != nil {
6256 return err
6257 }
6258
6259 switch name {
6260 case "default":
6261 (*s) = DisplayTypeDefault
6262 case "none":
6263 (*s) = DisplayTypeNone
6264 case "gtk":
6265 (*s) = DisplayTypeGtk
6266 case "sdl":
6267 (*s) = DisplayTypeSdl
6268 case "egl-headless":
6269 (*s) = DisplayTypeEglHeadless
6270 case "curses":
6271 (*s) = DisplayTypeCurses
6272 case "cocoa":
6273 (*s) = DisplayTypeCocoa
6274 case "spice-app":
6275 (*s) = DisplayTypeSpiceApp
6276 case "dbus":
6277 (*s) = DisplayTypeDbus
6278 default:
6279 fmt.Println("Failed to decode DisplayType", *s)
6280 }
6281 return nil
6282 }
6283
6284
6285
6286
6287 type DisplayReloadType int32
6288
6289 const (
6290 DisplayReloadTypeVnc DisplayReloadType = iota
6291 )
6292
6293 func (s DisplayReloadType) MarshalJSON() ([]byte, error) {
6294 switch s {
6295 case DisplayReloadTypeVnc:
6296 return []byte(`"vnc"`), nil
6297 default:
6298 fmt.Println("Failed to decode DisplayReloadType", s)
6299 }
6300 return nil, errors.New("Failed")
6301 }
6302
6303 func (s *DisplayReloadType) UnmarshalJSON(data []byte) error {
6304 var name string
6305
6306 if err := json.Unmarshal(data, &name); err != nil {
6307 return err
6308 }
6309
6310 switch name {
6311 case "vnc":
6312 (*s) = DisplayReloadTypeVnc
6313 default:
6314 fmt.Println("Failed to decode DisplayReloadType", *s)
6315 }
6316 return nil
6317 }
6318
6319
6320
6321
6322 type QAuthZListPolicy int32
6323
6324 const (
6325 QAuthZListPolicyDeny QAuthZListPolicy = iota
6326 QAuthZListPolicyAllow
6327 )
6328
6329 func (s QAuthZListPolicy) MarshalJSON() ([]byte, error) {
6330 switch s {
6331 case QAuthZListPolicyDeny:
6332 return []byte(`"deny"`), nil
6333 case QAuthZListPolicyAllow:
6334 return []byte(`"allow"`), nil
6335 default:
6336 fmt.Println("Failed to decode QAuthZListPolicy", s)
6337 }
6338 return nil, errors.New("Failed")
6339 }
6340
6341 func (s *QAuthZListPolicy) UnmarshalJSON(data []byte) error {
6342 var name string
6343
6344 if err := json.Unmarshal(data, &name); err != nil {
6345 return err
6346 }
6347
6348 switch name {
6349 case "deny":
6350 (*s) = QAuthZListPolicyDeny
6351 case "allow":
6352 (*s) = QAuthZListPolicyAllow
6353 default:
6354 fmt.Println("Failed to decode QAuthZListPolicy", *s)
6355 }
6356 return nil
6357 }
6358
6359
6360
6361
6362 type QAuthZListFormat int32
6363
6364 const (
6365 QAuthZListFormatExact QAuthZListFormat = iota
6366 QAuthZListFormatGlob
6367 )
6368
6369 func (s QAuthZListFormat) MarshalJSON() ([]byte, error) {
6370 switch s {
6371 case QAuthZListFormatExact:
6372 return []byte(`"exact"`), nil
6373 case QAuthZListFormatGlob:
6374 return []byte(`"glob"`), nil
6375 default:
6376 fmt.Println("Failed to decode QAuthZListFormat", s)
6377 }
6378 return nil, errors.New("Failed")
6379 }
6380
6381 func (s *QAuthZListFormat) UnmarshalJSON(data []byte) error {
6382 var name string
6383
6384 if err := json.Unmarshal(data, &name); err != nil {
6385 return err
6386 }
6387
6388 switch name {
6389 case "exact":
6390 (*s) = QAuthZListFormatExact
6391 case "glob":
6392 (*s) = QAuthZListFormatGlob
6393 default:
6394 fmt.Println("Failed to decode QAuthZListFormat", *s)
6395 }
6396 return nil
6397 }
6398
6399
6400
6401
6402 type MigrationStatus int32
6403
6404 const (
6405 MigrationStatusNone MigrationStatus = iota
6406 MigrationStatusSetup
6407 MigrationStatusCancelling
6408 MigrationStatusCancelled
6409 MigrationStatusActive
6410 MigrationStatusPostcopyActive
6411 MigrationStatusPostcopyPaused
6412 MigrationStatusPostcopyRecover
6413 MigrationStatusCompleted
6414 MigrationStatusFailed
6415 MigrationStatusColo
6416 MigrationStatusPreSwitchover
6417 MigrationStatusDevice
6418 MigrationStatusWaitUnplug
6419 )
6420
6421 func (s MigrationStatus) MarshalJSON() ([]byte, error) {
6422 switch s {
6423 case MigrationStatusNone:
6424 return []byte(`"none"`), nil
6425 case MigrationStatusSetup:
6426 return []byte(`"setup"`), nil
6427 case MigrationStatusCancelling:
6428 return []byte(`"cancelling"`), nil
6429 case MigrationStatusCancelled:
6430 return []byte(`"cancelled"`), nil
6431 case MigrationStatusActive:
6432 return []byte(`"active"`), nil
6433 case MigrationStatusPostcopyActive:
6434 return []byte(`"postcopy-active"`), nil
6435 case MigrationStatusPostcopyPaused:
6436 return []byte(`"postcopy-paused"`), nil
6437 case MigrationStatusPostcopyRecover:
6438 return []byte(`"postcopy-recover"`), nil
6439 case MigrationStatusCompleted:
6440 return []byte(`"completed"`), nil
6441 case MigrationStatusFailed:
6442 return []byte(`"failed"`), nil
6443 case MigrationStatusColo:
6444 return []byte(`"colo"`), nil
6445 case MigrationStatusPreSwitchover:
6446 return []byte(`"pre-switchover"`), nil
6447 case MigrationStatusDevice:
6448 return []byte(`"device"`), nil
6449 case MigrationStatusWaitUnplug:
6450 return []byte(`"wait-unplug"`), nil
6451 default:
6452 fmt.Println("Failed to decode MigrationStatus", s)
6453 }
6454 return nil, errors.New("Failed")
6455 }
6456
6457 func (s *MigrationStatus) UnmarshalJSON(data []byte) error {
6458 var name string
6459
6460 if err := json.Unmarshal(data, &name); err != nil {
6461 return err
6462 }
6463
6464 switch name {
6465 case "none":
6466 (*s) = MigrationStatusNone
6467 case "setup":
6468 (*s) = MigrationStatusSetup
6469 case "cancelling":
6470 (*s) = MigrationStatusCancelling
6471 case "cancelled":
6472 (*s) = MigrationStatusCancelled
6473 case "active":
6474 (*s) = MigrationStatusActive
6475 case "postcopy-active":
6476 (*s) = MigrationStatusPostcopyActive
6477 case "postcopy-paused":
6478 (*s) = MigrationStatusPostcopyPaused
6479 case "postcopy-recover":
6480 (*s) = MigrationStatusPostcopyRecover
6481 case "completed":
6482 (*s) = MigrationStatusCompleted
6483 case "failed":
6484 (*s) = MigrationStatusFailed
6485 case "colo":
6486 (*s) = MigrationStatusColo
6487 case "pre-switchover":
6488 (*s) = MigrationStatusPreSwitchover
6489 case "device":
6490 (*s) = MigrationStatusDevice
6491 case "wait-unplug":
6492 (*s) = MigrationStatusWaitUnplug
6493 default:
6494 fmt.Println("Failed to decode MigrationStatus", *s)
6495 }
6496 return nil
6497 }
6498
6499
6500
6501
6502 type MigrationCapability int32
6503
6504 const (
6505 MigrationCapabilityXbzrle MigrationCapability = iota
6506 MigrationCapabilityRdmaPinAll
6507 MigrationCapabilityAutoConverge
6508 MigrationCapabilityZeroBlocks
6509 MigrationCapabilityCompress
6510 MigrationCapabilityEvents
6511 MigrationCapabilityPostcopyRam
6512 MigrationCapabilityXColo
6513 MigrationCapabilityReleaseRam
6514 MigrationCapabilityBlock
6515 MigrationCapabilityReturnPath
6516 MigrationCapabilityPauseBeforeSwitchover
6517 MigrationCapabilityMultifd
6518 MigrationCapabilityDirtyBitmaps
6519 MigrationCapabilityPostcopyBlocktime
6520 MigrationCapabilityLateBlockActivate
6521 MigrationCapabilityXIgnoreShared
6522 MigrationCapabilityValidateUuid
6523 MigrationCapabilityBackgroundSnapshot
6524 )
6525
6526 func (s MigrationCapability) MarshalJSON() ([]byte, error) {
6527 switch s {
6528 case MigrationCapabilityXbzrle:
6529 return []byte(`"xbzrle"`), nil
6530 case MigrationCapabilityRdmaPinAll:
6531 return []byte(`"rdma-pin-all"`), nil
6532 case MigrationCapabilityAutoConverge:
6533 return []byte(`"auto-converge"`), nil
6534 case MigrationCapabilityZeroBlocks:
6535 return []byte(`"zero-blocks"`), nil
6536 case MigrationCapabilityCompress:
6537 return []byte(`"compress"`), nil
6538 case MigrationCapabilityEvents:
6539 return []byte(`"events"`), nil
6540 case MigrationCapabilityPostcopyRam:
6541 return []byte(`"postcopy-ram"`), nil
6542 case MigrationCapabilityXColo:
6543 return []byte(`"x-colo"`), nil
6544 case MigrationCapabilityReleaseRam:
6545 return []byte(`"release-ram"`), nil
6546 case MigrationCapabilityBlock:
6547 return []byte(`"block"`), nil
6548 case MigrationCapabilityReturnPath:
6549 return []byte(`"return-path"`), nil
6550 case MigrationCapabilityPauseBeforeSwitchover:
6551 return []byte(`"pause-before-switchover"`), nil
6552 case MigrationCapabilityMultifd:
6553 return []byte(`"multifd"`), nil
6554 case MigrationCapabilityDirtyBitmaps:
6555 return []byte(`"dirty-bitmaps"`), nil
6556 case MigrationCapabilityPostcopyBlocktime:
6557 return []byte(`"postcopy-blocktime"`), nil
6558 case MigrationCapabilityLateBlockActivate:
6559 return []byte(`"late-block-activate"`), nil
6560 case MigrationCapabilityXIgnoreShared:
6561 return []byte(`"x-ignore-shared"`), nil
6562 case MigrationCapabilityValidateUuid:
6563 return []byte(`"validate-uuid"`), nil
6564 case MigrationCapabilityBackgroundSnapshot:
6565 return []byte(`"background-snapshot"`), nil
6566 default:
6567 fmt.Println("Failed to decode MigrationCapability", s)
6568 }
6569 return nil, errors.New("Failed")
6570 }
6571
6572 func (s *MigrationCapability) UnmarshalJSON(data []byte) error {
6573 var name string
6574
6575 if err := json.Unmarshal(data, &name); err != nil {
6576 return err
6577 }
6578
6579 switch name {
6580 case "xbzrle":
6581 (*s) = MigrationCapabilityXbzrle
6582 case "rdma-pin-all":
6583 (*s) = MigrationCapabilityRdmaPinAll
6584 case "auto-converge":
6585 (*s) = MigrationCapabilityAutoConverge
6586 case "zero-blocks":
6587 (*s) = MigrationCapabilityZeroBlocks
6588 case "compress":
6589 (*s) = MigrationCapabilityCompress
6590 case "events":
6591 (*s) = MigrationCapabilityEvents
6592 case "postcopy-ram":
6593 (*s) = MigrationCapabilityPostcopyRam
6594 case "x-colo":
6595 (*s) = MigrationCapabilityXColo
6596 case "release-ram":
6597 (*s) = MigrationCapabilityReleaseRam
6598 case "block":
6599 (*s) = MigrationCapabilityBlock
6600 case "return-path":
6601 (*s) = MigrationCapabilityReturnPath
6602 case "pause-before-switchover":
6603 (*s) = MigrationCapabilityPauseBeforeSwitchover
6604 case "multifd":
6605 (*s) = MigrationCapabilityMultifd
6606 case "dirty-bitmaps":
6607 (*s) = MigrationCapabilityDirtyBitmaps
6608 case "postcopy-blocktime":
6609 (*s) = MigrationCapabilityPostcopyBlocktime
6610 case "late-block-activate":
6611 (*s) = MigrationCapabilityLateBlockActivate
6612 case "x-ignore-shared":
6613 (*s) = MigrationCapabilityXIgnoreShared
6614 case "validate-uuid":
6615 (*s) = MigrationCapabilityValidateUuid
6616 case "background-snapshot":
6617 (*s) = MigrationCapabilityBackgroundSnapshot
6618 default:
6619 fmt.Println("Failed to decode MigrationCapability", *s)
6620 }
6621 return nil
6622 }
6623
6624
6625
6626
6627 type MultiFDCompression int32
6628
6629 const (
6630 MultiFDCompressionNone MultiFDCompression = iota
6631 MultiFDCompressionZlib
6632 MultiFDCompressionZstd
6633 )
6634
6635 func (s MultiFDCompression) MarshalJSON() ([]byte, error) {
6636 switch s {
6637 case MultiFDCompressionNone:
6638 return []byte(`"none"`), nil
6639 case MultiFDCompressionZlib:
6640 return []byte(`"zlib"`), nil
6641 case MultiFDCompressionZstd:
6642 return []byte(`"zstd"`), nil
6643 default:
6644 fmt.Println("Failed to decode MultiFDCompression", s)
6645 }
6646 return nil, errors.New("Failed")
6647 }
6648
6649 func (s *MultiFDCompression) UnmarshalJSON(data []byte) error {
6650 var name string
6651
6652 if err := json.Unmarshal(data, &name); err != nil {
6653 return err
6654 }
6655
6656 switch name {
6657 case "none":
6658 (*s) = MultiFDCompressionNone
6659 case "zlib":
6660 (*s) = MultiFDCompressionZlib
6661 case "zstd":
6662 (*s) = MultiFDCompressionZstd
6663 default:
6664 fmt.Println("Failed to decode MultiFDCompression", *s)
6665 }
6666 return nil
6667 }
6668
6669
6670
6671
6672 type MigrationParameter int32
6673
6674 const (
6675 MigrationParameterAnnounceInitial MigrationParameter = iota
6676 MigrationParameterAnnounceMax
6677 MigrationParameterAnnounceRounds
6678 MigrationParameterAnnounceStep
6679 MigrationParameterCompressLevel
6680 MigrationParameterCompressThreads
6681 MigrationParameterDecompressThreads
6682 MigrationParameterCompressWaitThread
6683 MigrationParameterThrottleTriggerThreshold
6684 MigrationParameterCpuThrottleInitial
6685 MigrationParameterCpuThrottleIncrement
6686 MigrationParameterCpuThrottleTailslow
6687 MigrationParameterTlsCreds
6688 MigrationParameterTlsHostname
6689 MigrationParameterTlsAuthz
6690 MigrationParameterMaxBandwidth
6691 MigrationParameterDowntimeLimit
6692 MigrationParameterXCheckpointDelay
6693 MigrationParameterBlockIncremental
6694 MigrationParameterMultifdChannels
6695 MigrationParameterXbzrleCacheSize
6696 MigrationParameterMaxPostcopyBandwidth
6697 MigrationParameterMaxCpuThrottle
6698 MigrationParameterMultifdCompression
6699 MigrationParameterMultifdZlibLevel
6700 MigrationParameterMultifdZstdLevel
6701 MigrationParameterBlockBitmapMapping
6702 )
6703
6704 func (s MigrationParameter) MarshalJSON() ([]byte, error) {
6705 switch s {
6706 case MigrationParameterAnnounceInitial:
6707 return []byte(`"announce-initial"`), nil
6708 case MigrationParameterAnnounceMax:
6709 return []byte(`"announce-max"`), nil
6710 case MigrationParameterAnnounceRounds:
6711 return []byte(`"announce-rounds"`), nil
6712 case MigrationParameterAnnounceStep:
6713 return []byte(`"announce-step"`), nil
6714 case MigrationParameterCompressLevel:
6715 return []byte(`"compress-level"`), nil
6716 case MigrationParameterCompressThreads:
6717 return []byte(`"compress-threads"`), nil
6718 case MigrationParameterDecompressThreads:
6719 return []byte(`"decompress-threads"`), nil
6720 case MigrationParameterCompressWaitThread:
6721 return []byte(`"compress-wait-thread"`), nil
6722 case MigrationParameterThrottleTriggerThreshold:
6723 return []byte(`"throttle-trigger-threshold"`), nil
6724 case MigrationParameterCpuThrottleInitial:
6725 return []byte(`"cpu-throttle-initial"`), nil
6726 case MigrationParameterCpuThrottleIncrement:
6727 return []byte(`"cpu-throttle-increment"`), nil
6728 case MigrationParameterCpuThrottleTailslow:
6729 return []byte(`"cpu-throttle-tailslow"`), nil
6730 case MigrationParameterTlsCreds:
6731 return []byte(`"tls-creds"`), nil
6732 case MigrationParameterTlsHostname:
6733 return []byte(`"tls-hostname"`), nil
6734 case MigrationParameterTlsAuthz:
6735 return []byte(`"tls-authz"`), nil
6736 case MigrationParameterMaxBandwidth:
6737 return []byte(`"max-bandwidth"`), nil
6738 case MigrationParameterDowntimeLimit:
6739 return []byte(`"downtime-limit"`), nil
6740 case MigrationParameterXCheckpointDelay:
6741 return []byte(`"x-checkpoint-delay"`), nil
6742 case MigrationParameterBlockIncremental:
6743 return []byte(`"block-incremental"`), nil
6744 case MigrationParameterMultifdChannels:
6745 return []byte(`"multifd-channels"`), nil
6746 case MigrationParameterXbzrleCacheSize:
6747 return []byte(`"xbzrle-cache-size"`), nil
6748 case MigrationParameterMaxPostcopyBandwidth:
6749 return []byte(`"max-postcopy-bandwidth"`), nil
6750 case MigrationParameterMaxCpuThrottle:
6751 return []byte(`"max-cpu-throttle"`), nil
6752 case MigrationParameterMultifdCompression:
6753 return []byte(`"multifd-compression"`), nil
6754 case MigrationParameterMultifdZlibLevel:
6755 return []byte(`"multifd-zlib-level"`), nil
6756 case MigrationParameterMultifdZstdLevel:
6757 return []byte(`"multifd-zstd-level"`), nil
6758 case MigrationParameterBlockBitmapMapping:
6759 return []byte(`"block-bitmap-mapping"`), nil
6760 default:
6761 fmt.Println("Failed to decode MigrationParameter", s)
6762 }
6763 return nil, errors.New("Failed")
6764 }
6765
6766 func (s *MigrationParameter) UnmarshalJSON(data []byte) error {
6767 var name string
6768
6769 if err := json.Unmarshal(data, &name); err != nil {
6770 return err
6771 }
6772
6773 switch name {
6774 case "announce-initial":
6775 (*s) = MigrationParameterAnnounceInitial
6776 case "announce-max":
6777 (*s) = MigrationParameterAnnounceMax
6778 case "announce-rounds":
6779 (*s) = MigrationParameterAnnounceRounds
6780 case "announce-step":
6781 (*s) = MigrationParameterAnnounceStep
6782 case "compress-level":
6783 (*s) = MigrationParameterCompressLevel
6784 case "compress-threads":
6785 (*s) = MigrationParameterCompressThreads
6786 case "decompress-threads":
6787 (*s) = MigrationParameterDecompressThreads
6788 case "compress-wait-thread":
6789 (*s) = MigrationParameterCompressWaitThread
6790 case "throttle-trigger-threshold":
6791 (*s) = MigrationParameterThrottleTriggerThreshold
6792 case "cpu-throttle-initial":
6793 (*s) = MigrationParameterCpuThrottleInitial
6794 case "cpu-throttle-increment":
6795 (*s) = MigrationParameterCpuThrottleIncrement
6796 case "cpu-throttle-tailslow":
6797 (*s) = MigrationParameterCpuThrottleTailslow
6798 case "tls-creds":
6799 (*s) = MigrationParameterTlsCreds
6800 case "tls-hostname":
6801 (*s) = MigrationParameterTlsHostname
6802 case "tls-authz":
6803 (*s) = MigrationParameterTlsAuthz
6804 case "max-bandwidth":
6805 (*s) = MigrationParameterMaxBandwidth
6806 case "downtime-limit":
6807 (*s) = MigrationParameterDowntimeLimit
6808 case "x-checkpoint-delay":
6809 (*s) = MigrationParameterXCheckpointDelay
6810 case "block-incremental":
6811 (*s) = MigrationParameterBlockIncremental
6812 case "multifd-channels":
6813 (*s) = MigrationParameterMultifdChannels
6814 case "xbzrle-cache-size":
6815 (*s) = MigrationParameterXbzrleCacheSize
6816 case "max-postcopy-bandwidth":
6817 (*s) = MigrationParameterMaxPostcopyBandwidth
6818 case "max-cpu-throttle":
6819 (*s) = MigrationParameterMaxCpuThrottle
6820 case "multifd-compression":
6821 (*s) = MigrationParameterMultifdCompression
6822 case "multifd-zlib-level":
6823 (*s) = MigrationParameterMultifdZlibLevel
6824 case "multifd-zstd-level":
6825 (*s) = MigrationParameterMultifdZstdLevel
6826 case "block-bitmap-mapping":
6827 (*s) = MigrationParameterBlockBitmapMapping
6828 default:
6829 fmt.Println("Failed to decode MigrationParameter", *s)
6830 }
6831 return nil
6832 }
6833
6834
6835
6836
6837 type COLOMessage int32
6838
6839 const (
6840 COLOMessageCheckpointReady COLOMessage = iota
6841 COLOMessageCheckpointRequest
6842 COLOMessageCheckpointReply
6843 COLOMessageVmstateSend
6844 COLOMessageVmstateSize
6845 COLOMessageVmstateReceived
6846 COLOMessageVmstateLoaded
6847 )
6848
6849 func (s COLOMessage) MarshalJSON() ([]byte, error) {
6850 switch s {
6851 case COLOMessageCheckpointReady:
6852 return []byte(`"checkpoint-ready"`), nil
6853 case COLOMessageCheckpointRequest:
6854 return []byte(`"checkpoint-request"`), nil
6855 case COLOMessageCheckpointReply:
6856 return []byte(`"checkpoint-reply"`), nil
6857 case COLOMessageVmstateSend:
6858 return []byte(`"vmstate-send"`), nil
6859 case COLOMessageVmstateSize:
6860 return []byte(`"vmstate-size"`), nil
6861 case COLOMessageVmstateReceived:
6862 return []byte(`"vmstate-received"`), nil
6863 case COLOMessageVmstateLoaded:
6864 return []byte(`"vmstate-loaded"`), nil
6865 default:
6866 fmt.Println("Failed to decode COLOMessage", s)
6867 }
6868 return nil, errors.New("Failed")
6869 }
6870
6871 func (s *COLOMessage) UnmarshalJSON(data []byte) error {
6872 var name string
6873
6874 if err := json.Unmarshal(data, &name); err != nil {
6875 return err
6876 }
6877
6878 switch name {
6879 case "checkpoint-ready":
6880 (*s) = COLOMessageCheckpointReady
6881 case "checkpoint-request":
6882 (*s) = COLOMessageCheckpointRequest
6883 case "checkpoint-reply":
6884 (*s) = COLOMessageCheckpointReply
6885 case "vmstate-send":
6886 (*s) = COLOMessageVmstateSend
6887 case "vmstate-size":
6888 (*s) = COLOMessageVmstateSize
6889 case "vmstate-received":
6890 (*s) = COLOMessageVmstateReceived
6891 case "vmstate-loaded":
6892 (*s) = COLOMessageVmstateLoaded
6893 default:
6894 fmt.Println("Failed to decode COLOMessage", *s)
6895 }
6896 return nil
6897 }
6898
6899
6900
6901
6902 type COLOMode int32
6903
6904 const (
6905 COLOModeNone COLOMode = iota
6906 COLOModePrimary
6907 COLOModeSecondary
6908 )
6909
6910 func (s COLOMode) MarshalJSON() ([]byte, error) {
6911 switch s {
6912 case COLOModeNone:
6913 return []byte(`"none"`), nil
6914 case COLOModePrimary:
6915 return []byte(`"primary"`), nil
6916 case COLOModeSecondary:
6917 return []byte(`"secondary"`), nil
6918 default:
6919 fmt.Println("Failed to decode COLOMode", s)
6920 }
6921 return nil, errors.New("Failed")
6922 }
6923
6924 func (s *COLOMode) UnmarshalJSON(data []byte) error {
6925 var name string
6926
6927 if err := json.Unmarshal(data, &name); err != nil {
6928 return err
6929 }
6930
6931 switch name {
6932 case "none":
6933 (*s) = COLOModeNone
6934 case "primary":
6935 (*s) = COLOModePrimary
6936 case "secondary":
6937 (*s) = COLOModeSecondary
6938 default:
6939 fmt.Println("Failed to decode COLOMode", *s)
6940 }
6941 return nil
6942 }
6943
6944
6945
6946
6947 type FailoverStatus int32
6948
6949 const (
6950 FailoverStatusNone FailoverStatus = iota
6951 FailoverStatusRequire
6952 FailoverStatusActive
6953 FailoverStatusCompleted
6954 FailoverStatusRelaunch
6955 )
6956
6957 func (s FailoverStatus) MarshalJSON() ([]byte, error) {
6958 switch s {
6959 case FailoverStatusNone:
6960 return []byte(`"none"`), nil
6961 case FailoverStatusRequire:
6962 return []byte(`"require"`), nil
6963 case FailoverStatusActive:
6964 return []byte(`"active"`), nil
6965 case FailoverStatusCompleted:
6966 return []byte(`"completed"`), nil
6967 case FailoverStatusRelaunch:
6968 return []byte(`"relaunch"`), nil
6969 default:
6970 fmt.Println("Failed to decode FailoverStatus", s)
6971 }
6972 return nil, errors.New("Failed")
6973 }
6974
6975 func (s *FailoverStatus) UnmarshalJSON(data []byte) error {
6976 var name string
6977
6978 if err := json.Unmarshal(data, &name); err != nil {
6979 return err
6980 }
6981
6982 switch name {
6983 case "none":
6984 (*s) = FailoverStatusNone
6985 case "require":
6986 (*s) = FailoverStatusRequire
6987 case "active":
6988 (*s) = FailoverStatusActive
6989 case "completed":
6990 (*s) = FailoverStatusCompleted
6991 case "relaunch":
6992 (*s) = FailoverStatusRelaunch
6993 default:
6994 fmt.Println("Failed to decode FailoverStatus", *s)
6995 }
6996 return nil
6997 }
6998
6999
7000
7001
7002 type COLOExitReason int32
7003
7004 const (
7005 COLOExitReasonNone COLOExitReason = iota
7006 COLOExitReasonRequest
7007 COLOExitReasonError
7008 COLOExitReasonProcessing
7009 )
7010
7011 func (s COLOExitReason) MarshalJSON() ([]byte, error) {
7012 switch s {
7013 case COLOExitReasonNone:
7014 return []byte(`"none"`), nil
7015 case COLOExitReasonRequest:
7016 return []byte(`"request"`), nil
7017 case COLOExitReasonError:
7018 return []byte(`"error"`), nil
7019 case COLOExitReasonProcessing:
7020 return []byte(`"processing"`), nil
7021 default:
7022 fmt.Println("Failed to decode COLOExitReason", s)
7023 }
7024 return nil, errors.New("Failed")
7025 }
7026
7027 func (s *COLOExitReason) UnmarshalJSON(data []byte) error {
7028 var name string
7029
7030 if err := json.Unmarshal(data, &name); err != nil {
7031 return err
7032 }
7033
7034 switch name {
7035 case "none":
7036 (*s) = COLOExitReasonNone
7037 case "request":
7038 (*s) = COLOExitReasonRequest
7039 case "error":
7040 (*s) = COLOExitReasonError
7041 case "processing":
7042 (*s) = COLOExitReasonProcessing
7043 default:
7044 fmt.Println("Failed to decode COLOExitReason", *s)
7045 }
7046 return nil
7047 }
7048
7049
7050
7051
7052 type DirtyRateStatus int32
7053
7054 const (
7055 DirtyRateStatusUnstarted DirtyRateStatus = iota
7056 DirtyRateStatusMeasuring
7057 DirtyRateStatusMeasured
7058 )
7059
7060 func (s DirtyRateStatus) MarshalJSON() ([]byte, error) {
7061 switch s {
7062 case DirtyRateStatusUnstarted:
7063 return []byte(`"unstarted"`), nil
7064 case DirtyRateStatusMeasuring:
7065 return []byte(`"measuring"`), nil
7066 case DirtyRateStatusMeasured:
7067 return []byte(`"measured"`), nil
7068 default:
7069 fmt.Println("Failed to decode DirtyRateStatus", s)
7070 }
7071 return nil, errors.New("Failed")
7072 }
7073
7074 func (s *DirtyRateStatus) UnmarshalJSON(data []byte) error {
7075 var name string
7076
7077 if err := json.Unmarshal(data, &name); err != nil {
7078 return err
7079 }
7080
7081 switch name {
7082 case "unstarted":
7083 (*s) = DirtyRateStatusUnstarted
7084 case "measuring":
7085 (*s) = DirtyRateStatusMeasuring
7086 case "measured":
7087 (*s) = DirtyRateStatusMeasured
7088 default:
7089 fmt.Println("Failed to decode DirtyRateStatus", *s)
7090 }
7091 return nil
7092 }
7093
7094
7095
7096
7097 type DirtyRateMeasureMode int32
7098
7099 const (
7100 DirtyRateMeasureModePageSampling DirtyRateMeasureMode = iota
7101 DirtyRateMeasureModeDirtyRing
7102 DirtyRateMeasureModeDirtyBitmap
7103 )
7104
7105 func (s DirtyRateMeasureMode) MarshalJSON() ([]byte, error) {
7106 switch s {
7107 case DirtyRateMeasureModePageSampling:
7108 return []byte(`"page-sampling"`), nil
7109 case DirtyRateMeasureModeDirtyRing:
7110 return []byte(`"dirty-ring"`), nil
7111 case DirtyRateMeasureModeDirtyBitmap:
7112 return []byte(`"dirty-bitmap"`), nil
7113 default:
7114 fmt.Println("Failed to decode DirtyRateMeasureMode", s)
7115 }
7116 return nil, errors.New("Failed")
7117 }
7118
7119 func (s *DirtyRateMeasureMode) UnmarshalJSON(data []byte) error {
7120 var name string
7121
7122 if err := json.Unmarshal(data, &name); err != nil {
7123 return err
7124 }
7125
7126 switch name {
7127 case "page-sampling":
7128 (*s) = DirtyRateMeasureModePageSampling
7129 case "dirty-ring":
7130 (*s) = DirtyRateMeasureModeDirtyRing
7131 case "dirty-bitmap":
7132 (*s) = DirtyRateMeasureModeDirtyBitmap
7133 default:
7134 fmt.Println("Failed to decode DirtyRateMeasureMode", *s)
7135 }
7136 return nil
7137 }
7138
7139
7140
7141
7142 type ActionCompletionMode int32
7143
7144 const (
7145 ActionCompletionModeIndividual ActionCompletionMode = iota
7146 ActionCompletionModeGrouped
7147 )
7148
7149 func (s ActionCompletionMode) MarshalJSON() ([]byte, error) {
7150 switch s {
7151 case ActionCompletionModeIndividual:
7152 return []byte(`"individual"`), nil
7153 case ActionCompletionModeGrouped:
7154 return []byte(`"grouped"`), nil
7155 default:
7156 fmt.Println("Failed to decode ActionCompletionMode", s)
7157 }
7158 return nil, errors.New("Failed")
7159 }
7160
7161 func (s *ActionCompletionMode) UnmarshalJSON(data []byte) error {
7162 var name string
7163
7164 if err := json.Unmarshal(data, &name); err != nil {
7165 return err
7166 }
7167
7168 switch name {
7169 case "individual":
7170 (*s) = ActionCompletionModeIndividual
7171 case "grouped":
7172 (*s) = ActionCompletionModeGrouped
7173 default:
7174 fmt.Println("Failed to decode ActionCompletionMode", *s)
7175 }
7176 return nil
7177 }
7178
7179
7180 type TransactionActionKind int32
7181
7182 const (
7183 TransactionActionKindAbort TransactionActionKind = iota
7184 TransactionActionKindBlockDirtyBitmapAdd
7185 TransactionActionKindBlockDirtyBitmapRemove
7186 TransactionActionKindBlockDirtyBitmapClear
7187 TransactionActionKindBlockDirtyBitmapEnable
7188 TransactionActionKindBlockDirtyBitmapDisable
7189 TransactionActionKindBlockDirtyBitmapMerge
7190 TransactionActionKindBlockdevBackup
7191 TransactionActionKindBlockdevSnapshot
7192 TransactionActionKindBlockdevSnapshotInternalSync
7193 TransactionActionKindBlockdevSnapshotSync
7194 TransactionActionKindDriveBackup
7195 )
7196
7197 func (s TransactionActionKind) MarshalJSON() ([]byte, error) {
7198 switch s {
7199 case TransactionActionKindAbort:
7200 return []byte(`"abort"`), nil
7201 case TransactionActionKindBlockDirtyBitmapAdd:
7202 return []byte(`"block-dirty-bitmap-add"`), nil
7203 case TransactionActionKindBlockDirtyBitmapRemove:
7204 return []byte(`"block-dirty-bitmap-remove"`), nil
7205 case TransactionActionKindBlockDirtyBitmapClear:
7206 return []byte(`"block-dirty-bitmap-clear"`), nil
7207 case TransactionActionKindBlockDirtyBitmapEnable:
7208 return []byte(`"block-dirty-bitmap-enable"`), nil
7209 case TransactionActionKindBlockDirtyBitmapDisable:
7210 return []byte(`"block-dirty-bitmap-disable"`), nil
7211 case TransactionActionKindBlockDirtyBitmapMerge:
7212 return []byte(`"block-dirty-bitmap-merge"`), nil
7213 case TransactionActionKindBlockdevBackup:
7214 return []byte(`"blockdev-backup"`), nil
7215 case TransactionActionKindBlockdevSnapshot:
7216 return []byte(`"blockdev-snapshot"`), nil
7217 case TransactionActionKindBlockdevSnapshotInternalSync:
7218 return []byte(`"blockdev-snapshot-internal-sync"`), nil
7219 case TransactionActionKindBlockdevSnapshotSync:
7220 return []byte(`"blockdev-snapshot-sync"`), nil
7221 case TransactionActionKindDriveBackup:
7222 return []byte(`"drive-backup"`), nil
7223 default:
7224 fmt.Println("Failed to decode TransactionActionKind", s)
7225 }
7226 return nil, errors.New("Failed")
7227 }
7228
7229 func (s *TransactionActionKind) UnmarshalJSON(data []byte) error {
7230 var name string
7231
7232 if err := json.Unmarshal(data, &name); err != nil {
7233 return err
7234 }
7235
7236 switch name {
7237 case "abort":
7238 (*s) = TransactionActionKindAbort
7239 case "block-dirty-bitmap-add":
7240 (*s) = TransactionActionKindBlockDirtyBitmapAdd
7241 case "block-dirty-bitmap-remove":
7242 (*s) = TransactionActionKindBlockDirtyBitmapRemove
7243 case "block-dirty-bitmap-clear":
7244 (*s) = TransactionActionKindBlockDirtyBitmapClear
7245 case "block-dirty-bitmap-enable":
7246 (*s) = TransactionActionKindBlockDirtyBitmapEnable
7247 case "block-dirty-bitmap-disable":
7248 (*s) = TransactionActionKindBlockDirtyBitmapDisable
7249 case "block-dirty-bitmap-merge":
7250 (*s) = TransactionActionKindBlockDirtyBitmapMerge
7251 case "blockdev-backup":
7252 (*s) = TransactionActionKindBlockdevBackup
7253 case "blockdev-snapshot":
7254 (*s) = TransactionActionKindBlockdevSnapshot
7255 case "blockdev-snapshot-internal-sync":
7256 (*s) = TransactionActionKindBlockdevSnapshotInternalSync
7257 case "blockdev-snapshot-sync":
7258 (*s) = TransactionActionKindBlockdevSnapshotSync
7259 case "drive-backup":
7260 (*s) = TransactionActionKindDriveBackup
7261 default:
7262 fmt.Println("Failed to decode TransactionActionKind", *s)
7263 }
7264 return nil
7265 }
7266
7267
7268
7269
7270 type TraceEventState int32
7271
7272 const (
7273 TraceEventStateUnavailable TraceEventState = iota
7274 TraceEventStateDisabled
7275 TraceEventStateEnabled
7276 )
7277
7278 func (s TraceEventState) MarshalJSON() ([]byte, error) {
7279 switch s {
7280 case TraceEventStateUnavailable:
7281 return []byte(`"unavailable"`), nil
7282 case TraceEventStateDisabled:
7283 return []byte(`"disabled"`), nil
7284 case TraceEventStateEnabled:
7285 return []byte(`"enabled"`), nil
7286 default:
7287 fmt.Println("Failed to decode TraceEventState", s)
7288 }
7289 return nil, errors.New("Failed")
7290 }
7291
7292 func (s *TraceEventState) UnmarshalJSON(data []byte) error {
7293 var name string
7294
7295 if err := json.Unmarshal(data, &name); err != nil {
7296 return err
7297 }
7298
7299 switch name {
7300 case "unavailable":
7301 (*s) = TraceEventStateUnavailable
7302 case "disabled":
7303 (*s) = TraceEventStateDisabled
7304 case "enabled":
7305 (*s) = TraceEventStateEnabled
7306 default:
7307 fmt.Println("Failed to decode TraceEventState", *s)
7308 }
7309 return nil
7310 }
7311
7312
7313
7314
7315 type CompatPolicyInput int32
7316
7317 const (
7318 CompatPolicyInputAccept CompatPolicyInput = iota
7319 CompatPolicyInputReject
7320 CompatPolicyInputCrash
7321 )
7322
7323 func (s CompatPolicyInput) MarshalJSON() ([]byte, error) {
7324 switch s {
7325 case CompatPolicyInputAccept:
7326 return []byte(`"accept"`), nil
7327 case CompatPolicyInputReject:
7328 return []byte(`"reject"`), nil
7329 case CompatPolicyInputCrash:
7330 return []byte(`"crash"`), nil
7331 default:
7332 fmt.Println("Failed to decode CompatPolicyInput", s)
7333 }
7334 return nil, errors.New("Failed")
7335 }
7336
7337 func (s *CompatPolicyInput) UnmarshalJSON(data []byte) error {
7338 var name string
7339
7340 if err := json.Unmarshal(data, &name); err != nil {
7341 return err
7342 }
7343
7344 switch name {
7345 case "accept":
7346 (*s) = CompatPolicyInputAccept
7347 case "reject":
7348 (*s) = CompatPolicyInputReject
7349 case "crash":
7350 (*s) = CompatPolicyInputCrash
7351 default:
7352 fmt.Println("Failed to decode CompatPolicyInput", *s)
7353 }
7354 return nil
7355 }
7356
7357
7358
7359
7360 type CompatPolicyOutput int32
7361
7362 const (
7363 CompatPolicyOutputAccept CompatPolicyOutput = iota
7364 CompatPolicyOutputHide
7365 )
7366
7367 func (s CompatPolicyOutput) MarshalJSON() ([]byte, error) {
7368 switch s {
7369 case CompatPolicyOutputAccept:
7370 return []byte(`"accept"`), nil
7371 case CompatPolicyOutputHide:
7372 return []byte(`"hide"`), nil
7373 default:
7374 fmt.Println("Failed to decode CompatPolicyOutput", s)
7375 }
7376 return nil, errors.New("Failed")
7377 }
7378
7379 func (s *CompatPolicyOutput) UnmarshalJSON(data []byte) error {
7380 var name string
7381
7382 if err := json.Unmarshal(data, &name); err != nil {
7383 return err
7384 }
7385
7386 switch name {
7387 case "accept":
7388 (*s) = CompatPolicyOutputAccept
7389 case "hide":
7390 (*s) = CompatPolicyOutputHide
7391 default:
7392 fmt.Println("Failed to decode CompatPolicyOutput", *s)
7393 }
7394 return nil
7395 }
7396
7397
7398
7399
7400
7401 type QMPCapability int32
7402
7403 const (
7404 QMPCapabilityOob QMPCapability = iota
7405 )
7406
7407 func (s QMPCapability) MarshalJSON() ([]byte, error) {
7408 switch s {
7409 case QMPCapabilityOob:
7410 return []byte(`"oob"`), nil
7411 default:
7412 fmt.Println("Failed to decode QMPCapability", s)
7413 }
7414 return nil, errors.New("Failed")
7415 }
7416
7417 func (s *QMPCapability) UnmarshalJSON(data []byte) error {
7418 var name string
7419
7420 if err := json.Unmarshal(data, &name); err != nil {
7421 return err
7422 }
7423
7424 switch name {
7425 case "oob":
7426 (*s) = QMPCapabilityOob
7427 default:
7428 fmt.Println("Failed to decode QMPCapability", *s)
7429 }
7430 return nil
7431 }
7432
7433
7434
7435
7436 type MonitorMode int32
7437
7438 const (
7439 MonitorModeReadline MonitorMode = iota
7440 MonitorModeControl
7441 )
7442
7443 func (s MonitorMode) MarshalJSON() ([]byte, error) {
7444 switch s {
7445 case MonitorModeReadline:
7446 return []byte(`"readline"`), nil
7447 case MonitorModeControl:
7448 return []byte(`"control"`), nil
7449 default:
7450 fmt.Println("Failed to decode MonitorMode", s)
7451 }
7452 return nil, errors.New("Failed")
7453 }
7454
7455 func (s *MonitorMode) UnmarshalJSON(data []byte) error {
7456 var name string
7457
7458 if err := json.Unmarshal(data, &name); err != nil {
7459 return err
7460 }
7461
7462 switch name {
7463 case "readline":
7464 (*s) = MonitorModeReadline
7465 case "control":
7466 (*s) = MonitorModeControl
7467 default:
7468 fmt.Println("Failed to decode MonitorMode", *s)
7469 }
7470 return nil
7471 }
7472
7473
7474
7475
7476
7477 type SchemaMetaType int32
7478
7479 const (
7480 SchemaMetaTypeBuiltin SchemaMetaType = iota
7481 SchemaMetaTypeEnum
7482 SchemaMetaTypeArray
7483 SchemaMetaTypeObject
7484 SchemaMetaTypeAlternate
7485 SchemaMetaTypeCommand
7486 SchemaMetaTypeEvent
7487 )
7488
7489 func (s SchemaMetaType) MarshalJSON() ([]byte, error) {
7490 switch s {
7491 case SchemaMetaTypeBuiltin:
7492 return []byte(`"builtin"`), nil
7493 case SchemaMetaTypeEnum:
7494 return []byte(`"enum"`), nil
7495 case SchemaMetaTypeArray:
7496 return []byte(`"array"`), nil
7497 case SchemaMetaTypeObject:
7498 return []byte(`"object"`), nil
7499 case SchemaMetaTypeAlternate:
7500 return []byte(`"alternate"`), nil
7501 case SchemaMetaTypeCommand:
7502 return []byte(`"command"`), nil
7503 case SchemaMetaTypeEvent:
7504 return []byte(`"event"`), nil
7505 default:
7506 fmt.Println("Failed to decode SchemaMetaType", s)
7507 }
7508 return nil, errors.New("Failed")
7509 }
7510
7511 func (s *SchemaMetaType) UnmarshalJSON(data []byte) error {
7512 var name string
7513
7514 if err := json.Unmarshal(data, &name); err != nil {
7515 return err
7516 }
7517
7518 switch name {
7519 case "builtin":
7520 (*s) = SchemaMetaTypeBuiltin
7521 case "enum":
7522 (*s) = SchemaMetaTypeEnum
7523 case "array":
7524 (*s) = SchemaMetaTypeArray
7525 case "object":
7526 (*s) = SchemaMetaTypeObject
7527 case "alternate":
7528 (*s) = SchemaMetaTypeAlternate
7529 case "command":
7530 (*s) = SchemaMetaTypeCommand
7531 case "event":
7532 (*s) = SchemaMetaTypeEvent
7533 default:
7534 fmt.Println("Failed to decode SchemaMetaType", *s)
7535 }
7536 return nil
7537 }
7538
7539
7540
7541
7542
7543
7544 type JSONType int32
7545
7546 const (
7547 JSONTypeString JSONType = iota
7548 JSONTypeNumber
7549 JSONTypeInt
7550 JSONTypeBoolean
7551 JSONTypeNull
7552 JSONTypeObject
7553 JSONTypeArray
7554 JSONTypeValue
7555 )
7556
7557 func (s JSONType) MarshalJSON() ([]byte, error) {
7558 switch s {
7559 case JSONTypeString:
7560 return []byte(`"string"`), nil
7561 case JSONTypeNumber:
7562 return []byte(`"number"`), nil
7563 case JSONTypeInt:
7564 return []byte(`"int"`), nil
7565 case JSONTypeBoolean:
7566 return []byte(`"boolean"`), nil
7567 case JSONTypeNull:
7568 return []byte(`"null"`), nil
7569 case JSONTypeObject:
7570 return []byte(`"object"`), nil
7571 case JSONTypeArray:
7572 return []byte(`"array"`), nil
7573 case JSONTypeValue:
7574 return []byte(`"value"`), nil
7575 default:
7576 fmt.Println("Failed to decode JSONType", s)
7577 }
7578 return nil, errors.New("Failed")
7579 }
7580
7581 func (s *JSONType) UnmarshalJSON(data []byte) error {
7582 var name string
7583
7584 if err := json.Unmarshal(data, &name); err != nil {
7585 return err
7586 }
7587
7588 switch name {
7589 case "string":
7590 (*s) = JSONTypeString
7591 case "number":
7592 (*s) = JSONTypeNumber
7593 case "int":
7594 (*s) = JSONTypeInt
7595 case "boolean":
7596 (*s) = JSONTypeBoolean
7597 case "null":
7598 (*s) = JSONTypeNull
7599 case "object":
7600 (*s) = JSONTypeObject
7601 case "array":
7602 (*s) = JSONTypeArray
7603 case "value":
7604 (*s) = JSONTypeValue
7605 default:
7606 fmt.Println("Failed to decode JSONType", *s)
7607 }
7608 return nil
7609 }
7610
7611
7612
7613
7614 type NetfilterInsert int32
7615
7616 const (
7617 NetfilterInsertBefore NetfilterInsert = iota
7618 NetfilterInsertBehind
7619 )
7620
7621 func (s NetfilterInsert) MarshalJSON() ([]byte, error) {
7622 switch s {
7623 case NetfilterInsertBefore:
7624 return []byte(`"before"`), nil
7625 case NetfilterInsertBehind:
7626 return []byte(`"behind"`), nil
7627 default:
7628 fmt.Println("Failed to decode NetfilterInsert", s)
7629 }
7630 return nil, errors.New("Failed")
7631 }
7632
7633 func (s *NetfilterInsert) UnmarshalJSON(data []byte) error {
7634 var name string
7635
7636 if err := json.Unmarshal(data, &name); err != nil {
7637 return err
7638 }
7639
7640 switch name {
7641 case "before":
7642 (*s) = NetfilterInsertBefore
7643 case "behind":
7644 (*s) = NetfilterInsertBehind
7645 default:
7646 fmt.Println("Failed to decode NetfilterInsert", *s)
7647 }
7648 return nil
7649 }
7650
7651
7652 type ObjectType int32
7653
7654 const (
7655 ObjectTypeAuthzList ObjectType = iota
7656 ObjectTypeAuthzListfile
7657 ObjectTypeAuthzPam
7658 ObjectTypeAuthzSimple
7659 ObjectTypeCanBus
7660 ObjectTypeCanHostSocketcan
7661 ObjectTypeColoCompare
7662 ObjectTypeCryptodevBackend
7663 ObjectTypeCryptodevBackendBuiltin
7664 ObjectTypeCryptodevVhostUser
7665 ObjectTypeDbusVmstate
7666 ObjectTypeFilterBuffer
7667 ObjectTypeFilterDump
7668 ObjectTypeFilterMirror
7669 ObjectTypeFilterRedirector
7670 ObjectTypeFilterReplay
7671 ObjectTypeFilterRewriter
7672 ObjectTypeInputBarrier
7673 ObjectTypeInputLinux
7674 ObjectTypeIothread
7675 ObjectTypeMemoryBackendEpc
7676 ObjectTypeMemoryBackendFile
7677 ObjectTypeMemoryBackendMemfd
7678 ObjectTypeMemoryBackendRam
7679 ObjectTypePefGuest
7680 ObjectTypePrManagerHelper
7681 ObjectTypeQtest
7682 ObjectTypeRngBuiltin
7683 ObjectTypeRngEgd
7684 ObjectTypeRngRandom
7685 ObjectTypeSecret
7686 ObjectTypeSecret_Keyring
7687 ObjectTypeSevGuest
7688 ObjectTypeS390PvGuest
7689 ObjectTypeThrottleGroup
7690 ObjectTypeTlsCredsAnon
7691 ObjectTypeTlsCredsPsk
7692 ObjectTypeTlsCredsX509
7693 ObjectTypeTlsCipherSuites
7694 ObjectTypeXRemoteObject
7695 )
7696
7697 func (s ObjectType) MarshalJSON() ([]byte, error) {
7698 switch s {
7699 case ObjectTypeAuthzList:
7700 return []byte(`"authz-list"`), nil
7701 case ObjectTypeAuthzListfile:
7702 return []byte(`"authz-listfile"`), nil
7703 case ObjectTypeAuthzPam:
7704 return []byte(`"authz-pam"`), nil
7705 case ObjectTypeAuthzSimple:
7706 return []byte(`"authz-simple"`), nil
7707 case ObjectTypeCanBus:
7708 return []byte(`"can-bus"`), nil
7709 case ObjectTypeCanHostSocketcan:
7710 return []byte(`"can-host-socketcan"`), nil
7711 case ObjectTypeColoCompare:
7712 return []byte(`"colo-compare"`), nil
7713 case ObjectTypeCryptodevBackend:
7714 return []byte(`"cryptodev-backend"`), nil
7715 case ObjectTypeCryptodevBackendBuiltin:
7716 return []byte(`"cryptodev-backend-builtin"`), nil
7717 case ObjectTypeCryptodevVhostUser:
7718 return []byte(`"cryptodev-vhost-user"`), nil
7719 case ObjectTypeDbusVmstate:
7720 return []byte(`"dbus-vmstate"`), nil
7721 case ObjectTypeFilterBuffer:
7722 return []byte(`"filter-buffer"`), nil
7723 case ObjectTypeFilterDump:
7724 return []byte(`"filter-dump"`), nil
7725 case ObjectTypeFilterMirror:
7726 return []byte(`"filter-mirror"`), nil
7727 case ObjectTypeFilterRedirector:
7728 return []byte(`"filter-redirector"`), nil
7729 case ObjectTypeFilterReplay:
7730 return []byte(`"filter-replay"`), nil
7731 case ObjectTypeFilterRewriter:
7732 return []byte(`"filter-rewriter"`), nil
7733 case ObjectTypeInputBarrier:
7734 return []byte(`"input-barrier"`), nil
7735 case ObjectTypeInputLinux:
7736 return []byte(`"input-linux"`), nil
7737 case ObjectTypeIothread:
7738 return []byte(`"iothread"`), nil
7739 case ObjectTypeMemoryBackendEpc:
7740 return []byte(`"memory-backend-epc"`), nil
7741 case ObjectTypeMemoryBackendFile:
7742 return []byte(`"memory-backend-file"`), nil
7743 case ObjectTypeMemoryBackendMemfd:
7744 return []byte(`"memory-backend-memfd"`), nil
7745 case ObjectTypeMemoryBackendRam:
7746 return []byte(`"memory-backend-ram"`), nil
7747 case ObjectTypePefGuest:
7748 return []byte(`"pef-guest"`), nil
7749 case ObjectTypePrManagerHelper:
7750 return []byte(`"pr-manager-helper"`), nil
7751 case ObjectTypeQtest:
7752 return []byte(`"qtest"`), nil
7753 case ObjectTypeRngBuiltin:
7754 return []byte(`"rng-builtin"`), nil
7755 case ObjectTypeRngEgd:
7756 return []byte(`"rng-egd"`), nil
7757 case ObjectTypeRngRandom:
7758 return []byte(`"rng-random"`), nil
7759 case ObjectTypeSecret:
7760 return []byte(`"secret"`), nil
7761 case ObjectTypeSecret_Keyring:
7762 return []byte(`"secret_keyring"`), nil
7763 case ObjectTypeSevGuest:
7764 return []byte(`"sev-guest"`), nil
7765 case ObjectTypeS390PvGuest:
7766 return []byte(`"s390-pv-guest"`), nil
7767 case ObjectTypeThrottleGroup:
7768 return []byte(`"throttle-group"`), nil
7769 case ObjectTypeTlsCredsAnon:
7770 return []byte(`"tls-creds-anon"`), nil
7771 case ObjectTypeTlsCredsPsk:
7772 return []byte(`"tls-creds-psk"`), nil
7773 case ObjectTypeTlsCredsX509:
7774 return []byte(`"tls-creds-x509"`), nil
7775 case ObjectTypeTlsCipherSuites:
7776 return []byte(`"tls-cipher-suites"`), nil
7777 case ObjectTypeXRemoteObject:
7778 return []byte(`"x-remote-object"`), nil
7779 default:
7780 fmt.Println("Failed to decode ObjectType", s)
7781 }
7782 return nil, errors.New("Failed")
7783 }
7784
7785 func (s *ObjectType) UnmarshalJSON(data []byte) error {
7786 var name string
7787
7788 if err := json.Unmarshal(data, &name); err != nil {
7789 return err
7790 }
7791
7792 switch name {
7793 case "authz-list":
7794 (*s) = ObjectTypeAuthzList
7795 case "authz-listfile":
7796 (*s) = ObjectTypeAuthzListfile
7797 case "authz-pam":
7798 (*s) = ObjectTypeAuthzPam
7799 case "authz-simple":
7800 (*s) = ObjectTypeAuthzSimple
7801 case "can-bus":
7802 (*s) = ObjectTypeCanBus
7803 case "can-host-socketcan":
7804 (*s) = ObjectTypeCanHostSocketcan
7805 case "colo-compare":
7806 (*s) = ObjectTypeColoCompare
7807 case "cryptodev-backend":
7808 (*s) = ObjectTypeCryptodevBackend
7809 case "cryptodev-backend-builtin":
7810 (*s) = ObjectTypeCryptodevBackendBuiltin
7811 case "cryptodev-vhost-user":
7812 (*s) = ObjectTypeCryptodevVhostUser
7813 case "dbus-vmstate":
7814 (*s) = ObjectTypeDbusVmstate
7815 case "filter-buffer":
7816 (*s) = ObjectTypeFilterBuffer
7817 case "filter-dump":
7818 (*s) = ObjectTypeFilterDump
7819 case "filter-mirror":
7820 (*s) = ObjectTypeFilterMirror
7821 case "filter-redirector":
7822 (*s) = ObjectTypeFilterRedirector
7823 case "filter-replay":
7824 (*s) = ObjectTypeFilterReplay
7825 case "filter-rewriter":
7826 (*s) = ObjectTypeFilterRewriter
7827 case "input-barrier":
7828 (*s) = ObjectTypeInputBarrier
7829 case "input-linux":
7830 (*s) = ObjectTypeInputLinux
7831 case "iothread":
7832 (*s) = ObjectTypeIothread
7833 case "memory-backend-epc":
7834 (*s) = ObjectTypeMemoryBackendEpc
7835 case "memory-backend-file":
7836 (*s) = ObjectTypeMemoryBackendFile
7837 case "memory-backend-memfd":
7838 (*s) = ObjectTypeMemoryBackendMemfd
7839 case "memory-backend-ram":
7840 (*s) = ObjectTypeMemoryBackendRam
7841 case "pef-guest":
7842 (*s) = ObjectTypePefGuest
7843 case "pr-manager-helper":
7844 (*s) = ObjectTypePrManagerHelper
7845 case "qtest":
7846 (*s) = ObjectTypeQtest
7847 case "rng-builtin":
7848 (*s) = ObjectTypeRngBuiltin
7849 case "rng-egd":
7850 (*s) = ObjectTypeRngEgd
7851 case "rng-random":
7852 (*s) = ObjectTypeRngRandom
7853 case "secret":
7854 (*s) = ObjectTypeSecret
7855 case "secret_keyring":
7856 (*s) = ObjectTypeSecret_Keyring
7857 case "sev-guest":
7858 (*s) = ObjectTypeSevGuest
7859 case "s390-pv-guest":
7860 (*s) = ObjectTypeS390PvGuest
7861 case "throttle-group":
7862 (*s) = ObjectTypeThrottleGroup
7863 case "tls-creds-anon":
7864 (*s) = ObjectTypeTlsCredsAnon
7865 case "tls-creds-psk":
7866 (*s) = ObjectTypeTlsCredsPsk
7867 case "tls-creds-x509":
7868 (*s) = ObjectTypeTlsCredsX509
7869 case "tls-cipher-suites":
7870 (*s) = ObjectTypeTlsCipherSuites
7871 case "x-remote-object":
7872 (*s) = ObjectTypeXRemoteObject
7873 default:
7874 fmt.Println("Failed to decode ObjectType", *s)
7875 }
7876 return nil
7877 }
7878
7879
7880
7881
7882
7883
7884
7885
7886
7887
7888
7889
7890 type SysEmuTarget int32
7891
7892 const (
7893 SysEmuTargetAarch64 SysEmuTarget = iota
7894 SysEmuTargetAlpha
7895 SysEmuTargetArm
7896 SysEmuTargetAvr
7897 SysEmuTargetCris
7898 SysEmuTargetHppa
7899 SysEmuTargetI386
7900 SysEmuTargetM68K
7901 SysEmuTargetMicroblaze
7902 SysEmuTargetMicroblazeel
7903 SysEmuTargetMips
7904 SysEmuTargetMips64
7905 SysEmuTargetMips64El
7906 SysEmuTargetMipsel
7907 SysEmuTargetNios2
7908 SysEmuTargetOr1K
7909 SysEmuTargetPpc
7910 SysEmuTargetPpc64
7911 SysEmuTargetRiscv32
7912 SysEmuTargetRiscv64
7913 SysEmuTargetRx
7914 SysEmuTargetS390X
7915 SysEmuTargetSh4
7916 SysEmuTargetSh4Eb
7917 SysEmuTargetSparc
7918 SysEmuTargetSparc64
7919 SysEmuTargetTricore
7920 SysEmuTargetX86_64
7921 SysEmuTargetXtensa
7922 SysEmuTargetXtensaeb
7923 )
7924
7925 func (s SysEmuTarget) MarshalJSON() ([]byte, error) {
7926 switch s {
7927 case SysEmuTargetAarch64:
7928 return []byte(`"aarch64"`), nil
7929 case SysEmuTargetAlpha:
7930 return []byte(`"alpha"`), nil
7931 case SysEmuTargetArm:
7932 return []byte(`"arm"`), nil
7933 case SysEmuTargetAvr:
7934 return []byte(`"avr"`), nil
7935 case SysEmuTargetCris:
7936 return []byte(`"cris"`), nil
7937 case SysEmuTargetHppa:
7938 return []byte(`"hppa"`), nil
7939 case SysEmuTargetI386:
7940 return []byte(`"i386"`), nil
7941 case SysEmuTargetM68K:
7942 return []byte(`"m68k"`), nil
7943 case SysEmuTargetMicroblaze:
7944 return []byte(`"microblaze"`), nil
7945 case SysEmuTargetMicroblazeel:
7946 return []byte(`"microblazeel"`), nil
7947 case SysEmuTargetMips:
7948 return []byte(`"mips"`), nil
7949 case SysEmuTargetMips64:
7950 return []byte(`"mips64"`), nil
7951 case SysEmuTargetMips64El:
7952 return []byte(`"mips64el"`), nil
7953 case SysEmuTargetMipsel:
7954 return []byte(`"mipsel"`), nil
7955 case SysEmuTargetNios2:
7956 return []byte(`"nios2"`), nil
7957 case SysEmuTargetOr1K:
7958 return []byte(`"or1k"`), nil
7959 case SysEmuTargetPpc:
7960 return []byte(`"ppc"`), nil
7961 case SysEmuTargetPpc64:
7962 return []byte(`"ppc64"`), nil
7963 case SysEmuTargetRiscv32:
7964 return []byte(`"riscv32"`), nil
7965 case SysEmuTargetRiscv64:
7966 return []byte(`"riscv64"`), nil
7967 case SysEmuTargetRx:
7968 return []byte(`"rx"`), nil
7969 case SysEmuTargetS390X:
7970 return []byte(`"s390x"`), nil
7971 case SysEmuTargetSh4:
7972 return []byte(`"sh4"`), nil
7973 case SysEmuTargetSh4Eb:
7974 return []byte(`"sh4eb"`), nil
7975 case SysEmuTargetSparc:
7976 return []byte(`"sparc"`), nil
7977 case SysEmuTargetSparc64:
7978 return []byte(`"sparc64"`), nil
7979 case SysEmuTargetTricore:
7980 return []byte(`"tricore"`), nil
7981 case SysEmuTargetX86_64:
7982 return []byte(`"x86_64"`), nil
7983 case SysEmuTargetXtensa:
7984 return []byte(`"xtensa"`), nil
7985 case SysEmuTargetXtensaeb:
7986 return []byte(`"xtensaeb"`), nil
7987 default:
7988 fmt.Println("Failed to decode SysEmuTarget", s)
7989 }
7990 return nil, errors.New("Failed")
7991 }
7992
7993 func (s *SysEmuTarget) UnmarshalJSON(data []byte) error {
7994 var name string
7995
7996 if err := json.Unmarshal(data, &name); err != nil {
7997 return err
7998 }
7999
8000 switch name {
8001 case "aarch64":
8002 (*s) = SysEmuTargetAarch64
8003 case "alpha":
8004 (*s) = SysEmuTargetAlpha
8005 case "arm":
8006 (*s) = SysEmuTargetArm
8007 case "avr":
8008 (*s) = SysEmuTargetAvr
8009 case "cris":
8010 (*s) = SysEmuTargetCris
8011 case "hppa":
8012 (*s) = SysEmuTargetHppa
8013 case "i386":
8014 (*s) = SysEmuTargetI386
8015 case "m68k":
8016 (*s) = SysEmuTargetM68K
8017 case "microblaze":
8018 (*s) = SysEmuTargetMicroblaze
8019 case "microblazeel":
8020 (*s) = SysEmuTargetMicroblazeel
8021 case "mips":
8022 (*s) = SysEmuTargetMips
8023 case "mips64":
8024 (*s) = SysEmuTargetMips64
8025 case "mips64el":
8026 (*s) = SysEmuTargetMips64El
8027 case "mipsel":
8028 (*s) = SysEmuTargetMipsel
8029 case "nios2":
8030 (*s) = SysEmuTargetNios2
8031 case "or1k":
8032 (*s) = SysEmuTargetOr1K
8033 case "ppc":
8034 (*s) = SysEmuTargetPpc
8035 case "ppc64":
8036 (*s) = SysEmuTargetPpc64
8037 case "riscv32":
8038 (*s) = SysEmuTargetRiscv32
8039 case "riscv64":
8040 (*s) = SysEmuTargetRiscv64
8041 case "rx":
8042 (*s) = SysEmuTargetRx
8043 case "s390x":
8044 (*s) = SysEmuTargetS390X
8045 case "sh4":
8046 (*s) = SysEmuTargetSh4
8047 case "sh4eb":
8048 (*s) = SysEmuTargetSh4Eb
8049 case "sparc":
8050 (*s) = SysEmuTargetSparc
8051 case "sparc64":
8052 (*s) = SysEmuTargetSparc64
8053 case "tricore":
8054 (*s) = SysEmuTargetTricore
8055 case "x86_64":
8056 (*s) = SysEmuTargetX86_64
8057 case "xtensa":
8058 (*s) = SysEmuTargetXtensa
8059 case "xtensaeb":
8060 (*s) = SysEmuTargetXtensaeb
8061 default:
8062 fmt.Println("Failed to decode SysEmuTarget", *s)
8063 }
8064 return nil
8065 }
8066
8067
8068
8069
8070
8071 type CpuS390State int32
8072
8073 const (
8074 CpuS390StateUninitialized CpuS390State = iota
8075 CpuS390StateStopped
8076 CpuS390StateCheckStop
8077 CpuS390StateOperating
8078 CpuS390StateLoad
8079 )
8080
8081 func (s CpuS390State) MarshalJSON() ([]byte, error) {
8082 switch s {
8083 case CpuS390StateUninitialized:
8084 return []byte(`"uninitialized"`), nil
8085 case CpuS390StateStopped:
8086 return []byte(`"stopped"`), nil
8087 case CpuS390StateCheckStop:
8088 return []byte(`"check-stop"`), nil
8089 case CpuS390StateOperating:
8090 return []byte(`"operating"`), nil
8091 case CpuS390StateLoad:
8092 return []byte(`"load"`), nil
8093 default:
8094 fmt.Println("Failed to decode CpuS390State", s)
8095 }
8096 return nil, errors.New("Failed")
8097 }
8098
8099 func (s *CpuS390State) UnmarshalJSON(data []byte) error {
8100 var name string
8101
8102 if err := json.Unmarshal(data, &name); err != nil {
8103 return err
8104 }
8105
8106 switch name {
8107 case "uninitialized":
8108 (*s) = CpuS390StateUninitialized
8109 case "stopped":
8110 (*s) = CpuS390StateStopped
8111 case "check-stop":
8112 (*s) = CpuS390StateCheckStop
8113 case "operating":
8114 (*s) = CpuS390StateOperating
8115 case "load":
8116 (*s) = CpuS390StateLoad
8117 default:
8118 fmt.Println("Failed to decode CpuS390State", *s)
8119 }
8120 return nil
8121 }
8122
8123
8124
8125
8126
8127 type LostTickPolicy int32
8128
8129 const (
8130 LostTickPolicyDiscard LostTickPolicy = iota
8131 LostTickPolicyDelay
8132 LostTickPolicySlew
8133 )
8134
8135 func (s LostTickPolicy) MarshalJSON() ([]byte, error) {
8136 switch s {
8137 case LostTickPolicyDiscard:
8138 return []byte(`"discard"`), nil
8139 case LostTickPolicyDelay:
8140 return []byte(`"delay"`), nil
8141 case LostTickPolicySlew:
8142 return []byte(`"slew"`), nil
8143 default:
8144 fmt.Println("Failed to decode LostTickPolicy", s)
8145 }
8146 return nil, errors.New("Failed")
8147 }
8148
8149 func (s *LostTickPolicy) UnmarshalJSON(data []byte) error {
8150 var name string
8151
8152 if err := json.Unmarshal(data, &name); err != nil {
8153 return err
8154 }
8155
8156 switch name {
8157 case "discard":
8158 (*s) = LostTickPolicyDiscard
8159 case "delay":
8160 (*s) = LostTickPolicyDelay
8161 case "slew":
8162 (*s) = LostTickPolicySlew
8163 default:
8164 fmt.Println("Failed to decode LostTickPolicy", *s)
8165 }
8166 return nil
8167 }
8168
8169
8170 type NumaOptionsType int32
8171
8172 const (
8173 NumaOptionsTypeNode NumaOptionsType = iota
8174 NumaOptionsTypeDist
8175 NumaOptionsTypeCpu
8176 NumaOptionsTypeHmatLb
8177 NumaOptionsTypeHmatCache
8178 )
8179
8180 func (s NumaOptionsType) MarshalJSON() ([]byte, error) {
8181 switch s {
8182 case NumaOptionsTypeNode:
8183 return []byte(`"node"`), nil
8184 case NumaOptionsTypeDist:
8185 return []byte(`"dist"`), nil
8186 case NumaOptionsTypeCpu:
8187 return []byte(`"cpu"`), nil
8188 case NumaOptionsTypeHmatLb:
8189 return []byte(`"hmat-lb"`), nil
8190 case NumaOptionsTypeHmatCache:
8191 return []byte(`"hmat-cache"`), nil
8192 default:
8193 fmt.Println("Failed to decode NumaOptionsType", s)
8194 }
8195 return nil, errors.New("Failed")
8196 }
8197
8198 func (s *NumaOptionsType) UnmarshalJSON(data []byte) error {
8199 var name string
8200
8201 if err := json.Unmarshal(data, &name); err != nil {
8202 return err
8203 }
8204
8205 switch name {
8206 case "node":
8207 (*s) = NumaOptionsTypeNode
8208 case "dist":
8209 (*s) = NumaOptionsTypeDist
8210 case "cpu":
8211 (*s) = NumaOptionsTypeCpu
8212 case "hmat-lb":
8213 (*s) = NumaOptionsTypeHmatLb
8214 case "hmat-cache":
8215 (*s) = NumaOptionsTypeHmatCache
8216 default:
8217 fmt.Println("Failed to decode NumaOptionsType", *s)
8218 }
8219 return nil
8220 }
8221
8222
8223
8224
8225 type X86CPURegister32 int32
8226
8227 const (
8228 X86CPURegister32Eax X86CPURegister32 = iota
8229 X86CPURegister32Ebx
8230 X86CPURegister32Ecx
8231 X86CPURegister32Edx
8232 X86CPURegister32Esp
8233 X86CPURegister32Ebp
8234 X86CPURegister32Esi
8235 X86CPURegister32Edi
8236 )
8237
8238 func (s X86CPURegister32) MarshalJSON() ([]byte, error) {
8239 switch s {
8240 case X86CPURegister32Eax:
8241 return []byte(`"EAX"`), nil
8242 case X86CPURegister32Ebx:
8243 return []byte(`"EBX"`), nil
8244 case X86CPURegister32Ecx:
8245 return []byte(`"ECX"`), nil
8246 case X86CPURegister32Edx:
8247 return []byte(`"EDX"`), nil
8248 case X86CPURegister32Esp:
8249 return []byte(`"ESP"`), nil
8250 case X86CPURegister32Ebp:
8251 return []byte(`"EBP"`), nil
8252 case X86CPURegister32Esi:
8253 return []byte(`"ESI"`), nil
8254 case X86CPURegister32Edi:
8255 return []byte(`"EDI"`), nil
8256 default:
8257 fmt.Println("Failed to decode X86CPURegister32", s)
8258 }
8259 return nil, errors.New("Failed")
8260 }
8261
8262 func (s *X86CPURegister32) UnmarshalJSON(data []byte) error {
8263 var name string
8264
8265 if err := json.Unmarshal(data, &name); err != nil {
8266 return err
8267 }
8268
8269 switch name {
8270 case "EAX":
8271 (*s) = X86CPURegister32Eax
8272 case "EBX":
8273 (*s) = X86CPURegister32Ebx
8274 case "ECX":
8275 (*s) = X86CPURegister32Ecx
8276 case "EDX":
8277 (*s) = X86CPURegister32Edx
8278 case "ESP":
8279 (*s) = X86CPURegister32Esp
8280 case "EBP":
8281 (*s) = X86CPURegister32Ebp
8282 case "ESI":
8283 (*s) = X86CPURegister32Esi
8284 case "EDI":
8285 (*s) = X86CPURegister32Edi
8286 default:
8287 fmt.Println("Failed to decode X86CPURegister32", *s)
8288 }
8289 return nil
8290 }
8291
8292
8293
8294
8295
8296
8297
8298
8299 type HmatLBMemoryHierarchy int32
8300
8301 const (
8302 HmatLBMemoryHierarchyMemory HmatLBMemoryHierarchy = iota
8303 HmatLBMemoryHierarchyFirstLevel
8304 HmatLBMemoryHierarchySecondLevel
8305 HmatLBMemoryHierarchyThirdLevel
8306 )
8307
8308 func (s HmatLBMemoryHierarchy) MarshalJSON() ([]byte, error) {
8309 switch s {
8310 case HmatLBMemoryHierarchyMemory:
8311 return []byte(`"memory"`), nil
8312 case HmatLBMemoryHierarchyFirstLevel:
8313 return []byte(`"first-level"`), nil
8314 case HmatLBMemoryHierarchySecondLevel:
8315 return []byte(`"second-level"`), nil
8316 case HmatLBMemoryHierarchyThirdLevel:
8317 return []byte(`"third-level"`), nil
8318 default:
8319 fmt.Println("Failed to decode HmatLBMemoryHierarchy", s)
8320 }
8321 return nil, errors.New("Failed")
8322 }
8323
8324 func (s *HmatLBMemoryHierarchy) UnmarshalJSON(data []byte) error {
8325 var name string
8326
8327 if err := json.Unmarshal(data, &name); err != nil {
8328 return err
8329 }
8330
8331 switch name {
8332 case "memory":
8333 (*s) = HmatLBMemoryHierarchyMemory
8334 case "first-level":
8335 (*s) = HmatLBMemoryHierarchyFirstLevel
8336 case "second-level":
8337 (*s) = HmatLBMemoryHierarchySecondLevel
8338 case "third-level":
8339 (*s) = HmatLBMemoryHierarchyThirdLevel
8340 default:
8341 fmt.Println("Failed to decode HmatLBMemoryHierarchy", *s)
8342 }
8343 return nil
8344 }
8345
8346
8347
8348
8349
8350
8351
8352
8353 type HmatLBDataType int32
8354
8355 const (
8356 HmatLBDataTypeAccessLatency HmatLBDataType = iota
8357 HmatLBDataTypeReadLatency
8358 HmatLBDataTypeWriteLatency
8359 HmatLBDataTypeAccessBandwidth
8360 HmatLBDataTypeReadBandwidth
8361 HmatLBDataTypeWriteBandwidth
8362 )
8363
8364 func (s HmatLBDataType) MarshalJSON() ([]byte, error) {
8365 switch s {
8366 case HmatLBDataTypeAccessLatency:
8367 return []byte(`"access-latency"`), nil
8368 case HmatLBDataTypeReadLatency:
8369 return []byte(`"read-latency"`), nil
8370 case HmatLBDataTypeWriteLatency:
8371 return []byte(`"write-latency"`), nil
8372 case HmatLBDataTypeAccessBandwidth:
8373 return []byte(`"access-bandwidth"`), nil
8374 case HmatLBDataTypeReadBandwidth:
8375 return []byte(`"read-bandwidth"`), nil
8376 case HmatLBDataTypeWriteBandwidth:
8377 return []byte(`"write-bandwidth"`), nil
8378 default:
8379 fmt.Println("Failed to decode HmatLBDataType", s)
8380 }
8381 return nil, errors.New("Failed")
8382 }
8383
8384 func (s *HmatLBDataType) UnmarshalJSON(data []byte) error {
8385 var name string
8386
8387 if err := json.Unmarshal(data, &name); err != nil {
8388 return err
8389 }
8390
8391 switch name {
8392 case "access-latency":
8393 (*s) = HmatLBDataTypeAccessLatency
8394 case "read-latency":
8395 (*s) = HmatLBDataTypeReadLatency
8396 case "write-latency":
8397 (*s) = HmatLBDataTypeWriteLatency
8398 case "access-bandwidth":
8399 (*s) = HmatLBDataTypeAccessBandwidth
8400 case "read-bandwidth":
8401 (*s) = HmatLBDataTypeReadBandwidth
8402 case "write-bandwidth":
8403 (*s) = HmatLBDataTypeWriteBandwidth
8404 default:
8405 fmt.Println("Failed to decode HmatLBDataType", *s)
8406 }
8407 return nil
8408 }
8409
8410
8411
8412
8413
8414
8415
8416
8417 type HmatCacheAssociativity int32
8418
8419 const (
8420 HmatCacheAssociativityNone HmatCacheAssociativity = iota
8421 HmatCacheAssociativityDirect
8422 HmatCacheAssociativityComplex
8423 )
8424
8425 func (s HmatCacheAssociativity) MarshalJSON() ([]byte, error) {
8426 switch s {
8427 case HmatCacheAssociativityNone:
8428 return []byte(`"none"`), nil
8429 case HmatCacheAssociativityDirect:
8430 return []byte(`"direct"`), nil
8431 case HmatCacheAssociativityComplex:
8432 return []byte(`"complex"`), nil
8433 default:
8434 fmt.Println("Failed to decode HmatCacheAssociativity", s)
8435 }
8436 return nil, errors.New("Failed")
8437 }
8438
8439 func (s *HmatCacheAssociativity) UnmarshalJSON(data []byte) error {
8440 var name string
8441
8442 if err := json.Unmarshal(data, &name); err != nil {
8443 return err
8444 }
8445
8446 switch name {
8447 case "none":
8448 (*s) = HmatCacheAssociativityNone
8449 case "direct":
8450 (*s) = HmatCacheAssociativityDirect
8451 case "complex":
8452 (*s) = HmatCacheAssociativityComplex
8453 default:
8454 fmt.Println("Failed to decode HmatCacheAssociativity", *s)
8455 }
8456 return nil
8457 }
8458
8459
8460
8461
8462
8463
8464
8465
8466 type HmatCacheWritePolicy int32
8467
8468 const (
8469 HmatCacheWritePolicyNone HmatCacheWritePolicy = iota
8470 HmatCacheWritePolicyWriteBack
8471 HmatCacheWritePolicyWriteThrough
8472 )
8473
8474 func (s HmatCacheWritePolicy) MarshalJSON() ([]byte, error) {
8475 switch s {
8476 case HmatCacheWritePolicyNone:
8477 return []byte(`"none"`), nil
8478 case HmatCacheWritePolicyWriteBack:
8479 return []byte(`"write-back"`), nil
8480 case HmatCacheWritePolicyWriteThrough:
8481 return []byte(`"write-through"`), nil
8482 default:
8483 fmt.Println("Failed to decode HmatCacheWritePolicy", s)
8484 }
8485 return nil, errors.New("Failed")
8486 }
8487
8488 func (s *HmatCacheWritePolicy) UnmarshalJSON(data []byte) error {
8489 var name string
8490
8491 if err := json.Unmarshal(data, &name); err != nil {
8492 return err
8493 }
8494
8495 switch name {
8496 case "none":
8497 (*s) = HmatCacheWritePolicyNone
8498 case "write-back":
8499 (*s) = HmatCacheWritePolicyWriteBack
8500 case "write-through":
8501 (*s) = HmatCacheWritePolicyWriteThrough
8502 default:
8503 fmt.Println("Failed to decode HmatCacheWritePolicy", *s)
8504 }
8505 return nil
8506 }
8507
8508
8509 type MemoryDeviceInfoKind int32
8510
8511 const (
8512 MemoryDeviceInfoKindDimm MemoryDeviceInfoKind = iota
8513 MemoryDeviceInfoKindNvdimm
8514 MemoryDeviceInfoKindVirtioPmem
8515 MemoryDeviceInfoKindVirtioMem
8516 MemoryDeviceInfoKindSgxEpc
8517 )
8518
8519 func (s MemoryDeviceInfoKind) MarshalJSON() ([]byte, error) {
8520 switch s {
8521 case MemoryDeviceInfoKindDimm:
8522 return []byte(`"dimm"`), nil
8523 case MemoryDeviceInfoKindNvdimm:
8524 return []byte(`"nvdimm"`), nil
8525 case MemoryDeviceInfoKindVirtioPmem:
8526 return []byte(`"virtio-pmem"`), nil
8527 case MemoryDeviceInfoKindVirtioMem:
8528 return []byte(`"virtio-mem"`), nil
8529 case MemoryDeviceInfoKindSgxEpc:
8530 return []byte(`"sgx-epc"`), nil
8531 default:
8532 fmt.Println("Failed to decode MemoryDeviceInfoKind", s)
8533 }
8534 return nil, errors.New("Failed")
8535 }
8536
8537 func (s *MemoryDeviceInfoKind) UnmarshalJSON(data []byte) error {
8538 var name string
8539
8540 if err := json.Unmarshal(data, &name); err != nil {
8541 return err
8542 }
8543
8544 switch name {
8545 case "dimm":
8546 (*s) = MemoryDeviceInfoKindDimm
8547 case "nvdimm":
8548 (*s) = MemoryDeviceInfoKindNvdimm
8549 case "virtio-pmem":
8550 (*s) = MemoryDeviceInfoKindVirtioPmem
8551 case "virtio-mem":
8552 (*s) = MemoryDeviceInfoKindVirtioMem
8553 case "sgx-epc":
8554 (*s) = MemoryDeviceInfoKindSgxEpc
8555 default:
8556 fmt.Println("Failed to decode MemoryDeviceInfoKind", *s)
8557 }
8558 return nil
8559 }
8560
8561
8562 type SmbiosEntryPointType int32
8563
8564 const (
8565 SmbiosEntryPointType32 SmbiosEntryPointType = iota
8566 SmbiosEntryPointType64
8567 )
8568
8569 func (s SmbiosEntryPointType) MarshalJSON() ([]byte, error) {
8570 switch s {
8571 case SmbiosEntryPointType32:
8572 return []byte(`"32"`), nil
8573 case SmbiosEntryPointType64:
8574 return []byte(`"64"`), nil
8575 default:
8576 fmt.Println("Failed to decode SmbiosEntryPointType", s)
8577 }
8578 return nil, errors.New("Failed")
8579 }
8580
8581 func (s *SmbiosEntryPointType) UnmarshalJSON(data []byte) error {
8582 var name string
8583
8584 if err := json.Unmarshal(data, &name); err != nil {
8585 return err
8586 }
8587
8588 switch name {
8589 case "32":
8590 (*s) = SmbiosEntryPointType32
8591 case "64":
8592 (*s) = SmbiosEntryPointType64
8593 default:
8594 fmt.Println("Failed to decode SmbiosEntryPointType", *s)
8595 }
8596 return nil
8597 }
8598
8599
8600
8601
8602
8603
8604
8605
8606
8607
8608
8609
8610
8611 type CpuModelExpansionType int32
8612
8613 const (
8614 CpuModelExpansionTypeStatic CpuModelExpansionType = iota
8615 CpuModelExpansionTypeFull
8616 )
8617
8618 func (s CpuModelExpansionType) MarshalJSON() ([]byte, error) {
8619 switch s {
8620 case CpuModelExpansionTypeStatic:
8621 return []byte(`"static"`), nil
8622 case CpuModelExpansionTypeFull:
8623 return []byte(`"full"`), nil
8624 default:
8625 fmt.Println("Failed to decode CpuModelExpansionType", s)
8626 }
8627 return nil, errors.New("Failed")
8628 }
8629
8630 func (s *CpuModelExpansionType) UnmarshalJSON(data []byte) error {
8631 var name string
8632
8633 if err := json.Unmarshal(data, &name); err != nil {
8634 return err
8635 }
8636
8637 switch name {
8638 case "static":
8639 (*s) = CpuModelExpansionTypeStatic
8640 case "full":
8641 (*s) = CpuModelExpansionTypeFull
8642 default:
8643 fmt.Println("Failed to decode CpuModelExpansionType", *s)
8644 }
8645 return nil
8646 }
8647
8648
8649
8650
8651
8652 type CpuModelCompareResult int32
8653
8654 const (
8655 CpuModelCompareResultIncompatible CpuModelCompareResult = iota
8656 CpuModelCompareResultIdentical
8657 CpuModelCompareResultSuperset
8658 CpuModelCompareResultSubset
8659 )
8660
8661 func (s CpuModelCompareResult) MarshalJSON() ([]byte, error) {
8662 switch s {
8663 case CpuModelCompareResultIncompatible:
8664 return []byte(`"incompatible"`), nil
8665 case CpuModelCompareResultIdentical:
8666 return []byte(`"identical"`), nil
8667 case CpuModelCompareResultSuperset:
8668 return []byte(`"superset"`), nil
8669 case CpuModelCompareResultSubset:
8670 return []byte(`"subset"`), nil
8671 default:
8672 fmt.Println("Failed to decode CpuModelCompareResult", s)
8673 }
8674 return nil, errors.New("Failed")
8675 }
8676
8677 func (s *CpuModelCompareResult) UnmarshalJSON(data []byte) error {
8678 var name string
8679
8680 if err := json.Unmarshal(data, &name); err != nil {
8681 return err
8682 }
8683
8684 switch name {
8685 case "incompatible":
8686 (*s) = CpuModelCompareResultIncompatible
8687 case "identical":
8688 (*s) = CpuModelCompareResultIdentical
8689 case "superset":
8690 (*s) = CpuModelCompareResultSuperset
8691 case "subset":
8692 (*s) = CpuModelCompareResultSubset
8693 default:
8694 fmt.Println("Failed to decode CpuModelCompareResult", *s)
8695 }
8696 return nil
8697 }
8698
8699
8700
8701
8702 type ReplayMode int32
8703
8704 const (
8705 ReplayModeNone ReplayMode = iota
8706 ReplayModeRecord
8707 ReplayModePlay
8708 )
8709
8710 func (s ReplayMode) MarshalJSON() ([]byte, error) {
8711 switch s {
8712 case ReplayModeNone:
8713 return []byte(`"none"`), nil
8714 case ReplayModeRecord:
8715 return []byte(`"record"`), nil
8716 case ReplayModePlay:
8717 return []byte(`"play"`), nil
8718 default:
8719 fmt.Println("Failed to decode ReplayMode", s)
8720 }
8721 return nil, errors.New("Failed")
8722 }
8723
8724 func (s *ReplayMode) UnmarshalJSON(data []byte) error {
8725 var name string
8726
8727 if err := json.Unmarshal(data, &name); err != nil {
8728 return err
8729 }
8730
8731 switch name {
8732 case "none":
8733 (*s) = ReplayModeNone
8734 case "record":
8735 (*s) = ReplayModeRecord
8736 case "play":
8737 (*s) = ReplayModePlay
8738 default:
8739 fmt.Println("Failed to decode ReplayMode", *s)
8740 }
8741 return nil
8742 }
8743
8744
8745
8746
8747
8748 type YankInstanceType int32
8749
8750 const (
8751 YankInstanceTypeBlockNode YankInstanceType = iota
8752 YankInstanceTypeChardev
8753 YankInstanceTypeMigration
8754 )
8755
8756 func (s YankInstanceType) MarshalJSON() ([]byte, error) {
8757 switch s {
8758 case YankInstanceTypeBlockNode:
8759 return []byte(`"block-node"`), nil
8760 case YankInstanceTypeChardev:
8761 return []byte(`"chardev"`), nil
8762 case YankInstanceTypeMigration:
8763 return []byte(`"migration"`), nil
8764 default:
8765 fmt.Println("Failed to decode YankInstanceType", s)
8766 }
8767 return nil, errors.New("Failed")
8768 }
8769
8770 func (s *YankInstanceType) UnmarshalJSON(data []byte) error {
8771 var name string
8772
8773 if err := json.Unmarshal(data, &name); err != nil {
8774 return err
8775 }
8776
8777 switch name {
8778 case "block-node":
8779 (*s) = YankInstanceTypeBlockNode
8780 case "chardev":
8781 (*s) = YankInstanceTypeChardev
8782 case "migration":
8783 (*s) = YankInstanceTypeMigration
8784 default:
8785 fmt.Println("Failed to decode YankInstanceType", *s)
8786 }
8787 return nil
8788 }
8789
8790
8791
8792
8793 type CommandLineParameterType int32
8794
8795 const (
8796 CommandLineParameterTypeString CommandLineParameterType = iota
8797 CommandLineParameterTypeBoolean
8798 CommandLineParameterTypeNumber
8799 CommandLineParameterTypeSize
8800 )
8801
8802 func (s CommandLineParameterType) MarshalJSON() ([]byte, error) {
8803 switch s {
8804 case CommandLineParameterTypeString:
8805 return []byte(`"string"`), nil
8806 case CommandLineParameterTypeBoolean:
8807 return []byte(`"boolean"`), nil
8808 case CommandLineParameterTypeNumber:
8809 return []byte(`"number"`), nil
8810 case CommandLineParameterTypeSize:
8811 return []byte(`"size"`), nil
8812 default:
8813 fmt.Println("Failed to decode CommandLineParameterType", s)
8814 }
8815 return nil, errors.New("Failed")
8816 }
8817
8818 func (s *CommandLineParameterType) UnmarshalJSON(data []byte) error {
8819 var name string
8820
8821 if err := json.Unmarshal(data, &name); err != nil {
8822 return err
8823 }
8824
8825 switch name {
8826 case "string":
8827 (*s) = CommandLineParameterTypeString
8828 case "boolean":
8829 (*s) = CommandLineParameterTypeBoolean
8830 case "number":
8831 (*s) = CommandLineParameterTypeNumber
8832 case "size":
8833 (*s) = CommandLineParameterTypeSize
8834 default:
8835 fmt.Println("Failed to decode CommandLineParameterType", *s)
8836 }
8837 return nil
8838 }
8839
8840
8841
8842
8843 type SevState int32
8844
8845 const (
8846 SevStateUninit SevState = iota
8847 SevStateLaunchUpdate
8848 SevStateLaunchSecret
8849 SevStateRunning
8850 SevStateSendUpdate
8851 SevStateReceiveUpdate
8852 )
8853
8854 func (s SevState) MarshalJSON() ([]byte, error) {
8855 switch s {
8856 case SevStateUninit:
8857 return []byte(`"uninit"`), nil
8858 case SevStateLaunchUpdate:
8859 return []byte(`"launch-update"`), nil
8860 case SevStateLaunchSecret:
8861 return []byte(`"launch-secret"`), nil
8862 case SevStateRunning:
8863 return []byte(`"running"`), nil
8864 case SevStateSendUpdate:
8865 return []byte(`"send-update"`), nil
8866 case SevStateReceiveUpdate:
8867 return []byte(`"receive-update"`), nil
8868 default:
8869 fmt.Println("Failed to decode SevState", s)
8870 }
8871 return nil, errors.New("Failed")
8872 }
8873
8874 func (s *SevState) UnmarshalJSON(data []byte) error {
8875 var name string
8876
8877 if err := json.Unmarshal(data, &name); err != nil {
8878 return err
8879 }
8880
8881 switch name {
8882 case "uninit":
8883 (*s) = SevStateUninit
8884 case "launch-update":
8885 (*s) = SevStateLaunchUpdate
8886 case "launch-secret":
8887 (*s) = SevStateLaunchSecret
8888 case "running":
8889 (*s) = SevStateRunning
8890 case "send-update":
8891 (*s) = SevStateSendUpdate
8892 case "receive-update":
8893 (*s) = SevStateReceiveUpdate
8894 default:
8895 fmt.Println("Failed to decode SevState", *s)
8896 }
8897 return nil
8898 }
8899
8900
8901
8902
8903 type AudioFormat int32
8904
8905 const (
8906 AudioFormatU8 AudioFormat = iota
8907 AudioFormatS8
8908 AudioFormatU16
8909 AudioFormatS16
8910 AudioFormatU32
8911 AudioFormatS32
8912 AudioFormatF32
8913 )
8914
8915 func (s AudioFormat) MarshalJSON() ([]byte, error) {
8916 switch s {
8917 case AudioFormatU8:
8918 return []byte(`"u8"`), nil
8919 case AudioFormatS8:
8920 return []byte(`"s8"`), nil
8921 case AudioFormatU16:
8922 return []byte(`"u16"`), nil
8923 case AudioFormatS16:
8924 return []byte(`"s16"`), nil
8925 case AudioFormatU32:
8926 return []byte(`"u32"`), nil
8927 case AudioFormatS32:
8928 return []byte(`"s32"`), nil
8929 case AudioFormatF32:
8930 return []byte(`"f32"`), nil
8931 default:
8932 fmt.Println("Failed to decode AudioFormat", s)
8933 }
8934 return nil, errors.New("Failed")
8935 }
8936
8937 func (s *AudioFormat) UnmarshalJSON(data []byte) error {
8938 var name string
8939
8940 if err := json.Unmarshal(data, &name); err != nil {
8941 return err
8942 }
8943
8944 switch name {
8945 case "u8":
8946 (*s) = AudioFormatU8
8947 case "s8":
8948 (*s) = AudioFormatS8
8949 case "u16":
8950 (*s) = AudioFormatU16
8951 case "s16":
8952 (*s) = AudioFormatS16
8953 case "u32":
8954 (*s) = AudioFormatU32
8955 case "s32":
8956 (*s) = AudioFormatS32
8957 case "f32":
8958 (*s) = AudioFormatF32
8959 default:
8960 fmt.Println("Failed to decode AudioFormat", *s)
8961 }
8962 return nil
8963 }
8964
8965
8966
8967
8968 type AudiodevDriver int32
8969
8970 const (
8971 AudiodevDriverNone AudiodevDriver = iota
8972 AudiodevDriverAlsa
8973 AudiodevDriverCoreaudio
8974 AudiodevDriverDbus
8975 AudiodevDriverDsound
8976 AudiodevDriverJack
8977 AudiodevDriverOss
8978 AudiodevDriverPa
8979 AudiodevDriverSdl
8980 AudiodevDriverSpice
8981 AudiodevDriverWav
8982 )
8983
8984 func (s AudiodevDriver) MarshalJSON() ([]byte, error) {
8985 switch s {
8986 case AudiodevDriverNone:
8987 return []byte(`"none"`), nil
8988 case AudiodevDriverAlsa:
8989 return []byte(`"alsa"`), nil
8990 case AudiodevDriverCoreaudio:
8991 return []byte(`"coreaudio"`), nil
8992 case AudiodevDriverDbus:
8993 return []byte(`"dbus"`), nil
8994 case AudiodevDriverDsound:
8995 return []byte(`"dsound"`), nil
8996 case AudiodevDriverJack:
8997 return []byte(`"jack"`), nil
8998 case AudiodevDriverOss:
8999 return []byte(`"oss"`), nil
9000 case AudiodevDriverPa:
9001 return []byte(`"pa"`), nil
9002 case AudiodevDriverSdl:
9003 return []byte(`"sdl"`), nil
9004 case AudiodevDriverSpice:
9005 return []byte(`"spice"`), nil
9006 case AudiodevDriverWav:
9007 return []byte(`"wav"`), nil
9008 default:
9009 fmt.Println("Failed to decode AudiodevDriver", s)
9010 }
9011 return nil, errors.New("Failed")
9012 }
9013
9014 func (s *AudiodevDriver) UnmarshalJSON(data []byte) error {
9015 var name string
9016
9017 if err := json.Unmarshal(data, &name); err != nil {
9018 return err
9019 }
9020
9021 switch name {
9022 case "none":
9023 (*s) = AudiodevDriverNone
9024 case "alsa":
9025 (*s) = AudiodevDriverAlsa
9026 case "coreaudio":
9027 (*s) = AudiodevDriverCoreaudio
9028 case "dbus":
9029 (*s) = AudiodevDriverDbus
9030 case "dsound":
9031 (*s) = AudiodevDriverDsound
9032 case "jack":
9033 (*s) = AudiodevDriverJack
9034 case "oss":
9035 (*s) = AudiodevDriverOss
9036 case "pa":
9037 (*s) = AudiodevDriverPa
9038 case "sdl":
9039 (*s) = AudiodevDriverSdl
9040 case "spice":
9041 (*s) = AudiodevDriverSpice
9042 case "wav":
9043 (*s) = AudiodevDriverWav
9044 default:
9045 fmt.Println("Failed to decode AudiodevDriver", *s)
9046 }
9047 return nil
9048 }
9049
9050 type ACPISlotType int32
9051
9052 const (
9053 ACPISlotTypeDimm ACPISlotType = iota
9054 ACPISlotTypeCpu
9055 )
9056
9057 func (s ACPISlotType) MarshalJSON() ([]byte, error) {
9058 switch s {
9059 case ACPISlotTypeDimm:
9060 return []byte(`"DIMM"`), nil
9061 case ACPISlotTypeCpu:
9062 return []byte(`"CPU"`), nil
9063 default:
9064 fmt.Println("Failed to decode ACPISlotType", s)
9065 }
9066 return nil, errors.New("Failed")
9067 }
9068
9069 func (s *ACPISlotType) UnmarshalJSON(data []byte) error {
9070 var name string
9071
9072 if err := json.Unmarshal(data, &name); err != nil {
9073 return err
9074 }
9075
9076 switch name {
9077 case "DIMM":
9078 (*s) = ACPISlotTypeDimm
9079 case "CPU":
9080 (*s) = ACPISlotTypeCpu
9081 default:
9082 fmt.Println("Failed to decode ACPISlotType", *s)
9083 }
9084 return nil
9085 }
9086
View as plain text