Skip to content

Commit 5f45fa0

Browse files
franzpoeschelfranzpoeschel
committed
Rename in preparation for storeChunk adaptations
1 parent edb6d5e commit 5f45fa0

File tree

7 files changed

+125
-117
lines changed

7 files changed

+125
-117
lines changed

‎include/openPMD/LoadStoreChunk.hpp‎

Lines changed: 13 additions & 85 deletions
Original file line numberDiff line numberDiff line change
@@ -41,15 +41,15 @@ namespace internal
4141
} // namespace internal
4242

4343
template <typename ChildClass = void>
44-
class ConfigureStoreChunk : protected internal::ConfigureStoreChunkData
44+
class ConfigureLoadStore : protected internal::ConfigureStoreChunkData
4545
{
4646
friend class RecordComponent;
4747
template <typename>
48-
friend class ConfigureStoreChunk;
48+
friend class ConfigureLoadStore;
4949

5050
protected:
51-
ConfigureStoreChunk(RecordComponent &rc);
52-
ConfigureStoreChunk(ConfigureStoreChunkData &&);
51+
ConfigureLoadStore(RecordComponent &rc);
52+
ConfigureLoadStore(ConfigureStoreChunkData &&);
5353

5454
auto dim() const -> uint8_t;
5555
auto getOffset() const -> Offset;
@@ -59,7 +59,7 @@ class ConfigureStoreChunk : protected internal::ConfigureStoreChunkData
5959
public:
6060
using return_type = std::conditional_t<
6161
std::is_void_v<ChildClass>,
62-
/*then*/ ConfigureStoreChunk<void>,
62+
/*then*/ ConfigureLoadStore<void>,
6363
/*else*/ ChildClass>;
6464
template <typename T>
6565
using normalize_dataset_type = std::remove_cv_t<std::remove_extent_t<T>>;
@@ -93,24 +93,24 @@ class ConfigureStoreChunk : protected internal::ConfigureStoreChunkData
9393
typename T_ContiguousContainer::value_type> const>>>;
9494

9595
template <typename T>
96-
auto enqueue() -> DynamicMemoryView<T>;
96+
[[nodiscard]] auto enqueueStore() -> DynamicMemoryView<T>;
9797
// definition for this one is in RecordComponent.tpp since it needs the
9898
// definition of class RecordComponent.
9999
template <typename T, typename F>
100-
auto enqueue(F &&createBuffer) -> DynamicMemoryView<T>;
100+
[[nodiscard]] auto enqueueStore(F &&createBuffer) -> DynamicMemoryView<T>;
101101
};
102102

103103
template <typename Ptr_Type>
104104
class ConfigureStoreChunkFromBuffer
105-
: public ConfigureStoreChunk<ConfigureStoreChunkFromBuffer<Ptr_Type>>
105+
: public ConfigureLoadStore<ConfigureStoreChunkFromBuffer<Ptr_Type>>
106106
{
107107
public:
108108
using parent_t =
109-
ConfigureStoreChunk<ConfigureStoreChunkFromBuffer<Ptr_Type>>;
109+
ConfigureLoadStore<ConfigureStoreChunkFromBuffer<Ptr_Type>>;
110110

111111
private:
112112
template <typename T>
113-
friend class ConfigureStoreChunk;
113+
friend class ConfigureLoadStore;
114114

115115
Ptr_Type m_buffer;
116116
std::optional<MemorySelection> m_mem_select;
@@ -126,80 +126,8 @@ class ConfigureStoreChunkFromBuffer
126126
auto as_parent() & -> parent_t &;
127127
auto as_parent() const & -> parent_t const &;
128128

129-
auto enqueue() -> void;
129+
auto enqueueStore() -> void;
130130
};
131-
132-
template <typename ChildClass>
133-
template <typename T>
134-
auto ConfigureStoreChunk<ChildClass>::fromSharedPtr(std::shared_ptr<T> data)
135-
-> ConfigureStoreChunkFromBuffer<
136-
std::shared_ptr<normalize_dataset_type<T> const>>
137-
{
138-
if (!data)
139-
{
140-
throw std::runtime_error(
141-
"Unallocated pointer passed during chunk store.");
142-
}
143-
return ConfigureStoreChunkFromBuffer<
144-
std::shared_ptr<normalize_dataset_type<T> const>>(
145-
std::static_pointer_cast<normalize_dataset_type<T> const>(
146-
std::move(data)),
147-
{std::move(*this)});
148-
}
149-
template <typename ChildClass>
150-
template <typename T>
151-
auto ConfigureStoreChunk<ChildClass>::fromUniquePtr(UniquePtrWithLambda<T> data)
152-
-> ConfigureStoreChunkFromBuffer<
153-
UniquePtrWithLambda<normalize_dataset_type<T>>>
154-
{
155-
if (!data)
156-
{
157-
throw std::runtime_error(
158-
"Unallocated pointer passed during chunk store.");
159-
}
160-
return ConfigureStoreChunkFromBuffer<
161-
UniquePtrWithLambda<normalize_dataset_type<T>>>(
162-
std::move(data).template static_cast_<normalize_dataset_type<T>>(),
163-
{std::move(*this)});
164-
}
165-
template <typename ChildClass>
166-
template <typename T>
167-
auto ConfigureStoreChunk<ChildClass>::fromRawPtr(T *data)
168-
-> ConfigureStoreChunkFromBuffer<
169-
std::shared_ptr<normalize_dataset_type<T> const>>
170-
{
171-
if (!data)
172-
{
173-
throw std::runtime_error(
174-
"Unallocated pointer passed during chunk store.");
175-
}
176-
return ConfigureStoreChunkFromBuffer<
177-
std::shared_ptr<normalize_dataset_type<T> const>>(
178-
auxiliary::shareRaw(data), {std::move(*this)});
179-
}
180-
181-
template <typename ChildClass>
182-
template <typename T, typename Del>
183-
auto ConfigureStoreChunk<ChildClass>::fromUniquePtr(
184-
std::unique_ptr<T, Del> data)
185-
-> ConfigureStoreChunkFromBuffer<
186-
UniquePtrWithLambda<normalize_dataset_type<T>>>
187-
{
188-
return fromUniquePtr(UniquePtrWithLambda<T>(std::move(data)));
189-
}
190-
template <typename ChildClass>
191-
template <typename T_ContiguousContainer>
192-
auto ConfigureStoreChunk<ChildClass>::fromContiguousContainer(
193-
T_ContiguousContainer &data) ->
194-
typename std::enable_if_t<
195-
auxiliary::IsContiguousContainer_v<T_ContiguousContainer>,
196-
ConfigureStoreChunkFromBuffer<std::shared_ptr<normalize_dataset_type<
197-
typename T_ContiguousContainer::value_type> const>>>
198-
{
199-
if (!m_extent.has_value() && dim() == 1)
200-
{
201-
m_extent = Extent{data.size()};
202-
}
203-
return fromRawPtr(data.data());
204-
}
205131
} // namespace openPMD
132+
133+
#include "openPMD/LoadStoreChunk.tpp"

‎include/openPMD/LoadStoreChunk.tpp‎

Lines changed: 80 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,80 @@
1+
#pragma once
2+
3+
#include "openPMD/LoadStoreChunk.hpp"
4+
5+
namespace openPMD
6+
{
7+
8+
template <typename ChildClass>
9+
template <typename T>
10+
auto ConfigureLoadStore<ChildClass>::fromSharedPtr(std::shared_ptr<T> data)
11+
-> ConfigureStoreChunkFromBuffer<
12+
std::shared_ptr<normalize_dataset_type<T> const>>
13+
{
14+
if (!data)
15+
{
16+
throw std::runtime_error(
17+
"Unallocated pointer passed during chunk store.");
18+
}
19+
return ConfigureStoreChunkFromBuffer<
20+
std::shared_ptr<normalize_dataset_type<T> const>>(
21+
std::static_pointer_cast<normalize_dataset_type<T> const>(
22+
std::move(data)),
23+
{std::move(*this)});
24+
}
25+
template <typename ChildClass>
26+
template <typename T>
27+
auto ConfigureLoadStore<ChildClass>::fromUniquePtr(UniquePtrWithLambda<T> data)
28+
-> ConfigureStoreChunkFromBuffer<
29+
UniquePtrWithLambda<normalize_dataset_type<T>>>
30+
{
31+
if (!data)
32+
{
33+
throw std::runtime_error(
34+
"Unallocated pointer passed during chunk store.");
35+
}
36+
return ConfigureStoreChunkFromBuffer<
37+
UniquePtrWithLambda<normalize_dataset_type<T>>>(
38+
std::move(data).template static_cast_<normalize_dataset_type<T>>(),
39+
{std::move(*this)});
40+
}
41+
template <typename ChildClass>
42+
template <typename T>
43+
auto ConfigureLoadStore<ChildClass>::fromRawPtr(T *data)
44+
-> ConfigureStoreChunkFromBuffer<
45+
std::shared_ptr<normalize_dataset_type<T> const>>
46+
{
47+
if (!data)
48+
{
49+
throw std::runtime_error(
50+
"Unallocated pointer passed during chunk store.");
51+
}
52+
return ConfigureStoreChunkFromBuffer<
53+
std::shared_ptr<normalize_dataset_type<T> const>>(
54+
auxiliary::shareRaw(data), {std::move(*this)});
55+
}
56+
57+
template <typename ChildClass>
58+
template <typename T, typename Del>
59+
auto ConfigureLoadStore<ChildClass>::fromUniquePtr(std::unique_ptr<T, Del> data)
60+
-> ConfigureStoreChunkFromBuffer<
61+
UniquePtrWithLambda<normalize_dataset_type<T>>>
62+
{
63+
return fromUniquePtr(UniquePtrWithLambda<T>(std::move(data)));
64+
}
65+
template <typename ChildClass>
66+
template <typename T_ContiguousContainer>
67+
auto ConfigureLoadStore<ChildClass>::fromContiguousContainer(
68+
T_ContiguousContainer &data) ->
69+
typename std::enable_if_t<
70+
auxiliary::IsContiguousContainer_v<T_ContiguousContainer>,
71+
ConfigureStoreChunkFromBuffer<std::shared_ptr<normalize_dataset_type<
72+
typename T_ContiguousContainer::value_type> const>>>
73+
{
74+
if (!m_extent.has_value() && dim() == 1)
75+
{
76+
m_extent = Extent{data.size()};
77+
}
78+
return fromRawPtr(data.data());
79+
}
80+
} // namespace openPMD

‎include/openPMD/RecordComponent.hpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -134,7 +134,7 @@ class RecordComponent : public BaseRecordComponent
134134
friend class internal::RecordComponentData;
135135
friend class MeshRecordComponent;
136136
template <typename ChildClass>
137-
friend class ConfigureStoreChunk;
137+
friend class ConfigureLoadStore;
138138
template <typename Ptr_Type>
139139
friend class ConfigureStoreChunkFromBuffer;
140140

@@ -288,7 +288,7 @@ class RecordComponent : public BaseRecordComponent
288288
template <typename T>
289289
void loadChunkRaw(T *data, Offset offset, Extent extent);
290290

291-
ConfigureStoreChunk<void> prepareStoreChunk();
291+
ConfigureLoadStore<void> prepareStoreChunk();
292292

293293
/** Store a chunk of data from a chunk of memory.
294294
*

‎include/openPMD/RecordComponent.tpp‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -192,7 +192,7 @@ RecordComponent::storeChunk(std::shared_ptr<T> data, Offset o, Extent e)
192192
.offset(std::move(o))
193193
.extent(std::move(e))
194194
.fromSharedPtr(std::move(data))
195-
.enqueue();
195+
.enqueueStore();
196196
}
197197

198198
template <typename T>
@@ -203,7 +203,7 @@ RecordComponent::storeChunk(UniquePtrWithLambda<T> data, Offset o, Extent e)
203203
.offset(std::move(o))
204204
.extent(std::move(e))
205205
.fromUniquePtr(std::move(data))
206-
.enqueue();
206+
.enqueueStore();
207207
}
208208

209209
template <typename T, typename Del>
@@ -214,7 +214,7 @@ RecordComponent::storeChunk(std::unique_ptr<T, Del> data, Offset o, Extent e)
214214
.offset(std::move(o))
215215
.extent(std::move(e))
216216
.fromUniquePtr(std::move(data))
217-
.enqueue();
217+
.enqueueStore();
218218
}
219219

220220
template <typename T>
@@ -224,7 +224,7 @@ void RecordComponent::storeChunkRaw(T *ptr, Offset offset, Extent extent)
224224
.offset(std::move(offset))
225225
.extent(std::move(extent))
226226
.fromRawPtr(ptr)
227-
.enqueue();
227+
.enqueueStore();
228228
}
229229

230230
template <typename T_ContiguousContainer>
@@ -244,7 +244,7 @@ RecordComponent::storeChunk(T_ContiguousContainer &data, Offset o, Extent e)
244244
storeChunkConfig.extent(std::move(e));
245245
}
246246

247-
std::move(storeChunkConfig).fromContiguousContainer(data).enqueue();
247+
std::move(storeChunkConfig).fromContiguousContainer(data).enqueueStore();
248248
}
249249

250250
template <typename T, typename F>
@@ -254,7 +254,7 @@ RecordComponent::storeChunk(Offset o, Extent e, F &&createBuffer)
254254
return prepareStoreChunk()
255255
.offset(std::move(o))
256256
.extent(std::move(e))
257-
.enqueue<T>(std::forward<F>(createBuffer));
257+
.enqueueStore<T>(std::forward<F>(createBuffer));
258258
}
259259

260260
template <typename T>
@@ -264,7 +264,7 @@ RecordComponent::storeChunk(Offset offset, Extent extent)
264264
return prepareStoreChunk()
265265
.offset(std::move(offset))
266266
.extent(std::move(extent))
267-
.enqueue<T>();
267+
.enqueueStore<T>();
268268
}
269269

270270
template <typename T, typename F>
@@ -367,7 +367,7 @@ void RecordComponent::verifyChunk(Offset const &o, Extent const &e) const
367367
// definitions for LoadStoreChunk.hpp
368368
template <typename ChildClass>
369369
template <typename T, typename F>
370-
auto ConfigureStoreChunk<ChildClass>::enqueue(F &&createBuffer)
370+
auto ConfigureLoadStore<ChildClass>::enqueueStore(F &&createBuffer)
371371
-> DynamicMemoryView<T>
372372
{
373373
return m_rc.storeChunkSpanCreateBuffer_impl<T>(

0 commit comments

Comments
 (0)