1 <%include file="defs.mako"/>\
2 <%namespace file="defs.mako" import="*"/>\
3 <%!
4 def indent(str, depth):
5     return ''.join(4*' '*depth+line for line in str.splitlines(True))
6 %>\
7 /* This is a generated file. */
8 #include "manager.hpp"
9 #include "functor.hpp"
10 #include "actions.hpp"
11 #include "handlers.hpp"
12 #include "preconditions.hpp"
13 #include "matches.hpp"
14 #include "triggers.hpp"
15 
16 using namespace phosphor::fan::control;
17 
18 const unsigned int Manager::_powerOnDelay{${mgr_data['power_on_delay']}};
19 
20 const std::vector<ZoneGroup> Manager::_zoneLayouts
21 {
22 %for zone_group in zones:
23     ZoneGroup{
24         std::vector<Condition>{
25         %for condition in zone_group['conditions']:
26             Condition{
27                 "${condition['type']}",
28                 std::vector<ConditionProperty>{
29                 %for property in condition['properties']:
30                     ConditionProperty{
31                         "${property['property']}",
32                         "${property['interface']}",
33                         "${property['path']}",
34                         static_cast<${property['type']}>(${property['value']}),
35                     },
36                     %endfor
37                 },
38             },
39             %endfor
40         },
41         std::vector<ZoneDefinition>{
42         %for zone in zone_group['zones']:
43             ZoneDefinition{
44                 ${zone['num']},
45                 ${zone['full_speed']},
46                 ${zone['default_floor']},
47                 ${zone['increase_delay']},
48                 ${zone['decrease_interval']},
49                 std::vector<ZoneHandler>{
50                     %if ('ifaces' in zone) and \
51                         (zone['ifaces'] is not None):
52                         %for i in zone['ifaces']:
53                             %if ('props' in i) and \
54                                 (i['props'] is not None):
55                                 %for p in i['props']:
56                     ZoneHandler{
57                         make_zoneHandler(handler::setZoneProperty(
58                             "${i['name']}",
59                             "${p['name']}",
60                             &Zone::${p['func']},
61                             static_cast<${p['type']}>(
62                                 %if "vector" in p['type'] or "map" in p['type']:
63                                 ${p['type']}{
64                                 %endif
65                                 %for j, v in enumerate(p['values']):
66                                 %if (j+1) != len(p['values']):
67                                     ${v},
68                                 %else:
69                                     ${v}
70                                 %endif
71                                 %endfor
72                                 %if "vector" in p['type'] or "map" in p['type']:
73                                 }
74                                 %endif
75                             ),
76                             ${p['persist']}
77                         ))
78                     },
79                                 %endfor
80                             %endif
81                         %endfor
82                     %endif
83                 },
84                 std::vector<FanDefinition>{
85                 %for fan in zone['fans']:
86                     FanDefinition{
87                         "${fan['name']}",
88                         std::vector<std::string>{
89                         %for sensor in fan['sensors']:
90                             "${sensor}",
91                         %endfor
92                         },
93                         "${fan['target_interface']}"
94                     },
95                 %endfor
96                 },
97                 std::vector<SetSpeedEvent>{
98                 %for event in zone['events']:
99                     %if ('pc' in event) and \
100                         (event['pc'] is not None):
101                     SetSpeedEvent{
102                         "${event['pc']['pcname']}",
103                         Group
104                         {
105                         %for group in event['pc']['pcgrps']:
106                         %for member in group['members']:
107                             {"${member['object']}",
108                             "${member['interface']}",
109                             "${member['property']}"},
110                         %endfor
111                         %endfor
112                         },
113                         ActionData{
114                         {Group{},
115                         std::vector<Action>{
116                         %for i, a in enumerate(event['pc']['pcact']):
117                         make_action(
118                             precondition::${a['name']}(
119                         %for p in a['params']:
120                         ${p['type']}${p['open']}
121                         %for j, v in enumerate(p['values']):
122                         %if (j+1) != len(p['values']):
123                             ${v['value']},
124                         %else:
125                             ${v['value']}
126                         %endif
127                         %endfor
128                         ${p['close']},
129                         %endfor
130                         %endfor
131                     std::vector<SetSpeedEvent>{
132                     %for pcevt in event['pc']['pcevts']:
133                     SetSpeedEvent{
134                         "${pcevt['name']}",\
135                     ${indent(genSSE(event=pcevt), 6)}\
136                     },
137                     %endfor
138                     %else:
139                     SetSpeedEvent{
140                         "${event['name']}",\
141                     ${indent(genSSE(event=event), 6)}
142                     %endif
143                     %if ('pc' in event) and (event['pc'] is not None):
144                     }
145                         )),
146                         }},
147                         },
148                         std::vector<Trigger>{
149                             %if ('timer' in event['pc']['triggers']) and \
150                                 (event['pc']['triggers']['timer'] is not None):
151                             make_trigger(trigger::timer(TimerConf{
152                             ${event['pc']['triggers']['pctime']['interval']},
153                             ${event['pc']['triggers']['pctime']['type']}
154                             })),
155                             %endif
156                             %if ('pcsigs' in event['pc']['triggers']) and \
157                                 (event['pc']['triggers']['pcsigs'] is not None):
158                             %for s in event['pc']['triggers']['pcsigs']:
159                             make_trigger(trigger::signal(
160                                 %if ('match' in s) and \
161                                     (s['match'] is not None):
162                                 match::${s['match']}(
163                                 %for i, mp in enumerate(s['mparams']['params']):
164                                 %if (i+1) != len(s['mparams']['params']):
165                                 ${indent(s['mparams'][mp], 1)},
166                                 %else:
167                                 ${indent(s['mparams'][mp], 1)}
168                                 %endif
169                                 %endfor
170                                 ),
171                                 %else:
172                                 "",
173                                 %endif
174                                 make_handler<SignalHandler>(\
175                                 ${indent(genSignal(sig=s), 9)}\
176                                 )
177                             )),
178                             %endfor
179                             %endif
180                             %if ('init' in event['pc']['triggers']):
181                             %for i in event['pc']['triggers']['init']:
182                             make_trigger(trigger::init(
183                                 %if ('method' in i):
184                                 make_handler<MethodHandler>(\
185                                 ${indent(genMethod(meth=i), 3)}\
186                                 )
187                                 %endif
188                             )),
189                             %endfor
190                             %endif
191                         },
192                     %endif
193                     },
194                 %endfor
195                 }
196             },
197         %endfor
198         }
199     },
200 %endfor
201 };
202