2 Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
5/// @author Nils Krumnack
8#include <ColumnarCore/ColumnAccessorDataArray.h>
9#include <ColumnarCore/VectorConvertView.h>
17 struct ColumnAccessorOptionsArray final
19 std::string_view offsetName;
21 std::string dataSuffix = "";
22 bool isOffset = false;
23 unsigned numOffsets = 0u;
26 // the Array mode specialization for native types
27 template<typename CT,ColumnAccessMode CAM,ColumnarArrayModeConcept CM>
28 requires (MemoryAccessor<CT,CM>::isDefined)
29 class ContainerFreeAccessor<CT,CAM,CM> final
31 /// Common Public Members
32 /// =====================
35 static_assert (CAM == ColumnAccessMode::input || MemoryAccessor<CT,CM>::viewIsReference || MemoryAccessor<CT,CM>::hasSetter, "output access not supported for this type");
37 using ColumnType = typename MemoryAccessor<CT,CM>::MemoryType;
39 static constexpr bool isDefined = true;
40 static constexpr bool viewIsReference = MemoryAccessor<CT,CM>::viewIsReference;
41 static constexpr bool useSetter = !viewIsReference && CAM == ColumnAccessMode::output && MemoryAccessor<CT,CM>::hasSetter;
42 static constexpr unsigned internalOffsetColumns = 0;
44 ContainerFreeAccessor () noexcept = default;
46 ContainerFreeAccessor (ColumnarTool<CM>& columnarTool, ColumnAccessorOptions&& options, ColumnAccessorOptionsArray&& optionsArray)
48 auto info = options.makeColumnInfo();
49 info.offsetName = optionsArray.offsetName;
50 info.isOffset = optionsArray.isOffset;
51 setColumnType<ColumnType> (info);
52 if (options.isSignAgnostic)
54 if (info.typeCategory != ColumnTypeCategory::signedInteger && info.typeCategory != ColumnTypeCategory::unsignedInteger && info.typeCategory != ColumnTypeCategory::signAgnosticInteger)
55 throw std::logic_error ("isSignAgnostic set on a column that is not an integer: " + optionsArray.baseName + optionsArray.dataSuffix);
56 info.typeCategory = ColumnTypeCategory::signAgnosticInteger;
58 if constexpr (requires { requires MemoryAccessor<CT,CM>::isBooleanValued; })
59 info.typeCategory = ColumnTypeCategory::boolean;
60 m_accessorData = std::make_unique<ColumnAccessorDataArray> (&m_dataIndex, &m_accessorData, &typeid (typename MemoryAccessor<CT,CM>::MemoryType), CAM);
61 columnarTool.addColumn (optionsArray.baseName + optionsArray.dataSuffix, m_accessorData.get(), std::move (info));
64 ContainerFreeAccessor (ContainerFreeAccessor&& that)
66 moveAccessor (m_dataIndex, m_accessorData, that.m_dataIndex, that.m_accessorData);
69 ContainerFreeAccessor& operator = (ContainerFreeAccessor&& that)
72 moveAccessor (m_dataIndex, m_accessorData, that.m_dataIndex, that.m_accessorData);
76 ContainerFreeAccessor (const ContainerFreeAccessor&) = delete;
77 ContainerFreeAccessor& operator = (const ContainerFreeAccessor&) = delete;
79 [[nodiscard]] ColumnType& operator () (void** dataArea, std::size_t index) const noexcept
80 requires (viewIsReference)
82 auto *data = static_cast<ColumnType*>(dataArea[m_dataIndex]);
86 [[nodiscard]] decltype(auto) operator () (void** dataArea, std::size_t index) const noexcept
87 requires (!viewIsReference && CAM == ColumnAccessMode::input)
89 auto *data = static_cast<ColumnType*>(dataArea[m_dataIndex]);
90 return MemoryAccessor<CT,CM>::makeViewer (dataArea)(data[index]);
93 [[nodiscard]] std::span<ColumnType> operator () (void** dataArea, std::size_t beginIndex, std::size_t endIndex) const noexcept
94 requires (viewIsReference)
96 auto *data = static_cast<ColumnType*>(dataArea[m_dataIndex]);
97 return std::span<ColumnType> (data+beginIndex, endIndex-beginIndex);
100 [[nodiscard]] auto operator () (void** dataArea, std::size_t beginIndex, std::size_t endIndex) const noexcept
101 requires (!viewIsReference && CAM == ColumnAccessMode::input)
103 auto *data = static_cast<ColumnType*>(dataArea[m_dataIndex]);
104 std::span<ColumnType> mySpan (data+beginIndex, endIndex-beginIndex);
105 return VectorConvertView (MemoryAccessor<CT,CM>::makeViewer (dataArea), std::span (mySpan));
108 [[nodiscard]] auto operator () (void** dataArea, std::size_t index) const noexcept
111 auto *data = static_cast<ColumnType*>(dataArea[m_dataIndex]);
112 return OutputProxy (data[index], MemoryAccessor<CT,CM>::makeSetter (dataArea));
117 void set (void** dataArea, std::size_t index, T&& value) const
119 auto *data = static_cast<ColumnType*>(dataArea[m_dataIndex]);
120 MemoryAccessor<CT,CM>::makeSetter (dataArea)(data[index], std::forward<T>(value));
123 [[nodiscard]] bool isAvailable (void** dataArea) const noexcept
125 auto *data = static_cast<ColumnType*>(dataArea[m_dataIndex]);
126 return data != nullptr;
133 unsigned m_dataIndex = 0u;
134 std::unique_ptr<ColumnAccessorDataArray> m_accessorData;
140 // the Array mode specialization for native types
141 template<ContainerIdConcept CI,typename CT,ColumnAccessMode CAM,ColumnarArrayModeConcept CM>
142 requires (CI::regularColumnAccessorArray && detail::ContainerFreeAccessor<CT,CAM,CM>::isDefined)
143 class AccessorTemplate<CI,CT,CAM,CM> final
145 /// Common Public Members
146 /// =====================
149 static_assert (!std::is_const_v<CT>, "CT must not be const");
151 AccessorTemplate () noexcept = default;
153 AccessorTemplate (ColumnarTool<CM>& columnarTool, const std::string& name, ColumnAccessorOptions&& options = {})
154 : m_accessor (columnarTool, std::move (options), detail::ColumnAccessorOptionsArray{.offsetName = CI::perEventRange ? CI::idName : eventContextCIName, .baseName = std::string (CI::idName) + "." + name})
156 static_assert (CI::perEventRange + CI::perEventId == 1, "ContainerId must be either per-event-range or per-event-id");
159 AccessorTemplate (AccessorTemplate&& that) = default;
160 AccessorTemplate& operator = (AccessorTemplate&& that) = default;
161 AccessorTemplate (const AccessorTemplate&) = delete;
162 AccessorTemplate& operator = (const AccessorTemplate&) = delete;
164 void reset (ColumnarTool<CM>& columnarTool, const std::string& name, ColumnAccessorOptions&& options = {})
166 *this = AccessorTemplate (columnarTool, name, std::move (options));
169 [[nodiscard]] decltype(auto) operator () (ObjectId<CI,CM> id) const
171 return m_accessor(id.getDataArea(), id.getIndex());
174 // Normally we should not pass ObjectRange by reference (it can
175 // break loop optimization), but since this function should be
176 // inlined and any member is only accessed once, it doesn't matter
177 // (either is sufficient) and this shuts up cppcheck.
178 [[nodiscard]] decltype(auto) operator () (const ObjectRange<CI,CM>& range) const
180 return m_accessor(range.getDataArea(), range.beginIndex(), range.endIndex());
184 requires requires(T value) {std::declval<detail::ContainerFreeAccessor<CT,CAM,CM>>().set (nullptr,0,value);}
185 void set (ObjectId<CI,CM> id, T&& value) const
187 m_accessor.set (id.getDataArea(), id.getIndex(), std::forward<T>(value));
190 [[nodiscard]] bool isAvailable (ObjectId<CI,CM> id) const noexcept
192 return m_accessor.isAvailable (id.getDataArea());
195 // Normally we should not pass ObjectRange by reference (it can
196 // break loop optimization), but since this function should be
197 // inlined and any member is only accessed once, it doesn't matter
198 // (either is sufficient) and this shuts up cppcheck.
199 [[nodiscard]] bool isAvailable (const ObjectRange<CI,CM>& range) const noexcept
201 return m_accessor.isAvailable (range.getDataArea());
204 [[nodiscard]] auto getOptional (ObjectId<CI,CM> id) const
206 std::optional<std::decay_t<decltype(std::declval<detail::ContainerFreeAccessor<CT,CAM,CM>>()(nullptr,0))>> result;
207 if (m_accessor.isAvailable (id.getDataArea()))
208 result = m_accessor (id.getDataArea(), id.getIndex());
216 detail::ContainerFreeAccessor<CT,CAM,CM> m_accessor;