otsdaq  v2_04_01
IterateTable_table.cc
1 #include "otsdaq-core/ConfigurationInterface/ConfigurationManager.h"
2 #include "otsdaq-core/Macros/TablePluginMacros.h"
3 #include "otsdaq-core/TablePlugins/IterateTable.h"
4 
5 #include <iostream>
6 #include <string>
7 
8 using namespace ots;
9 
10 // instantiate static members
11 
12 const std::string IterateTable::COMMAND_BEGIN_LABEL = "BEGIN_LABEL";
13 const std::string IterateTable::COMMAND_CHOOSE_FSM = "CHOOSE_FSM";
14 const std::string IterateTable::COMMAND_CONFIGURE_ACTIVE_GROUP = "CONFIGURE_ACTIVE_GROUP";
15 const std::string IterateTable::COMMAND_CONFIGURE_ALIAS = "CONFIGURE_ALIAS";
16 const std::string IterateTable::COMMAND_CONFIGURE_GROUP = "CONFIGURE_GROUP";
17 const std::string IterateTable::COMMAND_EXECUTE_FE_MACRO = "EXECUTE_FE_MACRO";
18 const std::string IterateTable::COMMAND_EXECUTE_MACRO = "EXECUTE_MACRO";
19 const std::string IterateTable::COMMAND_MODIFY_ACTIVE_GROUP = "MODIFY_ACTIVE_GROUP";
20 const std::string IterateTable::COMMAND_REPEAT_LABEL = "REPEAT_LABEL";
21 const std::string IterateTable::COMMAND_RUN = "RUN";
22 
23 const std::string IterateTable::ITERATE_TABLE = "IterateTable";
24 const std::string IterateTable::PLAN_TABLE = "IterationPlanTable";
25 const std::string IterateTable::TARGET_TABLE = "IterationTargetTable";
26 
27 const std::map<std::string, std::string> IterateTable::commandToTableMap_ =
28  IterateTable::createCommandToTableMap();
29 
30 IterateTable::PlanTableColumns IterateTable::planTableCols_;
31 IterateTable::IterateTableColumns IterateTable::iterateTableCols_;
32 
33 IterateTable::CommandBeginLabelParams IterateTable::commandBeginLabelParams_;
34 IterateTable::CommandConfigureActiveParams IterateTable::commandConfigureActiveParams_;
35 IterateTable::CommandConfigureAliasParams IterateTable::commandConfigureAliasParams_;
36 IterateTable::CommandConfigureGroupParams IterateTable::commandConfigureGroupParams_;
37 IterateTable::CommandExecuteMacroParams IterateTable::commandExecuteMacroParams_;
38 IterateTable::CommandModifyActiveParams IterateTable::commandModifyActiveParams_;
39 IterateTable::CommandRepeatLabelParams IterateTable::commandRepeatLabelParams_;
40 IterateTable::CommandRunParams IterateTable::commandRunParams_;
41 IterateTable::CommandChooseFSMParams IterateTable::commandChooseFSMParams_;
42 
43 IterateTable::TargetParams IterateTable::targetParams_;
44 IterateTable::TargetTableColumns IterateTable::targetCols_;
45 IterateTable::CommandTargetColumns IterateTable::commandTargetCols_;
46 
47 IterateTable::MacroDimLoopTableColumns IterateTable::macroDimLoopCols_;
48 IterateTable::MacroParamTableColumns IterateTable::macroParamCols_;
49 
50 //==============================================================================
51 IterateTable::IterateTable(void) : TableBase(IterateTable::ITERATE_TABLE) {}
52 
53 //==============================================================================
54 IterateTable::~IterateTable(void) {}
55 
56 //==============================================================================
57 void IterateTable::init(ConfigurationManager* configManager)
58 {
59  // do something to validate or refactor table
60  // __COUT__ << "*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*" << std::endl;
61  // __COUT__ << configManager->__SELF_NODE__ << std::endl;
62 
63  std::string value;
64  auto childrenMap = configManager->__SELF_NODE__.getChildren();
65  for(auto& childPair : childrenMap)
66  {
67  // do something for each row in table
68  //__COUT__ << childPair.first << std::endl;
69  // __COUT__ << childPair.second.getNode(colNames_.colColumnName_) <<
70  // std::endl; childPair.second.getNode(colNames_.colColumnName_
71  // ).getValue(value);
72  }
73 }
74 
75 //==============================================================================
76 std::vector<IterateTable::Command> IterateTable::getPlanCommands(
77  ConfigurationManager* configManager, const std::string& plan) const
78 {
79  __COUT__ << configManager->__SELF_NODE__ << std::endl;
80 
81  ConfigurationTree planNode = configManager->__SELF_NODE__.getNode(plan);
82 
83  if(!planNode.getNode(IterateTable::planTableCols_.Status_).getValue<bool>())
84  {
85  __SS__ << "Error! Attempt to access disabled plan (Status=FALSE)." << std::endl;
86  __COUT_ERR__ << ss.str();
87  __SS_THROW__;
88  }
89 
90  std::vector<IterateTable::Command> commands;
91 
92  auto commandChildren =
93  planNode.getNode(IterateTable::iterateTableCols_.PlanLink_).getChildren();
94 
95  for(auto& commandChild : commandChildren)
96  {
97  __COUT__ << "Command \t" << commandChild.first << std::endl;
98 
99  __COUT__ << "\t\tStatus \t"
100  << commandChild.second.getNode(IterateTable::planTableCols_.Status_)
101  << std::endl;
102 
103  __COUT__ << "\t\tType \t"
104  << commandChild.second.getNode(IterateTable::planTableCols_.CommandType_)
105  << std::endl;
106 
107  if(!commandChild.second.getNode(IterateTable::planTableCols_.Status_)
108  .getValue<bool>())
109  continue; // skip disabled commands
110 
111  commands.push_back(IterateTable::Command());
112  commands.back().type_ =
113  commandChild.second.getNode(IterateTable::planTableCols_.CommandType_)
114  .getValue<std::string>();
115 
116  if(commandChild.second.getNode(IterateTable::planTableCols_.CommandLink_)
117  .isDisconnected())
118  continue; // skip if no command parameters
119 
120  auto commandSpecificFields =
121  commandChild.second.getNode(IterateTable::planTableCols_.CommandLink_)
122  .getChildren();
123 
124  for(unsigned int i = 0; i < commandSpecificFields.size() - 3;
125  ++i) // ignore last three columns
126  {
127  // NOTE -- that links turn into one field with value LinkID/GroupID unless
128  // specially handled
129 
130  __COUT__ << "\t\tParameter \t" << commandSpecificFields[i].first << " = \t"
131  << commandSpecificFields[i].second << std::endl;
132 
133  if(commandSpecificFields[i].first ==
134  IterateTable::commandTargetCols_.TargetsLink_)
135  {
136  __COUT__ << "Extracting targets..." << __E__;
137  auto targets = commandSpecificFields[i].second.getChildren();
138 
139  __COUTV__(targets.size());
140 
141  for(auto& target : targets)
142  {
143  __COUT__ << "\t\t\tTarget \t" << target.first << __E__;
144 
145  ConfigurationTree targetNode =
146  target.second.getNode(IterateTable::targetCols_.TargetLink_);
147  if(targetNode.isDisconnected())
148  {
149  __COUT_ERR__ << "Disconnected target!?" << __E__;
150  continue;
151  }
152 
153  __COUT__ << "\t\t = \t"
154  << "Table:" << targetNode.getTableName()
155  << " UID:" << targetNode.getUIDAsString() << std::endl;
156  commands.back().addTarget();
157  commands.back().targets_.back().table_ = targetNode.getTableName();
158  commands.back().targets_.back().UID_ = targetNode.getUIDAsString();
159  }
160  }
161  else if(commandSpecificFields[i].first ==
162  IterateTable::commandExecuteMacroParams_.MacroParameterLink_)
163  {
164  // get Macro parameters, place them in params_
165  __COUT__ << "Extracting macro parameters..." << __E__;
166 
167  // need to extract input arguments
168  // by dimension (by priority)
169  //
170  // two vector by dimension <map of params>
171  // one vector for long and for double
172  //
173  // map of params :=
174  // name => {
175  // <long/double current value>
176  // <long/double init value>
177  // <long/double step size>
178  // }
179 
180  auto dimensionalLoops = commandSpecificFields[i].second.getChildren(
181  std::map<std::string /*relative-path*/,
182  std::string /*value*/>() /*no filter*/,
183  true /*by Priority*/);
184 
185  __COUTV__(dimensionalLoops.size());
186 
187  // inputs:
188  // - inputArgs: dimensional semi-colon-separated,
189  // comma separated: dimension iterations and arguments
190  //(colon-separated name/value/stepsize sets)
191  std::string argStr = "";
192  // inputArgsStr = "3;3,myOtherArg:5:2"; //example
193 
194  // std::string name, value;
195  unsigned long numberOfIterations;
196  bool firstDimension = true;
197 
198  for(auto& dimensionalLoop : dimensionalLoops)
199  {
200  __COUT__ << "\t\t\tDimensionalLoop \t" << dimensionalLoop.first
201  << __E__;
202 
203  numberOfIterations =
204  dimensionalLoop.second
205  .getNode(IterateTable::macroDimLoopCols_.NumberOfIterations_)
206  .getValue<unsigned long>();
207 
208  __COUTV__(numberOfIterations);
209 
210  if(numberOfIterations == 0)
211  {
212  __SS__ << "Illegal number of iterations value of '"
213  << numberOfIterations << ".' Must be a positive integer!"
214  << __E__;
215  __SS_THROW__;
216  }
217 
218  // at this point add dimension parameter with value numberOfIterations
219 
220  if(!firstDimension)
221  argStr += ";";
222  firstDimension = false;
223  argStr += std::to_string(numberOfIterations);
224 
225  auto paramLinkNode = dimensionalLoop.second.getNode(
226  IterateTable::macroDimLoopCols_.ParamLink_);
227 
228  if(paramLinkNode.isDisconnected())
229  {
230  __COUT__ << "Disconnected parameter link, so no parameters for "
231  "this dimension."
232  << __E__;
233  continue;
234  }
235 
236  auto macroParams = paramLinkNode.getChildren();
237 
238  __COUTV__(macroParams.size());
239 
240  for(auto& macroParam : macroParams)
241  {
242  __COUT__ << "\t\t\tParam \t" << macroParam.first << __E__;
243 
244  // add parameter name:value:step
245 
246  argStr += ",";
247  argStr +=
248  macroParam.second.getNode(IterateTable::macroParamCols_.Name_)
249  .getValue<std::string>();
250  argStr += ":";
251  argStr += macroParam.second
252  .getNode(IterateTable::macroParamCols_.Value_)
253  .getValue<std::string>();
254  argStr += ":";
255  argStr +=
256  macroParam.second.getNode(IterateTable::macroParamCols_.Step_)
257  .getValue<std::string>();
258 
259  } // end parameter loop
260  } // end dimension loop
261 
262  // Macro argument string is done
263  __COUTV__(argStr);
264 
265  // assume no conflict with fixed parameters in map
266  // because of prepend
267  // IterateTable::commandExecuteMacroParams_.MacroParameterPrepend_
268  //+
269  commands.back().params_.emplace(
270  std::pair<std::string /*param name*/, std::string /*param value*/>(
271  IterateTable::commandExecuteMacroParams_.MacroArgumentString_,
272  argStr));
273  }
274  else // all other non-special fields
275  {
276  if( // bool type, convert to 1 or 0
277  commandSpecificFields[i].second.isValueBoolType())
278  commands.back().params_.emplace(
279  std::pair<std::string /*param name*/,
280  std::string /*param value*/>(
281  commandSpecificFields[i].first,
282  commandSpecificFields[i].second.getValue<bool>() ? "1"
283  : "0"));
284  else if( // number data type, get raw value string (note: does not do
285  // math or variable substitution)
286  commandSpecificFields[i].second.isValueNumberDataType())
287  commands.back().params_.emplace(
288  std::pair<std::string /*param name*/,
289  std::string /*param value*/>(
290  commandSpecificFields[i].first,
291  commandSpecificFields[i].second.getValueAsString()));
292  else
293  commands.back().params_.emplace(
294  std::pair<std::string /*param name*/,
295  std::string /*param value*/>(
296  commandSpecificFields[i].first,
297  commandSpecificFields[i].second.getValue<std::string>()));
298  }
299  }
300  }
301 
302  return commands;
303 }
304 
305 DEFINE_OTS_TABLE(IterateTable)