GCC Code Coverage Report


Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 100.0% 2 / 0 / 2
Functions: 100.0% 2 / 0 / 2
Branches: -% 0 / 0 / 0

src/utilities/idf/WorkspaceObjectOrder.hpp
Line Branch Exec Source
1 /***********************************************************************************************************************
2 * OpenStudio(R), Copyright (c) Alliance for Energy Innovation, LLC.
3 * See also https://openstudio.net/license
4 ***********************************************************************************************************************/
5
6 #ifndef UTILITIES_IDF_WORKSPACEOBJECTORDER_HPP
7 #define UTILITIES_IDF_WORKSPACEOBJECTORDER_HPP
8
9 #include "../UtilitiesAPI.hpp"
10
11 #include "Handle.hpp"
12 #include "WorkspaceObject.hpp"
13 #include "ObjectOrderBase.hpp"
14
15 #include <optional>
16
17 namespace openstudio {
18
19 struct IddObjectType;
20
21 namespace detail {
22
23 class Workspace_Impl; // forward declaration
24
25 /** Implementation of WorkspaceObjectOrder. */
26 class UTILITIES_API WorkspaceObjectOrder_Impl : public ObjectOrderBase
27 {
28 public:
29 using ObjectGetter = std::function<boost::optional<WorkspaceObject>(const Handle&)>;
30
31 WorkspaceObjectOrder_Impl(const ObjectGetter& objectGetter);
32
33 WorkspaceObjectOrder_Impl(const std::vector<Handle>& directOrder, const ObjectGetter& objectGetter);
34
35 WorkspaceObjectOrder_Impl(const std::vector<IddObjectType>& iddOrder, const ObjectGetter& objectGetter);
36
37 17936 virtual ~WorkspaceObjectOrder_Impl() override = default;
38
39 // GETTERS AND SETTERS
40
41 /// Returns whether or not direct ordered. Otherwise, is ordered by IddObjectType.
42 bool isDirectOrder() const;
43 /// returns the direct order. return value is false if not ordering this way.
44 boost::optional<std::vector<Handle>> directOrder() const;
45 /// deletes other ordering options and sets direct order
46 void setDirectOrder(const std::vector<Handle>& order);
47 /// returns false if not ordering directly
48 bool push_back(const Handle& handle);
49 /// returns false if not ordering directly
50 bool insert(const Handle& handle, const Handle& insertBeforeHandle);
51 /// returns false if not ordering directly
52 bool insert(const Handle& handle, unsigned index);
53 /// returns false if not ordering directly, or request is otherwise invalid
54 bool move(const Handle& handle, const Handle& insertBeforeHandle);
55 /// returns false if not ordering directly, or request is otherwise invalid
56 bool move(const Handle& handle, unsigned index);
57 /// returns false if not ordering directly, or request is otherwise invalid
58 bool swap(const Handle& handle1, const Handle& handle2);
59 /// returns false if not ordering directly, or request is otherwise invalid
60 bool erase(const Handle& handle);
61
62 /// deletes other ordering options and orders by IddObjectType
63 virtual void setOrderByIddEnum() override;
64 /// deletes other ordering options and sets IddObjectType order
65 virtual void setIddOrder(const std::vector<IddObjectType>& order) override;
66
67 // SORTING
68
69 /** Predicate for external sorters (for instance, std::set). */
70 bool less(const Handle& left, const Handle& right) const;
71
72 /** Predicate for external sorters (for instance, std::set). */
73 bool less(const WorkspaceObject& left, const WorkspaceObject& right) const;
74
75 /** Predicate for external sorters (for instance, std::set). */
76 bool less(IddObjectType left, IddObjectType right) const override;
77
78 std::vector<Handle> sort(const std::vector<Handle>& handles) const;
79
80 std::vector<openstudio::WorkspaceObject> sort(const std::vector<openstudio::WorkspaceObject>& objects) const;
81
82 /// returns empty vector if not all handles can be converted to objects
83 std::vector<WorkspaceObject> sortedObjects(const std::vector<Handle>& handles) const;
84
85 /// returns empty vector if not all objects can be converted to handles
86 std::vector<Handle> sortedHandles(const std::vector<WorkspaceObject>& objects) const;
87
88 // STATE CHECKING
89
90 /** Returns whether order of handle is directly specified. */
91 bool inOrder(const Handle& handle) const;
92
93 /** Returns index of handle in order, if its order is directly specified. */
94 boost::optional<unsigned> indexInOrder(const Handle& handle) const;
95
96 protected:
97 friend class Workspace_Impl;
98
99 void setObjectGetter(const ObjectGetter& getter);
100
101 private:
102 ObjectGetter m_objectGetter;
103 boost::optional<std::vector<Handle>> m_directOrder;
104
105 REGISTER_LOGGER("utilities.idf.WorkspaceObjectOrder");
106
107 // HELPER FUNCTIONS
108
109 // only call when m_directOrder == true
110 std::vector<Handle>::iterator getIterator(const Handle& handle);
111 std::vector<Handle>::iterator getIterator(IddObjectType type);
112 std::vector<Handle>::iterator getIterator(const WorkspaceObject& object);
113
114 std::vector<Handle>::const_iterator getIterator(const Handle& handle) const;
115 std::vector<Handle>::const_iterator getIterator(IddObjectType type) const;
116 std::vector<Handle>::const_iterator getIterator(const WorkspaceObject& object) const;
117
118 boost::optional<IddObjectType> getIddObjectType(const Handle& handle) const;
119
120 // returns empty vector if can't convert all.
121 WorkspaceObjectVector getObjects(const std::vector<Handle>& handles) const;
122 };
123
124 using WorkspaceObjectOrder_ImplPtr = std::shared_ptr<WorkspaceObjectOrder_Impl>;
125 } // namespace detail
126
127 class Workspace; // forward declaration
128
129 /** Public interface of WorkspaceObjectOrder. Accessed through Workspace as in:
130 *
131 * \code
132 * Workspace ws;
133 * WorkspaceObjectOrder orderer = workspace.order();
134 * \endcode
135 *
136 * This interface is provided to let users specify the order in which objects and
137 * handles are returned by Workspace. Sorting is accessed through the workspace itself.
138 * For instance,
139 *
140 * \code
141 * ws.objects(true)
142 * \endcode */
143 class UTILITIES_API WorkspaceObjectOrder
144 {
145 public:
146 66067 virtual ~WorkspaceObjectOrder() = default;
147
148 // GETTERS AND SETTERS
149
150 /// returns whether or not currently ordering by IddObjectType
151 bool orderByIddEnum() const;
152 /// deletes other ordering options and orders by IddObjectType
153 void setOrderByIddEnum();
154
155 /** returns the user-specified order of IddObjectTypes. return value is false if
156 * not ordering this way. */
157 boost::optional<std::vector<IddObjectType>> iddOrder() const;
158 /// deletes other ordering options and sets IddObjectType order
159 void setIddOrder(const std::vector<IddObjectType>& order);
160 /** returns false if not ordering by user-specified IddObjectType order, or request is
161 * otherwise invalid. */
162 bool push_back(IddObjectType type);
163 /** returns false if not ordering by user-specified IddObjectType order. */
164 bool insert(IddObjectType type, IddObjectType insertBeforeType);
165 /** returns false if not ordering by user-specified IddObjectType order. */
166 bool insert(IddObjectType type, unsigned index);
167 /** move type from current location and place before 'insertBeforeType'. returns
168 * false if not ordering by user-specified IddObjectType order, or request is otherwise
169 * invalid. type must already be in the order. if insertBeforeType is not in the ordering,
170 * places type at the end. */
171 bool move(IddObjectType type, IddObjectType insertBeforeType);
172 /** move type from current location to index. returns false if not ordering by
173 * user-specified IddObjectType order, or request is otherwise invalid. type must already
174 * be in the order. if index is invalid, places type at the end. */
175 bool move(IddObjectType type, unsigned index);
176 /** returns false if not ordering by user-specified IddObjectType, or request is
177 * otherwise invalid. */
178 bool swap(IddObjectType type1, IddObjectType type2);
179 /** returns false if not ordering by user-specified IddObjectType, or request is
180 * otherwise invalid. */
181 bool erase(IddObjectType type);
182
183 /// Returns whether or not direct ordered. Otherwise, is ordered by IddObjectType.
184 bool isDirectOrder() const;
185 /// returns the direct order. return value is false if not ordering this way.
186 boost::optional<std::vector<Handle>> directOrder() const;
187 /// deletes other ordering options and sets direct order
188 void setDirectOrder(const std::vector<Handle>& order);
189 /// returns false if not ordering directly
190 bool push_back(const Handle& handle);
191 /// returns false if not ordering directly
192 bool insert(const Handle& handle, const Handle& insertBeforeHandle);
193 /// returns false if not ordering directly
194 bool insert(const Handle& handle, unsigned index);
195 /// returns false if not ordering directly, or request is otherwise invalid
196 bool move(const Handle& handle, const Handle& insertBeforeHandle);
197 /// returns false if not ordering directly, or request is otherwise invalid
198 bool move(const Handle& handle, unsigned index);
199 /// returns false if not ordering directly, or request is otherwise invalid
200 bool swap(const Handle& handle1, const Handle& handle2);
201 /// returns false if not ordering directly, or request is otherwise invalid
202 bool erase(const Handle& handle);
203
204 // SORTING
205
206 std::vector<Handle> sort(const std::vector<Handle>& handles) const;
207
208 std::vector<openstudio::WorkspaceObject> sort(const std::vector<openstudio::WorkspaceObject>& objects) const;
209
210 // STATE CHECKING
211
212 /** Returns whether order of handle is directly specified. */
213 bool inOrder(const Handle& handle) const;
214
215 /** Returns index of handle in order, if its order is directly specified. */
216 boost::optional<unsigned> indexInOrder(const Handle& handle) const;
217
218 protected:
219 friend class Workspace;
220 friend class detail::Workspace_Impl;
221
222 // Workspace constructs the public interface of the orderer when it is requested.
223 WorkspaceObjectOrder(const std::shared_ptr<detail::WorkspaceObjectOrder_Impl>& impl);
224
225 private:
226 std::shared_ptr<detail::WorkspaceObjectOrder_Impl> m_impl;
227
228 REGISTER_LOGGER("utilities.idf.WorkspaceObjectOrder");
229 };
230
231 } // namespace openstudio
232
233 #endif // UTILITIES_IDF_WORKSPACEOBJECTORDER_HPP
234