align constness with track edm

Author: andiwand

Core/include/Acts/EventData/SpacePointColumnProxy2.hpp

@@ -26,18 +26,30 @@ class SpacePointColumnProxy {
  public:
   constexpr static bool ReadOnly = read_only;
   using Index = SpacePointIndex2;
-  using Value = const_if_t<ReadOnly, T>;
+  using Value = T;
   using Container = const_if_t<ReadOnly, SpacePointContainer2>;
-  using Column = const_if_t<ReadOnly, std::vector<T>>;
-  using Span = std::span<Value>;
-  using Reference = Value &;
+  using Column = const_if_t<ReadOnly, std::vector<Value>>;
 
+  /// Constructs a space point column proxy for the given container and column.
+  /// @param container The container holding the space point.
+  /// @param column The column of data to access.
   SpacePointColumnProxy(Container &container, Column &column)
       : m_container{&container}, m_column(&column) {}
 
+  /// Copy construct a space point column proxy.
+  /// @param other The space point column proxy to copy.
+  SpacePointColumnProxy(const SpacePointColumnProxy &other) noexcept = default;
+
+  /// Copy construct a mutable space point column proxy.
+  /// @param other The mutable space point column proxy to copy.
+  explicit SpacePointColumnProxy(
+      const SpacePointColumnProxy<T, false> &other) noexcept
+    requires ReadOnly
+      : m_container(&other.container()), m_column(&other.column()) {}
+
   /// Gets the container holding the space point.
   /// @return A reference to the container holding the space point.
-  SpacePointContainer2 &container() const noexcept
+  SpacePointContainer2 &container() noexcept
     requires(!ReadOnly)
   {
     return *m_container;
@@ -50,18 +62,42 @@ class SpacePointColumnProxy {
 
   /// Returns a const reference to the column container.
   /// @return A const reference to the column container.
-  const Column &column() const noexcept { return *m_column; }
+  const std::vector<Value> &column() const noexcept { return *m_column; }
 
-  /// Returns a span to the column data.
-  /// @return A span to the column data.
-  Span data() const noexcept { return Span(column().data(), column().size()); }
+  /// Returns a mutable span to the column data.
+  /// @return A mutable span to the column data.
+  std::span<Value> data() noexcept
+    requires(!ReadOnly)
+  {
+    return std::span<Value>(column().data(), column().size());
+  }
+  /// Returns a const span to the column data.
+  /// @return A const span to the column data.
+  std::span<const Value> data() const noexcept {
+    return std::span<const Value>(column().data(), column().size());
+  }
 
-  /// Returns a reference to the column entry at the given index.
+  /// Returns a mutable reference to the column entry at the given index.
+  /// If the index is out of range, an exception is thrown.
+  /// @param index The index of the space point to access.
+  /// @return A mutable reference to the column entry at the given index.
+  /// @throws std::out_of_range if the index is out of range.
+  Value &at(Index index)
+    requires(!ReadOnly)
+  {
+    if (index >= column().size()) {
+      throw std::out_of_range("Index out of range in SpacePointContainer2: " +
+                              std::to_string(index) +
+                              " >= " + std::to_string(size()));
+    }
+    return data()[index];
+  }
+  /// Returns a const reference to the column entry at the given index.
   /// If the index is out of range, an exception is thrown.
   /// @param index The index of the space point to access.
-  /// @return A reference to the column entry at the given index.
+  /// @return A const reference to the column entry at the given index.
   /// @throws std::out_of_range if the index is out of range.
-  Reference at(Index index) const {
+  const Value &at(Index index) const {
     if (index >= column().size()) {
       throw std::out_of_range("Index out of range in SpacePointContainer2: " +
                               std::to_string(index) +
@@ -70,10 +106,19 @@ class SpacePointColumnProxy {
     return data()[index];
   }
 
-  /// Returns a reference to the column entry at the given index.
+  /// Returns a mutable reference to the column entry at the given index.
+  /// @param index The index of the space point to access.
+  /// @return A mutable reference to the column entry at the given index.
+  Value &operator[](Index index) noexcept
+    requires(!ReadOnly)
+  {
+    assert(index < column().size() && "Index out of bounds");
+    return data()[index];
+  }
+  /// Returns a const reference to the column entry at the given index.
   /// @param index The index of the space point to access.
-  /// @return A reference to the column entry at the given index.
-  Reference operator[](Index index) const noexcept {
+  /// @return A const reference to the column entry at the given index.
+  const Value &operator[](Index index) const noexcept {
     assert(index < column().size() && "Index out of bounds");
     return data()[index];
   }
@@ -84,7 +129,7 @@ class SpacePointColumnProxy {
 
   std::uint32_t size() const noexcept { return column().size(); }
 
-  Column &column() const noexcept
+  std::vector<Value> &column() noexcept
     requires(!ReadOnly)
   {
     return *m_column;

Core/include/Acts/EventData/SpacePointProxy2.hpp

@@ -185,7 +185,7 @@ class SpacePointProxy2 {
   /// @param column The extra column proxy to access.
   /// @return A mutable reference to the value in the extra column for the space point.
   template <typename T>
-  T &extra(const MutableSpacePointColumnProxy<T> &column) const noexcept {
+  T &extra(MutableSpacePointColumnProxy<T> &column) const noexcept {
     return column[m_index];
   }