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 <map>
19 #include <stdexcept>
20 #include <string>
21 
22 namespace phosphor::power::regulators
23 {
24 
25 // Forward declarations to avoid circular dependencies
26 class Device;
27 class Rail;
28 class Rule;
29 
30 /**
31  * @class IDMap
32  *
33  * This class provides a mapping from string IDs to the associated Device, Rail,
34  * and Rule objects.
35  */
36 class IDMap
37 {
38   public:
39     // Specify which compiler-generated methods we want
40     IDMap() = default;
41     IDMap(const IDMap&) = delete;
42     IDMap(IDMap&&) = delete;
43     IDMap& operator=(const IDMap&) = delete;
44     IDMap& operator=(IDMap&&) = delete;
45     ~IDMap() = default;
46 
47     /**
48      * Adds the specified device to this IDMap.
49      *
50      * Throws invalid_argument if the device's ID already exists in the map.
51      *
52      * @param device device to add
53      */
54     void addDevice(Device& device);
55 
56     /**
57      * Adds the specified rail to this IDMap.
58      *
59      * Throws invalid_argument if the rail's ID already exists in the map.
60      *
61      * @param rail rail to add
62      */
63     void addRail(Rail& rail);
64 
65     /**
66      * Adds the specified rule to this IDMap.
67      *
68      * Throws invalid_argument if the rule's ID already exists in the map.
69      *
70      * @param rule rule to add
71      */
72     void addRule(Rule& rule);
73 
74     /**
75      * Returns the device with the specified ID.
76      *
77      * Throws invalid_argument if no device is found with specified ID.
78      *
79      * @param id device ID
80      * @return device with specified ID
81      */
getDevice(const std::string & id) const82     Device& getDevice(const std::string& id) const
83     {
84         auto it = deviceMap.find(id);
85         if (it == deviceMap.end())
86         {
87             throw std::invalid_argument{
88                 "Unable to find device with ID \"" + id + '"'};
89         }
90         return *(it->second);
91     }
92 
93     /**
94      * Returns the rail with the specified ID.
95      *
96      * Throws invalid_argument if no rail is found with specified ID.
97      *
98      * @param id rail ID
99      * @return rail with specified ID
100      */
getRail(const std::string & id) const101     Rail& getRail(const std::string& id) const
102     {
103         auto it = railMap.find(id);
104         if (it == railMap.end())
105         {
106             throw std::invalid_argument{
107                 "Unable to find rail with ID \"" + id + '"'};
108         }
109         return *(it->second);
110     }
111 
112     /**
113      * Returns the rule with the specified ID.
114      *
115      * Throws invalid_argument if no rule is found with specified ID.
116      *
117      * @param id rule ID
118      * @return rule with specified ID
119      */
getRule(const std::string & id) const120     Rule& getRule(const std::string& id) const
121     {
122         auto it = ruleMap.find(id);
123         if (it == ruleMap.end())
124         {
125             throw std::invalid_argument{
126                 "Unable to find rule with ID \"" + id + '"'};
127         }
128         return *(it->second);
129     }
130 
131   private:
132     /**
133      * Map from device IDs to Device objects.  Does not own the objects.
134      */
135     std::map<std::string, Device*> deviceMap{};
136 
137     /**
138      * Map from rail IDs to Rail objects.  Does not own the objects.
139      */
140     std::map<std::string, Rail*> railMap{};
141 
142     /**
143      * Map from rule IDs to Rule objects.  Does not own the objects.
144      */
145     std::map<std::string, Rule*> ruleMap{};
146 };
147 
148 } // namespace phosphor::power::regulators
149