ATLAS Offline Software
Loading...
Searching...
No Matches
JaggedVecVectorFactory.icc
Go to the documentation of this file.
1/*
2 * Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration.
3 */
4/**
5 * @file AthContainers/tools/JaggedVecVectorFactory.icc
6 * @author scott snyder <snyder@bnl.gov>
7 * @date Apr, 2024
8 * @brief Factory object that creates vectors using @c AuxTypeVector,
9 * specialized for JaggedVec.
10 */
11
12
13#include "AthContainers/tools/AuxTypeVector.h"
14#include "AthContainers/AuxTypeRegistry.h"
15#include "AthContainers/exceptions.h"
16
17
18namespace SG {
19
20
21namespace JaggedVecVectorFactoryFuncs {
22
23
24using Shift = JaggedVecEltBase::Shift;
25
26
27/**
28 * @brief Copy elements between vectors: out-of-line portion.
29 * @param auxid The aux data item being operated on.
30 * @param dst Container for the destination vector.
31 * @param dst_index Index of the first destination element in the vector.
32 * @param src Container for the source vector.
33 * @param src_index Index of the first source element in the vector.
34 * @param n Number of elements to copy.
35 * @param for_output If true, then need to use copyForOutput on the
36 * payload, to update links due to thinning.
37 *
38 * @c dst and @ src can be either the same or different.
39 */
40void copyImpl (SG::auxid_t auxid,
41 AuxVectorData& dst,
42 size_t dst_index,
43 const AuxVectorData& src,
44 size_t src_index,
45 size_t n,
46 bool for_output);
47
48
49/**
50 * @brief Swap elements between vectors.
51 * @param auxid The aux data item being operated on.
52 * @param a Container for the first vector.
53 * @param aindex Index of the first element in the first vector.
54 * @param b Container for the second vector.
55 * @param bindex Index of the first element in the second vector.
56 * @param n Number of elements to swap.
57 *
58 * @c a and @ b can be either the same or different.
59 * However, the ranges should not overlap.
60 */
61void swap (SG::auxid_t auxid,
62 AuxVectorData& a, size_t aindex,
63 AuxVectorData& b, size_t bindex,
64 size_t n);
65
66
67/**
68 * @brief Clear a range of elements within a vector.
69 * @param v Pointer to the vector being operated on.
70 * @param auxid The aux data item being operated on.
71 * @param dst Container holding the element
72 * @param dst_index Index of the first element in the vector.
73 * @param n Number of elements to clear.
74 */
75void clear (JaggedVecEltBase* v,
76 auxid_t auxid,
77 AuxVectorData& dst,
78 size_t dst_index,
79 size_t n);
80
81
82} // namespace JaggedVecVectorFactoryFuncs
83
84
85/**
86 * @brief Create a vector object of this type.
87 * @param auxid ID for the variable being created.
88 * @param size Initial size of the new vector.
89 * @param capacity Initial capacity of the new vector.
90 * @param isLinked True if this variable is linked from another one.
91 * Must be false.
92 */
93template <class T, class ALLOC>
94std::unique_ptr<IAuxTypeVector>
95JaggedVecVectorFactory<T, ALLOC>::create (SG::auxid_t auxid,
96 size_t size, size_t capacity,
97 [[maybe_unused]] bool isLinked) const
98{
99 assert (!isLinked);
100 const AuxTypeRegistry& r = AuxTypeRegistry::instance();
101 auxid_t linked_id = r.linkedVariable (auxid);
102
103 using linkedAlloc = typename std::allocator_traits<ALLOC>::template rebind_alloc<T>;
104 auto linkedVec =
105 std::make_unique<AuxTypeVector<T, linkedAlloc> > (linked_id, 0, 0, true);
106 return std::make_unique<AuxTypeVector_t> (auxid, size, capacity,
107 std::move (linkedVec));
108}
109
110
111/**
112 * @brief Create a vector object of this type from a data blob.
113 * @param auxid ID for the variable being created.
114 * @param data The vector object.
115 * @param linkedVector The interface for another variable linked to this one.
116 * (We do not take ownership.)
117 * @param isPacked If true, @c data is a @c PackedContainer.
118 * @param ownFlag If true, the newly-created IAuxTypeVector object
119 * will take ownership of @c data.
120 * @param isLinked True if this variable is linked from another one.
121 *
122 * @c data should be a pointer to a
123 * std::vector<SG::JaggedVec<CONT>, ALLOC<...> > object obtained with new.
124 * For this method, isPacked and isLinked must both be false.
125 */
126template <class CONT, class ALLOC>
127std::unique_ptr<IAuxTypeVector>
128JaggedVecVectorFactory<CONT, ALLOC>::createFromData (SG::auxid_t auxid,
129 void* data,
130 IAuxTypeVector* linkedVector,
131 [[maybe_unused]] bool isPacked,
132 bool ownFlag,
133 [[maybe_unused]] bool isLinked) const
134{
135 assert (!isPacked && !isLinked && linkedVector != nullptr);
136 using Holder = SG::JaggedVecVectorHolder<CONT, ALLOC>;
137 using vector_type = typename Holder::vector_type;
138 return std::make_unique<Holder>
139 (auxid, reinterpret_cast<vector_type*>(data), linkedVector, ownFlag);
140}
141
142
143/**
144 * @brief Copy elements between vectors.
145 * @param auxid The aux data item being operated on.
146 * @param dst Container for the destination vector.
147 * @param dst_index Index of the first destination element in the vector.
148 * @param src Container for the source vector.
149 * @param src_index Index of the first source element in the vector.
150 * @param n Number of elements to copy.
151 *
152 * @c dst and @ src can be either the same or different.
153 */
154template <class T, class ALLOC>
155void JaggedVecVectorFactory<T, ALLOC>::copy (SG::auxid_t auxid,
156 AuxVectorData& dst,
157 size_t dst_index,
158 const AuxVectorData& src,
159 size_t src_index,
160 size_t n) const
161{
162 if (n == 0) return;
163 JaggedVecVectorFactoryFuncs::copyImpl (auxid, dst, dst_index, src, src_index, n, false);
164}
165
166
167/**
168 * @brief Copy elements between vectors, possibly applying thinning.
169 * @param auxid The aux data item being operated on.
170 * @param dst Container for the destination vector.
171 * @param dst_index Index of the first destination element in the vector.
172 * @param src Container for the source vector.
173 * @param src_index Index of source element in the vector.
174 * @param src_index Index of the first source element in the vector.
175 * @param n Number of elements to copy.
176 *
177 * @c dst and @ src can be either the same or different.
178 */
179template <class CONT, class ALLOC>
180void JaggedVecVectorFactory<CONT, ALLOC>::copyForOutput
181 (SG::auxid_t auxid,
182 AuxVectorData& dst, size_t dst_index,
183 const AuxVectorData& src, size_t src_index,
184 size_t n) const
185{
186 if (n == 0) return;
187 JaggedVecVectorFactoryFuncs::copyImpl (auxid, dst, dst_index, src, src_index, n, true);
188}
189
190
191/**
192 * @brief Swap elements between vectors.
193 * @param auxid The aux data item being operated on.
194 * @param a Container for the first vector.
195 * @param aindex Index of the first element in the first vector.
196 * @param b Container for the second vector.
197 * @param bindex Index of the first element in the second vector.
198 * @param n Number of elements to swap.
199 *
200 * @c a and @ b can be either the same or different.
201 * However, the ranges should not overlap.
202 */
203template <class T, class ALLOC>
204void JaggedVecVectorFactory<T, ALLOC>::swap (SG::auxid_t auxid,
205 AuxVectorData& a, size_t aindex,
206 AuxVectorData& b, size_t bindex,
207 size_t n) const
208{
209 if (n == 0) return;
210 JaggedVecVectorFactoryFuncs::swap (auxid, a, aindex, b, bindex, n);
211}
212
213
214/**
215 * @brief Clear a range of elements within a vector.
216 * @param auxid The aux data item being operated on.
217 * @param dst Container holding the element
218 * @param dst_index Index of the first element in the vector.
219 * @param n Number of elements to clear.
220 */
221template <class T, class ALLOC>
222void JaggedVecVectorFactory<T, ALLOC>::clear (SG::auxid_t auxid,
223 AuxVectorData& dst,
224 size_t dst_index,
225 size_t n) const
226{
227 if (n == 0) return;
228
229 vector_value_type* v = reinterpret_cast<vector_value_type*> (dst.getDataArray (auxid));
230 JaggedVecVectorFactoryFuncs::clear (v, auxid, dst, dst_index, n);
231}
232
233
234} // namespace SG
Generated on for ATLAS Offline Software by doxygen 1.16.1