Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Decorator.icc
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration.
3  */
4 /**
5  * @file AthContainers/Decorator.icc
6  * @author scott snyder <snyder@bnl.gov>
7  * @date Oct, 2023
8  * @brief Helper class to provide type-safe access to aux data.
9  */
10 
11 
12 #include "AthContainers/AuxTypeRegistry.h"
13 #include "AthContainers/exceptions.h"
14 
15 
16 namespace SG {
17 
18 
19 /**
20  * @brief Constructor.
21  * @param name Name of this aux variable.
22  *
23  * The name -> auxid lookup is done here.
24  */
25 template <class T, class ALLOC>
26 inline
27 Decorator<T, ALLOC>::Decorator (const std::string& name)
28  : Decorator (name, "", SG::AuxVarFlags::None)
29 {
30  // cppcheck-suppress missingReturn
31 }
32 
33 
34 /**
35  * @brief Constructor.
36  * @param name Name of this aux variable.
37  * @param clsname The name of its associated class. May be blank.
38  *
39  * The name -> auxid lookup is done here.
40  */
41 template <class T, class ALLOC>
42 inline
43 Decorator<T, ALLOC>::Decorator (const std::string& name,
44  const std::string& clsname)
45  : Decorator (name, clsname, SG::AuxVarFlags::None)
46 {
47 }
48 
49 
50 /**
51  * @brief Constructor taking an auxid directly.
52  * @param auxid ID for this auxiliary variable.
53  *
54  * Will throw @c SG::ExcAuxTypeMismatch if the types don't match.
55  */
56 template <class T, class ALLOC>
57 inline
58 Decorator<T, ALLOC>::Decorator (const SG::auxid_t auxid)
59  : Decorator (auxid, SG::AuxVarFlags::None)
60 {
61  // cppcheck-suppress missingReturn; false positive
62 }
63 
64 
65 /**
66  * @brief Constructor.
67  * @param name Name of this aux variable.
68  * @param clsname The name of its associated class. May be blank.
69  * @param flags Optional flags qualifying the type. See AuxTypeRegsitry.
70  *
71  * The name -> auxid lookup is done here.
72  */
73 template <class T, class ALLOC>
74 inline
75 Decorator<T, ALLOC>::Decorator
76  (const std::string& name,
77  const std::string& clsname,
78  const SG::AuxVarFlags flags)
79  : m_auxid (SG::AuxTypeRegistry::instance().getAuxID<T, ALLOC> (name, clsname, flags))
80 {
81 }
82 
83 
84 /**
85  * @brief Constructor taking an auxid directly.
86  * @param auxid ID for this auxiliary variable.
87  * @param flags Optional flags qualifying the type. See AuxTypeRegistry.
88  *
89  * Will throw @c SG::ExcAuxTypeMismatch if the types don't match.
90  */
91 template <class T, class ALLOC>
92 inline
93 Decorator<T, ALLOC>::Decorator (const SG::auxid_t auxid,
94  const SG::AuxVarFlags flags)
95  : m_auxid (auxid)
96 {
97  SG::AuxTypeRegistry::instance().checkAuxID<T, ALLOC> (auxid, flags);
98 }
99 
100 
101 /**
102  * @brief Fetch the variable for one element, as a non-const reference.
103  * @param e The element for which to fetch the variable.
104  *
105  * If the container is locked, this will allow fetching only variables
106  * that do not yet exist (in which case they will be marked as decorations)
107  * or variables already marked as decorations.
108  */
109 template <class T, class ALLOC>
110 template <IsConstAuxElement ELT>
111 inline
112 typename Decorator<T, ALLOC>::reference_type
113 Decorator<T, ALLOC>::operator() (const ELT& e) const
114 {
115  assert (e.container() != 0);
116  return e.container()->template getDecoration<T> (m_auxid, e.index());
117 }
118 
119 /**
120  * @brief Fetch the variable for one element, as a non-const reference.
121  * @param container The container from which to fetch the variable.
122  * @param index The index of the desired element.
123  *
124  * This allows retrieving aux data by container / index.
125  * Looping over the index via this method will be faster then
126  * looping over the elements of the container.
127  *
128  * If the container is locked, this will allow fetching only variables
129  * that do not yet exist (in which case they will be marked as decorations)
130  * or variables already marked as decorations.
131  */
132 template <class T, class ALLOC>
133 inline
134 typename Decorator<T, ALLOC>::reference_type
135 Decorator<T, ALLOC>::operator() (const AuxVectorData& container,
136  size_t index) const
137 {
138  return container.template getDecoration<T> (m_auxid, index);
139 }
140 
141 
142 /**
143  * @brief Set the variable for one element.
144  * @param e The element for which to fetch the variable.
145  * @param x The variable value to set.
146  */
147 template <class T, class ALLOC>
148 template <IsConstAuxElement ELT>
149 inline
150 void Decorator<T, ALLOC>::set (const ELT& e,
151  const element_type& x) const
152 {
153  (*this)(e) = x;
154 }
155 
156 
157 /**
158  * @brief Get a pointer to the start of the auxiliary data array.
159  * @param container The container from which to fetch the variable.
160  */
161 template <class T, class ALLOC>
162 inline
163 typename Decorator<T, ALLOC>::const_container_pointer_type
164 Decorator<T, ALLOC>::getDataArray (const AuxVectorData& container) const
165 {
166  return reinterpret_cast<const_container_pointer_type>
167  (container.getDataArray (m_auxid));
168 }
169 
170 
171 /**
172  * @brief Get a pointer to the start of the auxiliary data array.
173  * @param container The container from which to fetch the variable.
174  *
175  * If the container is locked, this will allow fetching only variables
176  * that do not yet exist (in which case they will be marked as decorations)
177  * or variables already marked as decorations.
178  */
179 template <class T, class ALLOC>
180 inline
181 typename Decorator<T, ALLOC>::container_pointer_type
182 Decorator<T, ALLOC>::getDecorationArray (const AuxVectorData& container) const
183 {
184  return reinterpret_cast<container_pointer_type>
185  (container.getDecorationArray (m_auxid));
186 }
187 
188 
189 /**
190  * @brief Get a span over the auxilary data array.
191  * @param container The container from which to fetch the variable.
192  */
193 template <class T, class ALLOC>
194 inline
195 typename Decorator<T, ALLOC>::const_span
196 Decorator<T, ALLOC>::getDataSpan (const AuxVectorData& container) const
197 {
198  auto beg = reinterpret_cast<const_container_pointer_type>
199  (container.getDataArray (m_auxid));
200  return const_span (beg, container.size_v());
201 }
202 
203 
204 /**
205  * @brief Get a span over the auxilary data array.
206  * @param container The container from which to fetch the variable.
207  *
208  * If the container is locked, this will allow fetching only variables
209  * that do not yet exist (in which case they will be marked as decorations)
210  * or variables already marked as decorations.
211  */
212 template <class T, class ALLOC>
213 inline
214 typename Decorator<T, ALLOC>::span
215 Decorator<T, ALLOC>::getDecorationSpan (const AuxVectorData& container) const
216 {
217  auto beg = reinterpret_cast<container_pointer_type>
218  (container.getDecorationArray (m_auxid));
219  return span (beg, container.size_v());
220 }
221 
222 
223 /**
224  * @brief Test to see if this variable exists in the store.
225  * @param e An element of the container in which to test the variable.
226  */
227 template <class T, class ALLOC>
228 template <IsConstAuxElement ELT>
229 inline
230 bool
231 Decorator<T, ALLOC>::isAvailable (const ELT& e) const
232 {
233  return e.container() && e.container()->isAvailable (m_auxid);
234 }
235 
236 /**
237  * @brief Test to see if this variable exists in the store and is writable.
238  * @param e An element of the container in which to test the variable.
239  */
240 template <class T, class ALLOC>
241 template <IsConstAuxElement ELT>
242 inline
243 bool
244 Decorator<T, ALLOC>::isAvailableWritable (const ELT& e) const
245 {
246  return e.container() && e.container()->isAvailableWritableAsDecoration (m_auxid);
247 }
248 
249 
250 /**
251  * @brief Test to see if this variable exists in the store.
252  * @param c The container in which to test the variable.
253  */
254 template <class T, class ALLOC>
255 inline
256 bool
257 Decorator<T, ALLOC>::isAvailable (const AuxVectorData& c) const
258 {
259  return c.isAvailable (m_auxid);
260 }
261 
262 /**
263  * @brief Test to see if this variable exists in the store and is writable.
264  * @param c The container in which to test the variable.
265  */
266 template <class T, class ALLOC>
267 inline
268 bool
269 Decorator<T, ALLOC>::isAvailableWritable (const AuxVectorData& c) const
270 {
271  return c.isAvailableWritableAsDecoration (m_auxid);
272 }
273 
274 
275 /**
276  * @brief Return the aux id for this variable.
277  */
278 template <class T, class ALLOC>
279 inline
280 SG::auxid_t
281 Decorator<T, ALLOC>::auxid() const
282 {
283  return m_auxid;
284 }
285 
286 
287 } // namespace SG