EIC code displayed by LXR master/​include/​Acts/​EventData/​SeedProxy2.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-12-13 09:38:48

 // 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/.
 
 #pragma once
 
 #include "Acts/EventData/SpacePointContainer2.hpp"
 #include "Acts/Utilities/TypeTraits.hpp"
 
 #include <cassert>
 
 namespace Acts {
 
 class SeedContainer2;
 
 /// A proxy class for accessing individual seeds.
 template <bool read_only>
 class SeedProxy2 {
  public:
   /// Indicates whether this seed proxy is read-only or if it can be
   /// modified
   static constexpr bool ReadOnly = read_only;
 
   /// Type alias for seed index type
   using IndexType = SeedIndex2;
 
   /// Type alias for container type (const if read-only)
   using ContainerType = const_if_t<ReadOnly, SeedContainer2>;
 
   /// Constructs a seed proxy for the given container and index.
   /// @param container The container holding the seed.
   /// @param index The index of the seed in the container.
   SeedProxy2(ContainerType &container, IndexType index) noexcept
       : m_container{&container}, m_index{index} {}
 
   /// Copy construct a seed proxy.
   /// @param other The seed proxy to copy.
   SeedProxy2(const SeedProxy2 &other) noexcept = default;
 
   /// Copy construct a mutable seed proxy.
   /// @param other The mutable seed proxy to copy.
   explicit SeedProxy2(const SeedProxy2<false> &other) noexcept
     requires ReadOnly
       : m_container(&other.container()), m_index(other.index()) {}
 
   /// Gets the container holding the seed.
   /// @return A reference to the container holding the seed.
   SeedContainer2 &container() noexcept
     requires ReadOnly
   {
     return *m_container;
   }
   /// Gets the container holding the seed.
   /// @return A const reference to the container holding the seed.
   const SeedContainer2 &container() const noexcept { return *m_container; }
   /// Gets the index of the seed in the container.
   /// @return The index of the seed in the container.
   IndexType index() const noexcept { return m_index; }
 
   /// Assigns space point indices to the seed at the given index.
   /// @param spacePointIndices A span of space point indices to assign to the seed.
   /// @throws std::out_of_range if the index is out of range.
   /// @throws std::logic_error if space point indices are already assigned to the seed.
   void assignSpacePointIndices(
       std::span<const SpacePointIndex2> spacePointIndices)
     requires(!ReadOnly)
   {
     m_container->assignSpacePointIndices(m_index, spacePointIndices);
   }
 
   /// Returns the size of the seed, i.e., the number of space points
   /// associated with it.
   /// @return The number of space points in the seed.
   [[nodiscard]] std::size_t size() const noexcept {
     return m_container->spacePointIndices(m_index).size();
   }
   /// Checks if the seed is empty, i.e., has no space points associated with it.
   /// @return True if the seed is empty, false otherwise.
   [[nodiscard]]
   bool empty() const noexcept {
     return size() == 0;
   }
 
   /// Mutable access to the space point indices of the seed.
   /// @return A mutable span of space point indices associated with the seed.
   std::span<SpacePointIndex2> spacePointIndices() noexcept
     requires(!ReadOnly)
   {
     return m_container->spacePointIndices(m_index);
   }
   /// Mutable access to the quality of the seed.
   /// @return A mutable reference to the quality of the seed.
   float &quality() noexcept
     requires(!ReadOnly)
   {
     return m_container->quality(m_index);
   }
   /// Mutable access to the vertex Z coordinate of the seed.
   /// @return A mutable reference to the vertex Z coordinate of the seed.
   float &vertexZ() noexcept
     requires(!ReadOnly)
   {
     return m_container->vertexZ(m_index);
   }
 
   /// Const access to the space point indices of the seed.
   /// @return A span of space point indices associated with the seed.
   ///         This span is read-only and cannot be modified.
   std::span<const SpacePointIndex2> spacePointIndices() const noexcept {
     return m_container->spacePointIndices(m_index);
   }
   /// Const access to the quality of the seed.
   /// @return The quality of the seed.
   float quality() const noexcept { return m_container->quality(m_index); }
   /// Const access to the vertex Z coordinate of the seed.
   /// @return The vertex Z coordinate of the seed.
   float vertexZ() const noexcept { return m_container->vertexZ(m_index); }
 
   class SpacePointIterator {
    public:
     using value_type = ConstSpacePointProxy2;
     using difference_type = std::ptrdiff_t;
     using pointer = void;
     using reference = void;
 
     using iterator_category = std::random_access_iterator_tag;
     using iterator_concept = std::random_access_iterator_tag;
 
     SpacePointIterator() = default;
     SpacePointIterator(const SpacePointContainer2 &spacePointContainer,
                        const SpacePointIndex2 *indexPointer) noexcept
         : m_spacePointContainer{&spacePointContainer},
           m_indexPointer{indexPointer} {}
 
     value_type operator*() const noexcept {
       return (*m_spacePointContainer)[*m_indexPointer];
     }
     value_type operator[](difference_type n) const noexcept {
       return (*m_spacePointContainer)[m_indexPointer[n]];
     }
 
     constexpr SpacePointIterator &operator++() noexcept {
       ++m_indexPointer;
       return *this;
     }
     constexpr SpacePointIterator operator++(int) noexcept {
       auto tmp = *this;
       ++(*this);
       return tmp;
     }
     constexpr SpacePointIterator &operator--() noexcept {
       --m_indexPointer;
       return *this;
     }
     constexpr SpacePointIterator operator--(int) noexcept {
       auto tmp = *this;
       --(*this);
       return tmp;
     }
 
     constexpr SpacePointIterator &operator+=(difference_type n) noexcept {
       m_indexPointer += n;
       return *this;
     }
     constexpr SpacePointIterator &operator-=(difference_type n) noexcept {
       m_indexPointer -= n;
       return *this;
     }
 
    private:
     const SpacePointContainer2 *m_spacePointContainer{nullptr};
     const SpacePointIndex2 *m_indexPointer{nullptr};
 
     friend constexpr SpacePointIterator operator+(SpacePointIterator it,
                                                   difference_type n) noexcept {
       return it += n;
     }
 
     friend constexpr SpacePointIterator operator+(
         difference_type n, SpacePointIterator it) noexcept {
       return it += n;
     }
 
     friend constexpr SpacePointIterator operator-(SpacePointIterator it,
                                                   difference_type n) noexcept {
       return it -= n;
     }
 
     friend constexpr difference_type operator-(
         const SpacePointIterator &lhs, const SpacePointIterator &rhs) noexcept {
       return lhs.m_indexPointer - rhs.m_indexPointer;
     }
 
     friend constexpr auto operator<=>(const SpacePointIterator &a,
                                       const SpacePointIterator &b) noexcept {
       return a.m_indexPointer <=> b.m_indexPointer;
     }
     friend constexpr bool operator==(const SpacePointIterator &a,
                                      const SpacePointIterator &b) noexcept {
       return a.m_indexPointer == b.m_indexPointer;
     }
   };
 
   class SpacePointRange {
    public:
     SpacePointRange(
         const SpacePointContainer2 &spacePointContainer,
         std::span<const SpacePointIndex2> spacePointIndices) noexcept
         : m_spacePointContainer{&spacePointContainer},
           m_spacePointIndices{spacePointIndices} {}
 
     std::size_t size() const noexcept { return m_spacePointIndices.size(); }
     bool empty() const noexcept { return size() == 0; }
 
     ConstSpacePointProxy2 operator[](std::size_t index) const noexcept {
       return (*m_spacePointContainer)[m_spacePointIndices[index]];
     }
 
     SpacePointIterator begin() const noexcept {
       return SpacePointIterator(*m_spacePointContainer,
                                 m_spacePointIndices.data());
     }
     SpacePointIterator end() const noexcept {
       return SpacePointIterator(
           *m_spacePointContainer,
           m_spacePointIndices.data() + m_spacePointIndices.size());
     }
 
    private:
     const SpacePointContainer2 *m_spacePointContainer{nullptr};
     std::span<const SpacePointIndex2> m_spacePointIndices;
   };
 
   /// Get the space points associated with this seed.
   /// @param spacePointContainer Container holding all space points
   /// @return Range of space points for this seed
   SpacePointRange spacePoints(
       const SpacePointContainer2 &spacePointContainer) const noexcept {
     return SpacePointRange(spacePointContainer,
                            m_container->spacePointIndices(m_index));
   }
 
  private:
   ContainerType *m_container{nullptr};
   IndexType m_index{0};
 };
 
 }  // namespace Acts

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