Acts::TrackStateProxyConcept Concept Reference

#include <Acts/EventData/TrackStateProxyConcept.hpp>

Concept definition

template<typename T>
concept Acts::TrackStateProxyConcept = 
    requires(const T& cv, T v, HashedString key,
             std::shared_ptr<const Surface> surface) {
      { cv.index() } -> std::same_as<TrackIndexType>;
 
      { cv.previous() } -> std::same_as<TrackIndexType>;
 
      { cv.hasPrevious() } -> std::same_as<bool>;
 
      { cv.getMask() } -> std::same_as<TrackStatePropMask>;
 
      { cv.referenceSurface() } -> std::same_as<const Surface&>;
 
      { cv.hasReferenceSurface() } -> std::same_as<bool>;
 
      { cv.template has<hashString("blubb")>() } -> std::same_as<bool>;
 
      { cv.has(key) } -> std::same_as<bool>;
 
      { cv.has("blubb") } -> std::same_as<bool>;
 
      
      {
        cv.template component<int, hashString("blubb")>()
      } -> std::same_as<const int&>;
 
      { cv.template component<int>(key) } -> std::same_as<const int&>;
 
      { cv.parameters() } -> std::same_as<detail::ConstParameters>;
      { cv.covariance() } -> std::same_as<detail::ConstCovariance>;
 
      { cv.predicted() } -> std::same_as<detail::ConstParameters>;
      { cv.predictedCovariance() } -> std::same_as<detail::ConstCovariance>;
      { cv.hasPredicted() } -> std::same_as<bool>;
      { v.hasPredicted() } -> std::same_as<bool>;
 
      { cv.filtered() } -> std::same_as<detail::ConstParameters>;
      { cv.filteredCovariance() } -> std::same_as<detail::ConstCovariance>;
      { cv.hasFiltered() } -> std::same_as<bool>;
      { v.hasFiltered() } -> std::same_as<bool>;
 
      { cv.smoothed() } -> std::same_as<detail::ConstParameters>;
      { cv.smoothedCovariance() } -> std::same_as<detail::ConstCovariance>;
      { cv.hasSmoothed() } -> std::same_as<bool>;
      { v.hasSmoothed() } -> std::same_as<bool>;
 
      { cv.jacobian() } -> std::same_as<detail::ConstCovariance>;
      { cv.hasJacobian() } -> std::same_as<bool>;
      { v.hasJacobian() } -> std::same_as<bool>;
 
      { cv.hasProjector() } -> std::same_as<bool>;
      { v.hasProjector() } -> std::same_as<bool>;
 
      { v.projectorSubspaceIndices() } -> std::same_as<BoundSubspaceIndices>;
      { cv.projectorSubspaceIndices() } -> std::same_as<BoundSubspaceIndices>;
 
      {
        v.template projectorSubspaceIndices<4>()
      } -> std::same_as<SubspaceIndices<4>>;
      {
        cv.template projectorSubspaceIndices<4>()
      } -> std::same_as<SubspaceIndices<4>>;
 
      {
        v.projectorSubspaceHelper()
      } -> std::same_as<VariableBoundSubspaceHelper>;
      {
        cv.projectorSubspaceHelper()
      } -> std::same_as<VariableBoundSubspaceHelper>;
 
      {
        v.template projectorSubspaceHelper<4>()
      } -> std::same_as<FixedBoundSubspaceHelper<4>>;
      {
        cv.template projectorSubspaceHelper<4>()
      } -> std::same_as<FixedBoundSubspaceHelper<4>>;
 
      { cv.getUncalibratedSourceLink() } -> std::same_as<SourceLink>;
      { v.getUncalibratedSourceLink() } -> std::same_as<SourceLink>;
 
      { cv.hasCalibrated() } -> std::same_as<bool>;
      { v.hasCalibrated() } -> std::same_as<bool>;
 
      { cv.template calibrated<2>() } -> std::same_as<detail::ConstMeasurement>;
      {
        cv.template calibratedCovariance<2>()
      } -> std::same_as<detail::ConstMeasurementCovariance>;
 
      {
        cv.effectiveCalibrated()
      } -> std::same_as<detail::ConstDynamicMeasurement>;
      {
        cv.effectiveCalibratedCovariance()
      } -> std::same_as<detail::ConstDynamicMeasurementCovariance>;
 
      { cv.calibratedSize() } -> std::same_as<TrackIndexType>;
      { v.calibratedSize() } -> std::same_as<TrackIndexType>;
 
      { cv.chi2() } -> std::same_as<float>;
 
      { cv.pathLength() } -> std::same_as<double>;
 
      { cv.typeFlags() } -> std::same_as<ConstTrackStateTypeMap>;
    }