1 /** 2 * Copyright © 2019 IBM Corporation 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 #pragma once 17 18 #include "action.hpp" 19 #include "action_environment.hpp" 20 #include "action_utils.hpp" 21 22 #include <memory> 23 #include <string> 24 #include <utility> 25 #include <vector> 26 27 namespace phosphor::power::regulators 28 { 29 30 /** 31 * @class Rule 32 * 33 * A rule is a sequence of actions that can be shared by multiple voltage 34 * regulators. 35 * 36 * Rules define a standard way to perform an operation. For example, the 37 * following action sequences might be sharable using a rule: 38 * - Actions that set the output voltage of a regulator rail 39 * - Actions that read all the sensors of a regulator rail 40 * - Actions that detect down-level hardware using version registers 41 */ 42 class Rule 43 { 44 public: 45 // Specify which compiler-generated methods we want 46 Rule() = delete; 47 Rule(const Rule&) = delete; 48 Rule(Rule&&) = delete; 49 Rule& operator=(const Rule&) = delete; 50 Rule& operator=(Rule&&) = delete; 51 ~Rule() = default; 52 53 /** 54 * Constructor. 55 * 56 * @param id unique rule ID 57 * @param actions actions in the rule 58 */ Rule(const std::string & id,std::vector<std::unique_ptr<Action>> actions)59 explicit Rule(const std::string& id, 60 std::vector<std::unique_ptr<Action>> actions) : 61 id{id}, actions{std::move(actions)} 62 {} 63 64 /** 65 * Executes the actions in this rule. 66 * 67 * Returns the return value from the last action. 68 * 69 * Throws an exception if an error occurs and an action cannot be 70 * successfully executed. 71 * 72 * @param environment action execution environment 73 * @return return value from last action in rule 74 */ execute(ActionEnvironment & environment)75 bool execute(ActionEnvironment& environment) 76 { 77 return action_utils::execute(actions, environment); 78 } 79 80 /** 81 * Returns the actions in this rule. 82 * 83 * @return actions in rule 84 */ getActions() const85 const std::vector<std::unique_ptr<Action>>& getActions() const 86 { 87 return actions; 88 } 89 90 /** 91 * Returns the unique ID of this rule. 92 * 93 * @return rule ID 94 */ getID() const95 const std::string& getID() const 96 { 97 return id; 98 } 99 100 private: 101 /** 102 * Unique ID of this rule. 103 */ 104 const std::string id{}; 105 106 /** 107 * Actions in this rule. 108 */ 109 std::vector<std::unique_ptr<Action>> actions{}; 110 }; 111 112 } // namespace phosphor::power::regulators 113