EIC code displayed by LXR master/​acts/​Core/​src/​EventData/​SpacePointContainer.cpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-07-26 08:18:42

 // This file is part of the ACTS project.
 //
 // Copyright (C) 2016 CERN for the benefit of the ACTS project
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 #include "Acts/EventData/SpacePointContainer.hpp"
 
 #include "Acts/Utilities/Helpers.hpp"
 
 #include <string_view>
 #include <unordered_set>
 
 namespace {
 
 template <typename Tuple>
 using tuple_indices =
     std::make_index_sequence<std::tuple_size_v<std::remove_reference_t<Tuple>>>;
 
 }
 
 namespace Acts {
 
 static_assert(std::ranges::random_access_range<SpacePointContainer>);
 static_assert(
     std::ranges::random_access_range<SpacePointContainer::MutableRange>);
 static_assert(
     std::ranges::random_access_range<SpacePointContainer::ConstRange>);
 static_assert(
     std::ranges::random_access_range<SpacePointContainer::MutableSubset>);
 static_assert(
     std::ranges::random_access_range<SpacePointContainer::ConstSubset>);
 
 SpacePointContainer::SpacePointContainer(SpacePointColumns columns) noexcept {
   createColumns(columns);
 }
 
 SpacePointContainer::SpacePointContainer(
     const SpacePointContainer &other) noexcept
     : m_size(other.m_size), m_sourceLinks(other.m_sourceLinks) {
   copyColumns(other);
 }
 
 SpacePointContainer::SpacePointContainer(SpacePointContainer &&other) noexcept
     : m_size(other.m_size), m_sourceLinks(std::move(other.m_sourceLinks)) {
   moveColumns(other);
 
   other.m_size = 0;
 }
 
 SpacePointContainer &SpacePointContainer::operator=(
     const SpacePointContainer &other) noexcept {
   if (this == &other) {
     return *this;
   }
 
   copyColumns(other);
   m_sourceLinks = other.m_sourceLinks;
   m_size = other.m_size;
 
   return *this;
 }
 
 SpacePointContainer &SpacePointContainer::operator=(
     SpacePointContainer &&other) noexcept {
   if (this == &other) {
     return *this;
   }
 
   moveColumns(other);
   m_sourceLinks = std::move(other.m_sourceLinks);
   m_size = other.m_size;
 
   other.m_size = 0;
 
   return *this;
 }
 
 void SpacePointContainer::copyColumns(const SpacePointContainer &other) {
   m_allColumns.reserve(other.m_allColumns.size());
   m_dynamicColumns.reserve(other.m_dynamicColumns.size());
 
   const auto copyKnownColumns =
       [&]<typename T>(std::string_view name,
                       std::optional<ColumnHolder<T>> &column,
                       const std::optional<ColumnHolder<T>> &otherColumn) {
         column = otherColumn;
         if (column.has_value()) {
           m_allColumns.try_emplace(std::string(name), &column.value());
         }
       };
 
   [&]<std::size_t... Is>(std::index_sequence<Is...>) {
     ((copyKnownColumns(std::get<Is>(knownColumnNames()),
                        std::get<Is>(knownColumns()),
                        std::get<Is>(other.knownColumns()))),
      ...);
   }(tuple_indices<decltype(knownColumns())>{});
   m_knownColumns = other.m_knownColumns;
 
   for (auto &[name, column] : other.m_dynamicColumns) {
     std::unique_ptr<ColumnHolderBase> columnCopy = column->copy();
     m_allColumns.try_emplace(name, columnCopy.get());
     m_dynamicColumns.try_emplace(name, std::move(columnCopy));
   }
 }
 
 void SpacePointContainer::moveColumns(SpacePointContainer &other) noexcept {
   m_allColumns.reserve(other.m_allColumns.size());
   m_dynamicColumns.reserve(other.m_dynamicColumns.size());
 
   const auto moveKnownColumns =
       [&]<typename T>(std::string_view name,
                       std::optional<ColumnHolder<T>> &column,
                       std::optional<ColumnHolder<T>> &otherColumn) {
         column = std::move(otherColumn);
         if (column.has_value()) {
           m_allColumns.try_emplace(std::string(name), &column.value());
         }
       };
 
   [&]<std::size_t... Is>(std::index_sequence<Is...>) {
     ((moveKnownColumns(std::get<Is>(knownColumnNames()),
                        std::get<Is>(knownColumns()),
                        std::get<Is>(other.knownColumns()))),
      ...);
   }(tuple_indices<decltype(knownColumns())>{});
   m_knownColumns = other.m_knownColumns;
 
   for (auto &[name, column] : other.m_dynamicColumns) {
     m_allColumns.try_emplace(name, column.get());
     m_dynamicColumns.try_emplace(name, std::move(column));
   }
 
   other.m_allColumns.clear();
   other.m_knownColumns = SpacePointColumns::None;
   other.m_dynamicColumns.clear();
 }
 
 void SpacePointContainer::reserve(std::uint32_t size,
                                   float averageSourceLinks) noexcept {
   if (hasColumns(SpacePointColumns::SourceLinks)) {
     m_sourceLinks.reserve(
         static_cast<std::uint32_t>(size * averageSourceLinks));
   }
 
   for (const auto &[name, column] : m_allColumns) {
     column->reserve(size);
   }
 }
 
 void SpacePointContainer::clear() noexcept {
   m_size = 0;
   m_sourceLinks.clear();
 
   for (const auto &[name, column] : m_allColumns) {
     column->clear();
   }
 }
 
 MutableSpacePointProxy SpacePointContainer::createSpacePoint() noexcept {
   ++m_size;
 
   for (const auto &[name, column] : m_allColumns) {
     column->emplace_back();
   }
 
   return MutableProxy(*this, size() - 1);
 }
 
 void SpacePointContainer::copyFrom(Index index,
                                    const SpacePointContainer &otherContainer,
                                    Index otherIndex,
                                    SpacePointColumns columnsToCopy) {
   if (index >= size() || otherIndex >= otherContainer.size()) {
     throw std::out_of_range(
         "Index out of range in SpacePointContainer::copyFrom");
   }
   if ((columnsToCopy & otherContainer.m_knownColumns) != columnsToCopy) {
     throw std::logic_error(
         "Source container does not have all columns to copy");
   }
   if ((columnsToCopy & m_knownColumns) != columnsToCopy) {
     throw std::logic_error(
         "Destination container does not have all columns to copy");
   }
 
   if (ACTS_CHECK_BIT(columnsToCopy, SpacePointColumns::SourceLinks)) {
     at(index).assignSourceLinks(otherContainer[otherIndex].sourceLinks());
   }
 
   const auto copyColumn =
       [&]<typename T>(SpacePointColumns mask,
                       std::optional<ColumnHolder<T>> &destinationColumn,
                       const std::optional<ColumnHolder<T>> &sourceColumn) {
         if (mask == SpacePointColumns::SourceLinks) {
           // already handled above
           return;
         }
         if (ACTS_CHECK_BIT(columnsToCopy, mask)) {
           assert(destinationColumn.has_value() &&
                  "Column is not available in destination container");
           assert(sourceColumn.has_value() &&
                  "Column is not available in source container");
           destinationColumn->proxy(*this)[index] =
               sourceColumn->proxy(otherContainer)[otherIndex];
         }
       };
 
   [&]<std::size_t... Is>(std::index_sequence<Is...>) {
     ((copyColumn(std::get<Is>(knownColumnMasks()), std::get<Is>(knownColumns()),
                  std::get<Is>(otherContainer.knownColumns()))),
      ...);
   }(tuple_indices<decltype(knownColumns())>{});
 }
 
 void SpacePointContainer::createColumns(SpacePointColumns columns) noexcept {
   using enum SpacePointColumns;
 
   const auto createColumn =
       [&]<typename T>(SpacePointColumns mask, std::string_view name,
                       T defaultValue, std::optional<ColumnHolder<T>> &column) {
         if (ACTS_CHECK_BIT(columns, mask) && !column.has_value()) {
           column = ColumnHolder<T>(std::move(defaultValue));
           column->resize(size());
           m_allColumns.try_emplace(std::string(name), &column.value());
           m_knownColumns = m_knownColumns | mask;
         }
       };
 
   [&]<std::size_t... Is>(std::index_sequence<Is...>) {
     ((createColumn(
          std::get<Is>(knownColumnMasks()), std::get<Is>(knownColumnNames()),
          std::get<Is>(knownColumnDefaults()), std::get<Is>(knownColumns()))),
      ...);
   }(tuple_indices<decltype(knownColumns())>{});
 }
 
 void SpacePointContainer::dropColumns(SpacePointColumns columns) noexcept {
   using enum SpacePointColumns;
 
   const auto dropColumn = [&]<typename T>(
                               SpacePointColumns mask, std::string_view name,
                               std::optional<ColumnHolder<T>> &column) {
     if (ACTS_CHECK_BIT(columns, mask) && column.has_value()) {
       m_allColumns.erase(std::string(name));
       column.reset();
       m_knownColumns = m_knownColumns & ~mask;
     }
   };
 
   [&]<std::size_t... Is>(std::index_sequence<Is...>) {
     ((dropColumn(std::get<Is>(knownColumnMasks()),
                  std::get<Is>(knownColumnNames()),
                  std::get<Is>(knownColumns()))),
      ...);
   }(tuple_indices<decltype(knownColumns())>{});
 
   if (ACTS_CHECK_BIT(columns, SpacePointColumns::SourceLinks)) {
     m_sourceLinks.clear();
   }
 }
 
 void SpacePointContainer::dropColumn(const std::string &name) {
   if (reservedColumn(name)) {
     throw std::runtime_error("Cannot drop reserved column: " + name);
   }
 
   auto it = m_allColumns.find(name);
   if (it == m_allColumns.end()) {
     throw std::runtime_error("Column does not exist: " + name);
   }
 
   m_allColumns.erase(it);
   m_dynamicColumns.erase(name);
 }
 
 bool SpacePointContainer::reservedColumn(const std::string &name) noexcept {
   static const auto reservedColumns = std::apply(
       [](auto... reservedNames) {
         return std::unordered_set<std::string, std::hash<std::string_view>,
                                   std::equal_to<>>({reservedNames...});
       },
       knownColumnNames());
 
   return reservedColumns.contains(name);
 }
 
 }  // namespace Acts

This page was automatically generated by the 2.3.7 LXR engine. The LXR team