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      */
59     explicit Rule(const std::string& id,
60                   std::vector<std::unique_ptr<Action>> actions) :
61         id{id},
62         actions{std::move(actions)}
63     {}
64 
65     /**
66      * Executes the actions in this rule.
67      *
68      * Returns the return value from the last action.
69      *
70      * Throws an exception if an error occurs and an action cannot be
71      * successfully executed.
72      *
73      * @param environment action execution environment
74      * @return return value from last action in rule
75      */
76     bool execute(ActionEnvironment& environment)
77     {
78         return action_utils::execute(actions, environment);
79     }
80 
81     /**
82      * Returns the actions in this rule.
83      *
84      * @return actions in rule
85      */
86     const std::vector<std::unique_ptr<Action>>& getActions() const
87     {
88         return actions;
89     }
90 
91     /**
92      * Returns the unique ID of this rule.
93      *
94      * @return rule ID
95      */
96     const std::string& getID() const
97     {
98         return id;
99     }
100 
101   private:
102     /**
103      * Unique ID of this rule.
104      */
105     const std::string id{};
106 
107     /**
108      * Actions in this rule.
109      */
110     std::vector<std::unique_ptr<Action>> actions{};
111 };
112 
113 } // namespace phosphor::power::regulators
114