26 ColumnarToolArray (ColumnarToolArray* val_parent)
28 if (val_parent ==
nullptr)
30 m_data = std::make_shared<ColumnarToolDataArray> ();
31 m_data->mainTool =
this;
32 m_data->sharedTools.push_back (
this);
39 addColumn (std::string (
eventContextCIName), m_eventsData.get(), std::move (eventsInfo));
42 m_data = val_parent->m_data;
43 m_data->sharedTools.push_back (
this);
58 if (m_data->mainTool ==
this)
59 m_data->mainTool =
nullptr;
61 auto iter = std::find (m_data->sharedTools.begin(), m_data->sharedTools.end(),
this);
62 if (iter != m_data->sharedTools.end())
63 m_data->sharedTools.erase (iter);
68 void ColumnarToolArray ::
69 addSubtool (ColumnarToolArray& subtool)
74 auto subtoolData = subtool.m_data;
76 if (m_data == subtoolData)
79 if (subtoolData->mainTool != &subtool)
80 throw std::runtime_error (
"subtool already has a different parent tool");
82 for (
auto& containerName : subtoolData->containerInternalToUserNames)
84 auto [
iter,success] = m_data->containerInternalToUserNames.emplace (containerName.first, containerName.second);
85 if (!success &&
iter->second != containerName.second)
86 throw std::runtime_error (
"container assigned different name in subtool: " +
iter->second +
" vs " + containerName.second);
88 m_data->containerUserToInternalNames[containerName.second].push_back (containerName.first);
90 for (
auto& columnName : subtoolData->columnInternalToUserNames)
92 auto [
iter,success] = m_data->columnInternalToUserNames.emplace (columnName.first, columnName.second);
93 if (!success &&
iter->second != columnName.second)
94 throw std::runtime_error (
"column assigned different name in subtool: " +
iter->second +
" vs " + columnName.second);
96 m_data->columnUserToInternalNames[columnName.second].push_back (columnName.first);
99 for (
auto& column : subtoolData->columns)
101 auto [
iter,success] = m_data->columns.try_emplace (
column.first, std::move (
column.second));
104 if (
iter->second.empty())
106 else if (!
column.second.empty())
111 for (
auto& [ciName, watchers] : subtoolData->linkTargetNameWatchers)
113 auto&
target = m_data->linkTargetNameWatchers[ciName];
114 target.insert (
target.end(), std::make_move_iterator (watchers.begin()), std::make_move_iterator (watchers.end()));
116 subtoolData->linkTargetNameWatchers.clear();
117 m_data->linkTargetNames.insert (subtoolData->linkTargetNames.begin(), subtoolData->linkTargetNames.end());
119 m_data->sharedTools.insert (m_data->sharedTools.end(), subtoolData->sharedTools.begin(), subtoolData->sharedTools.end());
120 for (
auto& tool : subtoolData->sharedTools)
121 tool->m_data = m_data;
123 m_data->notifyLinkTargetNameWatchers ();
131 return StatusCode::SUCCESS;
136 std::vector<ColumnInfo> ColumnarToolArray ::
137 getColumnInfo ()
const
139 for (
auto& [ciName, watchers] : m_data->linkTargetNameWatchers)
141 if (!m_data->hasContainerUserName (ciName))
142 throw std::runtime_error (
"no name registered for container: " + ciName +
" (it needs an ObjectColumn accessor, e.g. as the target of a link)");
145 std::vector<std::pair<std::string,std::string>>
names;
146 names.reserve (m_data->columns.size());
147 for (
auto& [name, column] : m_data->columns)
150 names.emplace_back (name, m_data->convertInternalToUserName (name));
152 std::sort (
names.begin(),
names.end(), [] (
const auto&
a,
const auto& b) { return a.second < b.second; });
154 std::vector<ColumnInfo>
result;
156 for (
auto& name : names)
158 auto&
column = m_data->columns.at (
name.first);
161 info.offsetName = m_data->convertInternalToUserName (
info.offsetName);
162 info.replacesColumn = m_data->convertInternalToUserName (
info.replacesColumn);
163 if (m_data->linkTargetNameWatchers.contains (
name.first))
164 info.nameForLinks = m_data->linkTargetName (
name.first);
166 result.push_back (std::move(info));
175 void ColumnarToolArray ::
176 renameColumn (
const std::string& from,
const std::string& to)
178 if (
auto iter = m_data->columnUserToInternalNames.find (from);
179 iter != m_data->columnUserToInternalNames.end())
181 for (
auto& internalName :
iter->second)
182 m_data->columnInternalToUserNames[internalName] = to;
183 auto internalNames =
iter->second;
184 m_data->columnUserToInternalNames.erase (iter);
185 m_data->columnUserToInternalNames[to].insert (m_data->columnUserToInternalNames[to].end(), internalNames.begin(), internalNames.end());
189 auto internalNames = m_data->convertUserToInternalNames (from);
190 if (internalNames.empty())
191 throw std::runtime_error (
"column not found for rename: " + from);
192 m_data->columnUserToInternalNames[to].insert (m_data->columnUserToInternalNames[to].end(), internalNames.begin(), internalNames.end());
193 for (
auto& internalName : internalNames)
194 m_data->columnInternalToUserNames[internalName] = to;
199 void ColumnarToolArray ::
200 setLinkTargetName (
const std::string& column,
const std::string& name)
202 auto internalNames = m_data->convertUserToInternalNames (column);
203 if (internalNames.empty())
204 throw std::runtime_error (
"column not found for link target name: " + column);
205 for (
auto& internalName : internalNames)
207 if (!m_data->hasContainerUserName (internalName))
208 throw std::runtime_error (
"column for link target name is not the offset map of a container: " + column);
210 for (
auto& internalName : internalNames)
211 m_data->linkTargetNames[internalName] =
name;
212 m_data->notifyLinkTargetNameWatchers ();
217 void ColumnarToolArray ::
218 setColumnIndex (
const std::string& name, std::size_t index)
220 auto internalNames = m_data->convertUserToInternalNames (name);
222 for (
auto& internalName : internalNames)
224 if (
auto column = m_data->columns.find (internalName);
225 column != m_data->columns.end() && !
column->second.empty())
227 column->second.setIndex (index);
232 throw std::runtime_error (
"column not found: " + name);
237 void ColumnarToolArray ::
238 setContainerUserName (std::string_view container,
const std::string& name)
240 auto [
iter, success] = m_data->containerInternalToUserNames.emplace (container, name);
241 if (!success &&
iter->second != name)
242 throw std::runtime_error (
"container already registered with different name: " + name +
" vs " +
iter->second);
243 m_data->containerUserToInternalNames[
name].emplace_back (container);
244 m_data->notifyLinkTargetNameWatchers ();
249 void ColumnarToolArray ::
250 watchLinkTargetName (std::string_view ciName, std::function<
void(
const std::string&)> watcher)
252 if (m_data->hasContainerUserName (ciName))
253 watcher (m_data->linkTargetName (ciName));
254 auto iter = m_data->linkTargetNameWatchers.find (ciName);
255 if (iter == m_data->linkTargetNameWatchers.end())
256 iter = m_data->linkTargetNameWatchers.emplace (std::string (ciName), std::vector<std::function<
void(
const std::string&)>> ()).first;
257 iter->second.push_back (std::move (watcher));
262 void ColumnarToolArray ::
265 if (
info.type ==
nullptr ||
info.sizeOfType == 0u)
266 throw std::logic_error (
"missing type information for column: " + name);
267 if (*
info.type != *accessorData->type)
268 throw std::logic_error (
"inconsistent type information for column: " + name);
269 info.accessMode = accessorData->accessMode;
271 m_data->columns[
name].addAccessor (name, info, accessorData);
274 if (!
info.offsetName.empty())
275 m_data->columns[
info.offsetName];
276 if (!
info.replacesColumn.empty())
277 m_data->columns[
info.replacesColumn];
289 if (ptr->dataRef == &
other)
297 ~ColumnDataArray () noexcept
301 if (ptr->dataRef ==
this)
302 ptr->dataRef =
nullptr;
308 bool ColumnDataArray ::
309 empty ()
const noexcept
317 info ()
const noexcept
324 void ColumnDataArray ::
338 throw std::runtime_error (
"multiple types for column: " + name);
344 m_info.isOptional =
false;
348 throw std::runtime_error (
"inconsistent offset map for column: " + name);
351 if (val_accessorData)
354 val_accessorData->
dataRef =
this;
360 void ColumnDataArray ::
367 val_accessorData.
dataRef =
nullptr;
372 void ColumnDataArray ::
378 for (
auto *ptr :
other.m_accessors)
380 other.m_accessors.clear();
385 void ColumnDataArray ::
386 setIndex (
unsigned index)
noexcept
390 *ptr->dataIndexPtr =
index;
395 std::string ColumnarToolDataArray ::
396 convertInternalToUserName (std::string_view name)
const
399 return std::string{};
403 auto split = name.find (
'.');
404 if (
split == std::string::npos)
406 auto containerName = name.substr (0,
split);
409 return std::string (name);
410 return iter->second + std::string (name.substr (
split));
415 std::vector<std::string> ColumnarToolDataArray ::
416 convertUserToInternalNames (std::string_view name)
const
421 auto split = name.find (
'.');
422 if (
split == std::string::npos)
424 auto containerName = name.substr (0,
split);
425 std::vector<std::string> result;
429 for (
auto& internalContainerName : iter->second)
431 std::string subname = internalContainerName + std::string (name.substr (
split));
433 result.push_back (std::move (subname));
437 result.push_back (std::string (name));
443 std::string ColumnarToolDataArray ::
444 linkTargetName (std::string_view ciName)
const
453 bool ColumnarToolDataArray ::
454 hasContainerUserName (std::string_view ciName)
const
461 void ColumnarToolDataArray ::
462 notifyLinkTargetNameWatchers ()
const
469 for (
auto& watcher : watchers)
helper functions for working with the type information in columnar::ColumnInfo
std::vector< std::string > split(const std::string &s, const std::string &t=":")
::StatusCode StatusCode
StatusCode definition for legacy code.
void mergeColumnInfo(ColumnInfo &target, const ColumnInfo &source)
constexpr ColumnTypeCategory mergeColumnTypeCategory(ColumnTypeCategory a, ColumnTypeCategory b) noexcept
merge the type categories of two users of the same column (with the same type), the strictest one win...
constexpr std::string_view eventContextCIName
the name for the event context container id
@ update
an updateable column
void setColumnType(ColumnInfo &info) noexcept
set the type information in the ColumnInfo for the given C++ type
const std::string eventRangeColumnName
the default name for the column containing the event range
std::size_t ColumnarOffsetType
the type used for the size and offsets in the columnar data
void sort(typename DataModel_detail::iterator< DVL > beg, typename DataModel_detail::iterator< DVL > end)
Specialization of sort for DataVector/List.
all the data about a column accessor that the ColumnarTool needs to know about
ColumnDataArray * dataRef
the ColumnDataArray object that holds us
ColumnDataArray() noexcept=default
standard constructor
std::vector< ColumnAccessorDataArray * > m_accessors
the data on all accessors for this column
ColumnInfo m_info
the column info
void addAccessor(const std::string &name, const ColumnInfo &val_info, ColumnAccessorDataArray *val_accessorData)
add an info to the column
a struct that contains meta-information about each column that's needed to interface the column with ...
std::string offsetName
the name of the offset column used for this column (or empty string for none)
ColumnTypeCategory typeCategory
the type category for the individual entries in the column
bool isOptional
whether this column is optional
bool isOffset
whether this is an offset column
ColumnAccessMode accessMode
the access mode for the column
const std::type_info * type
the type of the individual entries in the column
static constexpr std::string_view idName