1 // This file was autogenerated.  Do not edit!
2 // See elog-gen.py for more details
3 #pragma once
4 
5 #include <phosphor-logging/elog.hpp>
6 #include <phosphor-logging/log.hpp>
7 #include <sdbusplus/exception.hpp>
8 
9 #include <string>
10 #include <tuple>
11 #include <type_traits>
12 
13 namespace sdbusplus
14 {
15 namespace org
16 {
17 namespace open_power
18 {
19 namespace Witherspoon
20 {
21 namespace Fault
22 {
23 namespace Error
24 {
25 struct PowerSequencerPGOODFault;
26 } // namespace Error
27 } // namespace Fault
28 } // namespace Witherspoon
29 } // namespace open_power
30 } // namespace org
31 } // namespace sdbusplus
32 
33 namespace sdbusplus
34 {
35 namespace org
36 {
37 namespace open_power
38 {
39 namespace Witherspoon
40 {
41 namespace Fault
42 {
43 namespace Error
44 {
45 struct MemoryPowerFault;
46 } // namespace Error
47 } // namespace Fault
48 } // namespace Witherspoon
49 } // namespace open_power
50 } // namespace org
51 } // namespace sdbusplus
52 
53 namespace sdbusplus
54 {
55 namespace xyz
56 {
57 namespace openbmc_project
58 {
59 namespace Common
60 {
61 namespace Callout
62 {
63 namespace Error
64 {
65 struct GPIO;
66 } // namespace Error
67 } // namespace Callout
68 } // namespace Common
69 } // namespace openbmc_project
70 } // namespace xyz
71 } // namespace sdbusplus
72 
73 namespace sdbusplus
74 {
75 namespace org
76 {
77 namespace open_power
78 {
79 namespace Witherspoon
80 {
81 namespace Fault
82 {
83 namespace Error
84 {
85 struct PowerOnFailure;
86 } // namespace Error
87 } // namespace Fault
88 } // namespace Witherspoon
89 } // namespace open_power
90 } // namespace org
91 } // namespace sdbusplus
92 
93 namespace sdbusplus
94 {
95 namespace org
96 {
97 namespace open_power
98 {
99 namespace Witherspoon
100 {
101 namespace Fault
102 {
103 namespace Error
104 {
105 struct PowerSupplyInputFault;
106 } // namespace Error
107 } // namespace Fault
108 } // namespace Witherspoon
109 } // namespace open_power
110 } // namespace org
111 } // namespace sdbusplus
112 
113 namespace sdbusplus
114 {
115 namespace xyz
116 {
117 namespace openbmc_project
118 {
119 namespace Common
120 {
121 namespace Callout
122 {
123 namespace Error
124 {
125 struct IIC;
126 } // namespace Error
127 } // namespace Callout
128 } // namespace Common
129 } // namespace openbmc_project
130 } // namespace xyz
131 } // namespace sdbusplus
132 
133 namespace sdbusplus
134 {
135 namespace org
136 {
137 namespace open_power
138 {
139 namespace Witherspoon
140 {
141 namespace Fault
142 {
143 namespace Error
144 {
145 struct GPUPowerFault;
146 } // namespace Error
147 } // namespace Fault
148 } // namespace Witherspoon
149 } // namespace open_power
150 } // namespace org
151 } // namespace sdbusplus
152 
153 namespace sdbusplus
154 {
155 namespace org
156 {
157 namespace open_power
158 {
159 namespace Witherspoon
160 {
161 namespace Fault
162 {
163 namespace Error
164 {
165 struct Shutdown;
166 } // namespace Error
167 } // namespace Fault
168 } // namespace Witherspoon
169 } // namespace open_power
170 } // namespace org
171 } // namespace sdbusplus
172 
173 namespace sdbusplus
174 {
175 namespace xyz
176 {
177 namespace openbmc_project
178 {
179 namespace Common
180 {
181 namespace Callout
182 {
183 namespace Error
184 {
185 struct Inventory;
186 } // namespace Error
187 } // namespace Callout
188 } // namespace Common
189 } // namespace openbmc_project
190 } // namespace xyz
191 } // namespace sdbusplus
192 
193 namespace sdbusplus
194 {
195 namespace xyz
196 {
197 namespace openbmc_project
198 {
199 namespace Common
200 {
201 namespace Callout
202 {
203 namespace Error
204 {
205 struct Device;
206 } // namespace Error
207 } // namespace Callout
208 } // namespace Common
209 } // namespace openbmc_project
210 } // namespace xyz
211 } // namespace sdbusplus
212 
213 namespace sdbusplus
214 {
215 namespace org
216 {
217 namespace open_power
218 {
219 namespace Witherspoon
220 {
221 namespace Fault
222 {
223 namespace Error
224 {
225 struct PowerSequencerFault;
226 } // namespace Error
227 } // namespace Fault
228 } // namespace Witherspoon
229 } // namespace open_power
230 } // namespace org
231 } // namespace sdbusplus
232 
233 namespace sdbusplus
234 {
235 namespace org
236 {
237 namespace open_power
238 {
239 namespace Witherspoon
240 {
241 namespace Fault
242 {
243 namespace Error
244 {
245 struct PowerSupplyOutputOvercurrent;
246 } // namespace Error
247 } // namespace Fault
248 } // namespace Witherspoon
249 } // namespace open_power
250 } // namespace org
251 } // namespace sdbusplus
252 
253 namespace sdbusplus
254 {
255 namespace org
256 {
257 namespace open_power
258 {
259 namespace Witherspoon
260 {
261 namespace Fault
262 {
263 namespace Error
264 {
265 struct PowerSupplyOutputOvervoltage;
266 } // namespace Error
267 } // namespace Fault
268 } // namespace Witherspoon
269 } // namespace open_power
270 } // namespace org
271 } // namespace sdbusplus
272 
273 namespace sdbusplus
274 {
275 namespace org
276 {
277 namespace open_power
278 {
279 namespace Witherspoon
280 {
281 namespace Fault
282 {
283 namespace Error
284 {
285 struct PowerSupplyFanFault;
286 } // namespace Error
287 } // namespace Fault
288 } // namespace Witherspoon
289 } // namespace open_power
290 } // namespace org
291 } // namespace sdbusplus
292 
293 namespace sdbusplus
294 {
295 namespace org
296 {
297 namespace open_power
298 {
299 namespace Witherspoon
300 {
301 namespace Fault
302 {
303 namespace Error
304 {
305 struct PowerSequencerVoltageFault;
306 } // namespace Error
307 } // namespace Fault
308 } // namespace Witherspoon
309 } // namespace open_power
310 } // namespace org
311 } // namespace sdbusplus
312 
313 namespace sdbusplus
314 {
315 namespace xyz
316 {
317 namespace openbmc_project
318 {
319 namespace Common
320 {
321 namespace Callout
322 {
323 namespace Error
324 {
325 struct IPMISensor;
326 } // namespace Error
327 } // namespace Callout
328 } // namespace Common
329 } // namespace openbmc_project
330 } // namespace xyz
331 } // namespace sdbusplus
332 
333 namespace sdbusplus
334 {
335 namespace org
336 {
337 namespace open_power
338 {
339 namespace Witherspoon
340 {
341 namespace Fault
342 {
343 namespace Error
344 {
345 struct PowerSupplyTemperatureFault;
346 } // namespace Error
347 } // namespace Fault
348 } // namespace Witherspoon
349 } // namespace open_power
350 } // namespace org
351 } // namespace sdbusplus
352 
353 namespace sdbusplus
354 {
355 namespace org
356 {
357 namespace open_power
358 {
359 namespace Witherspoon
360 {
361 namespace Fault
362 {
363 namespace Error
364 {
365 struct PowerSupplyShouldBeOn;
366 } // namespace Error
367 } // namespace Fault
368 } // namespace Witherspoon
369 } // namespace open_power
370 } // namespace org
371 } // namespace sdbusplus
372 
373 namespace sdbusplus
374 {
375 namespace org
376 {
377 namespace open_power
378 {
379 namespace Witherspoon
380 {
381 namespace Fault
382 {
383 namespace Error
384 {
385 struct GPUOverTemp;
386 } // namespace Error
387 } // namespace Fault
388 } // namespace Witherspoon
389 } // namespace open_power
390 } // namespace org
391 } // namespace sdbusplus
392 
393 namespace phosphor
394 {
395 
396 namespace logging
397 {
398 
399 namespace xyz
400 {
401 namespace openbmc_project
402 {
403 namespace Common
404 {
405 namespace Callout
406 {
407 namespace _Device
408 {
409 
410 struct CALLOUT_ERRNO
411 {
412     /*
413      * We can't use -fsanitize=undefined if we declare a
414      * 'static constexpr auto str' member, so don't. Instead, open-code the
415      * mako template lookups.
416      */
417     static constexpr auto str_short = "CALLOUT_ERRNO";
418     using type =
419         std::tuple<std::decay_t<decltype("CALLOUT_ERRNO=%d")>, int32_t>;
420     explicit constexpr CALLOUT_ERRNO(int32_t a) :
421         _entry(entry("CALLOUT_ERRNO=%d", a)){};
422     type _entry;
423 };
424 struct CALLOUT_DEVICE_PATH
425 {
426     /*
427      * We can't use -fsanitize=undefined if we declare a
428      * 'static constexpr auto str' member, so don't. Instead, open-code the
429      * mako template lookups.
430      */
431     static constexpr auto str_short = "CALLOUT_DEVICE_PATH";
432     using type = std::tuple<std::decay_t<decltype("CALLOUT_DEVICE_PATH=%s")>,
433                             const char*>;
434     explicit constexpr CALLOUT_DEVICE_PATH(const char* a) :
435         _entry(entry("CALLOUT_DEVICE_PATH=%s", a)){};
436     type _entry;
437 };
438 
439 } // namespace _Device
440 
441 struct Device
442 {
443     static constexpr auto L = level::ERR;
444     using CALLOUT_ERRNO = _Device::CALLOUT_ERRNO;
445     using CALLOUT_DEVICE_PATH = _Device::CALLOUT_DEVICE_PATH;
446     using metadata_types = std::tuple<CALLOUT_ERRNO, CALLOUT_DEVICE_PATH>;
447 };
448 
449 } // namespace Callout
450 } // namespace Common
451 } // namespace openbmc_project
452 } // namespace xyz
453 
454 namespace details
455 {
456 
457 template <>
458 struct map_exception_type<
459     sdbusplus::xyz::openbmc_project::Common::Callout::Error::Device>
460 {
461     using type = xyz::openbmc_project::Common::Callout::Device;
462 };
463 
464 } // namespace details
465 
466 namespace xyz
467 {
468 namespace openbmc_project
469 {
470 namespace Common
471 {
472 namespace Callout
473 {
474 namespace _GPIO
475 {
476 
477 struct CALLOUT_GPIO_NUM
478 {
479     /*
480      * We can't use -fsanitize=undefined if we declare a
481      * 'static constexpr auto str' member, so don't. Instead, open-code the
482      * mako template lookups.
483      */
484     static constexpr auto str_short = "CALLOUT_GPIO_NUM";
485     using type =
486         std::tuple<std::decay_t<decltype("CALLOUT_GPIO_NUM=%u")>, uint32_t>;
487     explicit constexpr CALLOUT_GPIO_NUM(uint32_t a) :
488         _entry(entry("CALLOUT_GPIO_NUM=%u", a)){};
489     type _entry;
490 };
491 
492 } // namespace _GPIO
493 
494 struct GPIO
495 {
496     static constexpr auto L = level::ERR;
497     using CALLOUT_GPIO_NUM = _GPIO::CALLOUT_GPIO_NUM;
498     using CALLOUT_ERRNO =
499         xyz::openbmc_project::Common::Callout::Device::CALLOUT_ERRNO;
500     using CALLOUT_DEVICE_PATH =
501         xyz::openbmc_project::Common::Callout::Device::CALLOUT_DEVICE_PATH;
502     using metadata_types =
503         std::tuple<CALLOUT_GPIO_NUM, CALLOUT_ERRNO, CALLOUT_DEVICE_PATH>;
504 };
505 
506 } // namespace Callout
507 } // namespace Common
508 } // namespace openbmc_project
509 } // namespace xyz
510 
511 namespace details
512 {
513 
514 template <>
515 struct map_exception_type<
516     sdbusplus::xyz::openbmc_project::Common::Callout::Error::GPIO>
517 {
518     using type = xyz::openbmc_project::Common::Callout::GPIO;
519 };
520 
521 } // namespace details
522 
523 namespace xyz
524 {
525 namespace openbmc_project
526 {
527 namespace Common
528 {
529 namespace Callout
530 {
531 namespace _IIC
532 {
533 
534 struct CALLOUT_IIC_BUS
535 {
536     /*
537      * We can't use -fsanitize=undefined if we declare a
538      * 'static constexpr auto str' member, so don't. Instead, open-code the
539      * mako template lookups.
540      */
541     static constexpr auto str_short = "CALLOUT_IIC_BUS";
542     using type =
543         std::tuple<std::decay_t<decltype("CALLOUT_IIC_BUS=%s")>, const char*>;
544     explicit constexpr CALLOUT_IIC_BUS(const char* a) :
545         _entry(entry("CALLOUT_IIC_BUS=%s", a)){};
546     type _entry;
547 };
548 struct CALLOUT_IIC_ADDR
549 {
550     /*
551      * We can't use -fsanitize=undefined if we declare a
552      * 'static constexpr auto str' member, so don't. Instead, open-code the
553      * mako template lookups.
554      */
555     static constexpr auto str_short = "CALLOUT_IIC_ADDR";
556     using type =
557         std::tuple<std::decay_t<decltype("CALLOUT_IIC_ADDR=0x%hx")>, uint16_t>;
558     explicit constexpr CALLOUT_IIC_ADDR(uint16_t a) :
559         _entry(entry("CALLOUT_IIC_ADDR=0x%hx", a)){};
560     type _entry;
561 };
562 
563 } // namespace _IIC
564 
565 struct IIC
566 {
567     static constexpr auto L = level::ERR;
568     using CALLOUT_IIC_BUS = _IIC::CALLOUT_IIC_BUS;
569     using CALLOUT_IIC_ADDR = _IIC::CALLOUT_IIC_ADDR;
570     using CALLOUT_ERRNO =
571         xyz::openbmc_project::Common::Callout::Device::CALLOUT_ERRNO;
572     using CALLOUT_DEVICE_PATH =
573         xyz::openbmc_project::Common::Callout::Device::CALLOUT_DEVICE_PATH;
574     using metadata_types = std::tuple<CALLOUT_IIC_BUS, CALLOUT_IIC_ADDR,
575                                       CALLOUT_ERRNO, CALLOUT_DEVICE_PATH>;
576 };
577 
578 } // namespace Callout
579 } // namespace Common
580 } // namespace openbmc_project
581 } // namespace xyz
582 
583 namespace details
584 {
585 
586 template <>
587 struct map_exception_type<
588     sdbusplus::xyz::openbmc_project::Common::Callout::Error::IIC>
589 {
590     using type = xyz::openbmc_project::Common::Callout::IIC;
591 };
592 
593 } // namespace details
594 
595 namespace xyz
596 {
597 namespace openbmc_project
598 {
599 namespace Common
600 {
601 namespace Callout
602 {
603 namespace _Inventory
604 {
605 
606 struct CALLOUT_INVENTORY_PATH
607 {
608     /*
609      * We can't use -fsanitize=undefined if we declare a
610      * 'static constexpr auto str' member, so don't. Instead, open-code the
611      * mako template lookups.
612      */
613     static constexpr auto str_short = "CALLOUT_INVENTORY_PATH";
614     using type = std::tuple<std::decay_t<decltype("CALLOUT_INVENTORY_PATH=%s")>,
615                             const char*>;
616     explicit constexpr CALLOUT_INVENTORY_PATH(const char* a) :
617         _entry(entry("CALLOUT_INVENTORY_PATH=%s", a)){};
618     type _entry;
619 };
620 
621 } // namespace _Inventory
622 
623 struct Inventory
624 {
625     static constexpr auto L = level::ERR;
626     using CALLOUT_INVENTORY_PATH = _Inventory::CALLOUT_INVENTORY_PATH;
627     using metadata_types = std::tuple<CALLOUT_INVENTORY_PATH>;
628 };
629 
630 } // namespace Callout
631 } // namespace Common
632 } // namespace openbmc_project
633 } // namespace xyz
634 
635 namespace details
636 {
637 
638 template <>
639 struct map_exception_type<
640     sdbusplus::xyz::openbmc_project::Common::Callout::Error::Inventory>
641 {
642     using type = xyz::openbmc_project::Common::Callout::Inventory;
643 };
644 
645 } // namespace details
646 
647 namespace xyz
648 {
649 namespace openbmc_project
650 {
651 namespace Common
652 {
653 namespace Callout
654 {
655 namespace _IPMISensor
656 {
657 
658 struct CALLOUT_IPMI_SENSOR_NUM
659 {
660     /*
661      * We can't use -fsanitize=undefined if we declare a
662      * 'static constexpr auto str' member, so don't. Instead, open-code the
663      * mako template lookups.
664      */
665     static constexpr auto str_short = "CALLOUT_IPMI_SENSOR_NUM";
666     using type =
667         std::tuple<std::decay_t<decltype("CALLOUT_IPMI_SENSOR_NUM=%u")>,
668                    uint32_t>;
669     explicit constexpr CALLOUT_IPMI_SENSOR_NUM(uint32_t a) :
670         _entry(entry("CALLOUT_IPMI_SENSOR_NUM=%u", a)){};
671     type _entry;
672 };
673 
674 } // namespace _IPMISensor
675 
676 struct IPMISensor
677 {
678     static constexpr auto L = level::ERR;
679     using CALLOUT_IPMI_SENSOR_NUM = _IPMISensor::CALLOUT_IPMI_SENSOR_NUM;
680     using metadata_types = std::tuple<CALLOUT_IPMI_SENSOR_NUM>;
681 };
682 
683 } // namespace Callout
684 } // namespace Common
685 } // namespace openbmc_project
686 } // namespace xyz
687 
688 namespace details
689 {
690 
691 template <>
692 struct map_exception_type<
693     sdbusplus::xyz::openbmc_project::Common::Callout::Error::IPMISensor>
694 {
695     using type = xyz::openbmc_project::Common::Callout::IPMISensor;
696 };
697 
698 } // namespace details
699 
700 namespace org
701 {
702 namespace open_power
703 {
704 namespace Witherspoon
705 {
706 namespace Fault
707 {
708 namespace _PowerSupplyInputFault
709 {
710 
711 struct RAW_STATUS
712 {
713     /*
714      * We can't use -fsanitize=undefined if we declare a
715      * 'static constexpr auto str' member, so don't. Instead, open-code the
716      * mako template lookups.
717      */
718     static constexpr auto str_short = "RAW_STATUS";
719     using type =
720         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
721     explicit constexpr RAW_STATUS(const char* a) :
722         _entry(entry("RAW_STATUS=%s", a)){};
723     type _entry;
724 };
725 
726 } // namespace _PowerSupplyInputFault
727 
728 struct PowerSupplyInputFault
729 {
730     static constexpr auto L = level::ERR;
731     using RAW_STATUS = _PowerSupplyInputFault::RAW_STATUS;
732     using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout::
733         Inventory::CALLOUT_INVENTORY_PATH;
734     using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>;
735 };
736 
737 } // namespace Fault
738 } // namespace Witherspoon
739 } // namespace open_power
740 } // namespace org
741 
742 namespace details
743 {
744 
745 template <>
746 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault::
747                               Error::PowerSupplyInputFault>
748 {
749     using type = org::open_power::Witherspoon::Fault::PowerSupplyInputFault;
750 };
751 
752 } // namespace details
753 
754 namespace org
755 {
756 namespace open_power
757 {
758 namespace Witherspoon
759 {
760 namespace Fault
761 {
762 namespace _PowerSupplyShouldBeOn
763 {
764 
765 struct RAW_STATUS
766 {
767     /*
768      * We can't use -fsanitize=undefined if we declare a
769      * 'static constexpr auto str' member, so don't. Instead, open-code the
770      * mako template lookups.
771      */
772     static constexpr auto str_short = "RAW_STATUS";
773     using type =
774         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
775     explicit constexpr RAW_STATUS(const char* a) :
776         _entry(entry("RAW_STATUS=%s", a)){};
777     type _entry;
778 };
779 
780 } // namespace _PowerSupplyShouldBeOn
781 
782 struct PowerSupplyShouldBeOn
783 {
784     static constexpr auto L = level::ERR;
785     using RAW_STATUS = _PowerSupplyShouldBeOn::RAW_STATUS;
786     using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout::
787         Inventory::CALLOUT_INVENTORY_PATH;
788     using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>;
789 };
790 
791 } // namespace Fault
792 } // namespace Witherspoon
793 } // namespace open_power
794 } // namespace org
795 
796 namespace details
797 {
798 
799 template <>
800 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault::
801                               Error::PowerSupplyShouldBeOn>
802 {
803     using type = org::open_power::Witherspoon::Fault::PowerSupplyShouldBeOn;
804 };
805 
806 } // namespace details
807 
808 namespace org
809 {
810 namespace open_power
811 {
812 namespace Witherspoon
813 {
814 namespace Fault
815 {
816 namespace _PowerSupplyOutputOvercurrent
817 {
818 
819 struct RAW_STATUS
820 {
821     /*
822      * We can't use -fsanitize=undefined if we declare a
823      * 'static constexpr auto str' member, so don't. Instead, open-code the
824      * mako template lookups.
825      */
826     static constexpr auto str_short = "RAW_STATUS";
827     using type =
828         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
829     explicit constexpr RAW_STATUS(const char* a) :
830         _entry(entry("RAW_STATUS=%s", a)){};
831     type _entry;
832 };
833 
834 } // namespace _PowerSupplyOutputOvercurrent
835 
836 struct PowerSupplyOutputOvercurrent
837 {
838     static constexpr auto L = level::ERR;
839     using RAW_STATUS = _PowerSupplyOutputOvercurrent::RAW_STATUS;
840     using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout::
841         Inventory::CALLOUT_INVENTORY_PATH;
842     using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>;
843 };
844 
845 } // namespace Fault
846 } // namespace Witherspoon
847 } // namespace open_power
848 } // namespace org
849 
850 namespace details
851 {
852 
853 template <>
854 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault::
855                               Error::PowerSupplyOutputOvercurrent>
856 {
857     using type =
858         org::open_power::Witherspoon::Fault::PowerSupplyOutputOvercurrent;
859 };
860 
861 } // namespace details
862 
863 namespace org
864 {
865 namespace open_power
866 {
867 namespace Witherspoon
868 {
869 namespace Fault
870 {
871 namespace _PowerSupplyOutputOvervoltage
872 {
873 
874 struct RAW_STATUS
875 {
876     /*
877      * We can't use -fsanitize=undefined if we declare a
878      * 'static constexpr auto str' member, so don't. Instead, open-code the
879      * mako template lookups.
880      */
881     static constexpr auto str_short = "RAW_STATUS";
882     using type =
883         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
884     explicit constexpr RAW_STATUS(const char* a) :
885         _entry(entry("RAW_STATUS=%s", a)){};
886     type _entry;
887 };
888 
889 } // namespace _PowerSupplyOutputOvervoltage
890 
891 struct PowerSupplyOutputOvervoltage
892 {
893     static constexpr auto L = level::ERR;
894     using RAW_STATUS = _PowerSupplyOutputOvervoltage::RAW_STATUS;
895     using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout::
896         Inventory::CALLOUT_INVENTORY_PATH;
897     using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>;
898 };
899 
900 } // namespace Fault
901 } // namespace Witherspoon
902 } // namespace open_power
903 } // namespace org
904 
905 namespace details
906 {
907 
908 template <>
909 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault::
910                               Error::PowerSupplyOutputOvervoltage>
911 {
912     using type =
913         org::open_power::Witherspoon::Fault::PowerSupplyOutputOvervoltage;
914 };
915 
916 } // namespace details
917 
918 namespace org
919 {
920 namespace open_power
921 {
922 namespace Witherspoon
923 {
924 namespace Fault
925 {
926 namespace _PowerSupplyFanFault
927 {
928 
929 struct RAW_STATUS
930 {
931     /*
932      * We can't use -fsanitize=undefined if we declare a
933      * 'static constexpr auto str' member, so don't. Instead, open-code the
934      * mako template lookups.
935      */
936     static constexpr auto str_short = "RAW_STATUS";
937     using type =
938         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
939     explicit constexpr RAW_STATUS(const char* a) :
940         _entry(entry("RAW_STATUS=%s", a)){};
941     type _entry;
942 };
943 
944 } // namespace _PowerSupplyFanFault
945 
946 struct PowerSupplyFanFault
947 {
948     static constexpr auto L = level::ERR;
949     using RAW_STATUS = _PowerSupplyFanFault::RAW_STATUS;
950     using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout::
951         Inventory::CALLOUT_INVENTORY_PATH;
952     using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>;
953 };
954 
955 } // namespace Fault
956 } // namespace Witherspoon
957 } // namespace open_power
958 } // namespace org
959 
960 namespace details
961 {
962 
963 template <>
964 struct map_exception_type<
965     sdbusplus::org::open_power::Witherspoon::Fault::Error::PowerSupplyFanFault>
966 {
967     using type = org::open_power::Witherspoon::Fault::PowerSupplyFanFault;
968 };
969 
970 } // namespace details
971 
972 namespace org
973 {
974 namespace open_power
975 {
976 namespace Witherspoon
977 {
978 namespace Fault
979 {
980 namespace _PowerSupplyTemperatureFault
981 {
982 
983 struct RAW_STATUS
984 {
985     /*
986      * We can't use -fsanitize=undefined if we declare a
987      * 'static constexpr auto str' member, so don't. Instead, open-code the
988      * mako template lookups.
989      */
990     static constexpr auto str_short = "RAW_STATUS";
991     using type =
992         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
993     explicit constexpr RAW_STATUS(const char* a) :
994         _entry(entry("RAW_STATUS=%s", a)){};
995     type _entry;
996 };
997 
998 } // namespace _PowerSupplyTemperatureFault
999 
1000 struct PowerSupplyTemperatureFault
1001 {
1002     static constexpr auto L = level::ERR;
1003     using RAW_STATUS = _PowerSupplyTemperatureFault::RAW_STATUS;
1004     using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout::
1005         Inventory::CALLOUT_INVENTORY_PATH;
1006     using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>;
1007 };
1008 
1009 } // namespace Fault
1010 } // namespace Witherspoon
1011 } // namespace open_power
1012 } // namespace org
1013 
1014 namespace details
1015 {
1016 
1017 template <>
1018 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault::
1019                               Error::PowerSupplyTemperatureFault>
1020 {
1021     using type =
1022         org::open_power::Witherspoon::Fault::PowerSupplyTemperatureFault;
1023 };
1024 
1025 } // namespace details
1026 
1027 namespace org
1028 {
1029 namespace open_power
1030 {
1031 namespace Witherspoon
1032 {
1033 namespace Fault
1034 {
1035 namespace _Shutdown
1036 {} // namespace _Shutdown
1037 
1038 struct Shutdown
1039 {
1040     static constexpr auto L = level::ERR;
1041     using metadata_types = std::tuple<>;
1042 };
1043 
1044 } // namespace Fault
1045 } // namespace Witherspoon
1046 } // namespace open_power
1047 } // namespace org
1048 
1049 namespace details
1050 {
1051 
1052 template <>
1053 struct map_exception_type<
1054     sdbusplus::org::open_power::Witherspoon::Fault::Error::Shutdown>
1055 {
1056     using type = org::open_power::Witherspoon::Fault::Shutdown;
1057 };
1058 
1059 } // namespace details
1060 
1061 namespace org
1062 {
1063 namespace open_power
1064 {
1065 namespace Witherspoon
1066 {
1067 namespace Fault
1068 {
1069 namespace _PowerOnFailure
1070 {} // namespace _PowerOnFailure
1071 
1072 struct PowerOnFailure
1073 {
1074     static constexpr auto L = level::ERR;
1075     using metadata_types = std::tuple<>;
1076 };
1077 
1078 } // namespace Fault
1079 } // namespace Witherspoon
1080 } // namespace open_power
1081 } // namespace org
1082 
1083 namespace details
1084 {
1085 
1086 template <>
1087 struct map_exception_type<
1088     sdbusplus::org::open_power::Witherspoon::Fault::Error::PowerOnFailure>
1089 {
1090     using type = org::open_power::Witherspoon::Fault::PowerOnFailure;
1091 };
1092 
1093 } // namespace details
1094 
1095 namespace org
1096 {
1097 namespace open_power
1098 {
1099 namespace Witherspoon
1100 {
1101 namespace Fault
1102 {
1103 namespace _PowerSequencerVoltageFault
1104 {
1105 
1106 struct RAIL
1107 {
1108     /*
1109      * We can't use -fsanitize=undefined if we declare a
1110      * 'static constexpr auto str' member, so don't. Instead, open-code the
1111      * mako template lookups.
1112      */
1113     static constexpr auto str_short = "RAIL";
1114     using type = std::tuple<std::decay_t<decltype("RAIL=%d")>, uint16_t>;
1115     explicit constexpr RAIL(uint16_t a) : _entry(entry("RAIL=%d", a)){};
1116     type _entry;
1117 };
1118 struct RAIL_NAME
1119 {
1120     /*
1121      * We can't use -fsanitize=undefined if we declare a
1122      * 'static constexpr auto str' member, so don't. Instead, open-code the
1123      * mako template lookups.
1124      */
1125     static constexpr auto str_short = "RAIL_NAME";
1126     using type =
1127         std::tuple<std::decay_t<decltype("RAIL_NAME=%s")>, const char*>;
1128     explicit constexpr RAIL_NAME(const char* a) :
1129         _entry(entry("RAIL_NAME=%s", a)){};
1130     type _entry;
1131 };
1132 struct RAW_STATUS
1133 {
1134     /*
1135      * We can't use -fsanitize=undefined if we declare a
1136      * 'static constexpr auto str' member, so don't. Instead, open-code the
1137      * mako template lookups.
1138      */
1139     static constexpr auto str_short = "RAW_STATUS";
1140     using type =
1141         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
1142     explicit constexpr RAW_STATUS(const char* a) :
1143         _entry(entry("RAW_STATUS=%s", a)){};
1144     type _entry;
1145 };
1146 
1147 } // namespace _PowerSequencerVoltageFault
1148 
1149 struct PowerSequencerVoltageFault
1150 {
1151     static constexpr auto L = level::ERR;
1152     using RAIL = _PowerSequencerVoltageFault::RAIL;
1153     using RAIL_NAME = _PowerSequencerVoltageFault::RAIL_NAME;
1154     using RAW_STATUS = _PowerSequencerVoltageFault::RAW_STATUS;
1155     using metadata_types = std::tuple<RAIL, RAIL_NAME, RAW_STATUS>;
1156 };
1157 
1158 } // namespace Fault
1159 } // namespace Witherspoon
1160 } // namespace open_power
1161 } // namespace org
1162 
1163 namespace details
1164 {
1165 
1166 template <>
1167 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault::
1168                               Error::PowerSequencerVoltageFault>
1169 {
1170     using type =
1171         org::open_power::Witherspoon::Fault::PowerSequencerVoltageFault;
1172 };
1173 
1174 } // namespace details
1175 
1176 namespace org
1177 {
1178 namespace open_power
1179 {
1180 namespace Witherspoon
1181 {
1182 namespace Fault
1183 {
1184 namespace _PowerSequencerPGOODFault
1185 {
1186 
1187 struct INPUT_NUM
1188 {
1189     /*
1190      * We can't use -fsanitize=undefined if we declare a
1191      * 'static constexpr auto str' member, so don't. Instead, open-code the
1192      * mako template lookups.
1193      */
1194     static constexpr auto str_short = "INPUT_NUM";
1195     using type = std::tuple<std::decay_t<decltype("INPUT_NUM=%d")>, uint16_t>;
1196     explicit constexpr INPUT_NUM(uint16_t a) :
1197         _entry(entry("INPUT_NUM=%d", a)){};
1198     type _entry;
1199 };
1200 struct INPUT_NAME
1201 {
1202     /*
1203      * We can't use -fsanitize=undefined if we declare a
1204      * 'static constexpr auto str' member, so don't. Instead, open-code the
1205      * mako template lookups.
1206      */
1207     static constexpr auto str_short = "INPUT_NAME";
1208     using type =
1209         std::tuple<std::decay_t<decltype("INPUT_NAME=%s")>, const char*>;
1210     explicit constexpr INPUT_NAME(const char* a) :
1211         _entry(entry("INPUT_NAME=%s", a)){};
1212     type _entry;
1213 };
1214 struct RAW_STATUS
1215 {
1216     /*
1217      * We can't use -fsanitize=undefined if we declare a
1218      * 'static constexpr auto str' member, so don't. Instead, open-code the
1219      * mako template lookups.
1220      */
1221     static constexpr auto str_short = "RAW_STATUS";
1222     using type =
1223         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
1224     explicit constexpr RAW_STATUS(const char* a) :
1225         _entry(entry("RAW_STATUS=%s", a)){};
1226     type _entry;
1227 };
1228 
1229 } // namespace _PowerSequencerPGOODFault
1230 
1231 struct PowerSequencerPGOODFault
1232 {
1233     static constexpr auto L = level::ERR;
1234     using INPUT_NUM = _PowerSequencerPGOODFault::INPUT_NUM;
1235     using INPUT_NAME = _PowerSequencerPGOODFault::INPUT_NAME;
1236     using RAW_STATUS = _PowerSequencerPGOODFault::RAW_STATUS;
1237     using metadata_types = std::tuple<INPUT_NUM, INPUT_NAME, RAW_STATUS>;
1238 };
1239 
1240 } // namespace Fault
1241 } // namespace Witherspoon
1242 } // namespace open_power
1243 } // namespace org
1244 
1245 namespace details
1246 {
1247 
1248 template <>
1249 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault::
1250                               Error::PowerSequencerPGOODFault>
1251 {
1252     using type = org::open_power::Witherspoon::Fault::PowerSequencerPGOODFault;
1253 };
1254 
1255 } // namespace details
1256 
1257 namespace org
1258 {
1259 namespace open_power
1260 {
1261 namespace Witherspoon
1262 {
1263 namespace Fault
1264 {
1265 namespace _PowerSequencerFault
1266 {
1267 
1268 struct RAW_STATUS
1269 {
1270     /*
1271      * We can't use -fsanitize=undefined if we declare a
1272      * 'static constexpr auto str' member, so don't. Instead, open-code the
1273      * mako template lookups.
1274      */
1275     static constexpr auto str_short = "RAW_STATUS";
1276     using type =
1277         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
1278     explicit constexpr RAW_STATUS(const char* a) :
1279         _entry(entry("RAW_STATUS=%s", a)){};
1280     type _entry;
1281 };
1282 
1283 } // namespace _PowerSequencerFault
1284 
1285 struct PowerSequencerFault
1286 {
1287     static constexpr auto L = level::ERR;
1288     using RAW_STATUS = _PowerSequencerFault::RAW_STATUS;
1289     using metadata_types = std::tuple<RAW_STATUS>;
1290 };
1291 
1292 } // namespace Fault
1293 } // namespace Witherspoon
1294 } // namespace open_power
1295 } // namespace org
1296 
1297 namespace details
1298 {
1299 
1300 template <>
1301 struct map_exception_type<
1302     sdbusplus::org::open_power::Witherspoon::Fault::Error::PowerSequencerFault>
1303 {
1304     using type = org::open_power::Witherspoon::Fault::PowerSequencerFault;
1305 };
1306 
1307 } // namespace details
1308 
1309 namespace org
1310 {
1311 namespace open_power
1312 {
1313 namespace Witherspoon
1314 {
1315 namespace Fault
1316 {
1317 namespace _GPUPowerFault
1318 {
1319 
1320 struct RAW_STATUS
1321 {
1322     /*
1323      * We can't use -fsanitize=undefined if we declare a
1324      * 'static constexpr auto str' member, so don't. Instead, open-code the
1325      * mako template lookups.
1326      */
1327     static constexpr auto str_short = "RAW_STATUS";
1328     using type =
1329         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
1330     explicit constexpr RAW_STATUS(const char* a) :
1331         _entry(entry("RAW_STATUS=%s", a)){};
1332     type _entry;
1333 };
1334 
1335 } // namespace _GPUPowerFault
1336 
1337 struct GPUPowerFault
1338 {
1339     static constexpr auto L = level::ERR;
1340     using RAW_STATUS = _GPUPowerFault::RAW_STATUS;
1341     using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout::
1342         Inventory::CALLOUT_INVENTORY_PATH;
1343     using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>;
1344 };
1345 
1346 } // namespace Fault
1347 } // namespace Witherspoon
1348 } // namespace open_power
1349 } // namespace org
1350 
1351 namespace details
1352 {
1353 
1354 template <>
1355 struct map_exception_type<
1356     sdbusplus::org::open_power::Witherspoon::Fault::Error::GPUPowerFault>
1357 {
1358     using type = org::open_power::Witherspoon::Fault::GPUPowerFault;
1359 };
1360 
1361 } // namespace details
1362 
1363 namespace org
1364 {
1365 namespace open_power
1366 {
1367 namespace Witherspoon
1368 {
1369 namespace Fault
1370 {
1371 namespace _GPUOverTemp
1372 {
1373 
1374 struct RAW_STATUS
1375 {
1376     /*
1377      * We can't use -fsanitize=undefined if we declare a
1378      * 'static constexpr auto str' member, so don't. Instead, open-code the
1379      * mako template lookups.
1380      */
1381     static constexpr auto str_short = "RAW_STATUS";
1382     using type =
1383         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
1384     explicit constexpr RAW_STATUS(const char* a) :
1385         _entry(entry("RAW_STATUS=%s", a)){};
1386     type _entry;
1387 };
1388 
1389 } // namespace _GPUOverTemp
1390 
1391 struct GPUOverTemp
1392 {
1393     static constexpr auto L = level::ERR;
1394     using RAW_STATUS = _GPUOverTemp::RAW_STATUS;
1395     using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout::
1396         Inventory::CALLOUT_INVENTORY_PATH;
1397     using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>;
1398 };
1399 
1400 } // namespace Fault
1401 } // namespace Witherspoon
1402 } // namespace open_power
1403 } // namespace org
1404 
1405 namespace details
1406 {
1407 
1408 template <>
1409 struct map_exception_type<
1410     sdbusplus::org::open_power::Witherspoon::Fault::Error::GPUOverTemp>
1411 {
1412     using type = org::open_power::Witherspoon::Fault::GPUOverTemp;
1413 };
1414 
1415 } // namespace details
1416 
1417 namespace org
1418 {
1419 namespace open_power
1420 {
1421 namespace Witherspoon
1422 {
1423 namespace Fault
1424 {
1425 namespace _MemoryPowerFault
1426 {
1427 
1428 struct RAW_STATUS
1429 {
1430     /*
1431      * We can't use -fsanitize=undefined if we declare a
1432      * 'static constexpr auto str' member, so don't. Instead, open-code the
1433      * mako template lookups.
1434      */
1435     static constexpr auto str_short = "RAW_STATUS";
1436     using type =
1437         std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>;
1438     explicit constexpr RAW_STATUS(const char* a) :
1439         _entry(entry("RAW_STATUS=%s", a)){};
1440     type _entry;
1441 };
1442 
1443 } // namespace _MemoryPowerFault
1444 
1445 struct MemoryPowerFault
1446 {
1447     static constexpr auto L = level::ERR;
1448     using RAW_STATUS = _MemoryPowerFault::RAW_STATUS;
1449     using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout::
1450         Inventory::CALLOUT_INVENTORY_PATH;
1451     using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>;
1452 };
1453 
1454 } // namespace Fault
1455 } // namespace Witherspoon
1456 } // namespace open_power
1457 } // namespace org
1458 
1459 namespace details
1460 {
1461 
1462 template <>
1463 struct map_exception_type<
1464     sdbusplus::org::open_power::Witherspoon::Fault::Error::MemoryPowerFault>
1465 {
1466     using type = org::open_power::Witherspoon::Fault::MemoryPowerFault;
1467 };
1468 
1469 } // namespace details
1470 
1471 } // namespace logging
1472 
1473 } // namespace phosphor
1474