Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2025-05-29 03:17:35

0001 #ifndef DataFormats_SoATemplate_interface_SoAView_h
0002 #define DataFormats_SoATemplate_interface_SoAView_h
0003 
0004 /*
0005  * Structure-of-Arrays templates allowing access to a selection of scalars and columns from one
0006  * or multiple SoA layouts or views.
0007  * This template generator will allow handling subsets of columns from one or multiple SoA views or layouts.
0008  */
0009 
0010 #include "SoACommon.h"
0011 
0012 #define SOA_VIEW_LAYOUT(TYPE, NAME) (TYPE, NAME)
0013 
0014 #define SOA_VIEW_LAYOUT_LIST(...) __VA_ARGS__
0015 
0016 #define SOA_VIEW_VALUE(LAYOUT_NAME, LAYOUT_MEMBER) (LAYOUT_NAME, LAYOUT_MEMBER, LAYOUT_MEMBER)
0017 
0018 #define SOA_VIEW_VALUE_RENAME(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME) (LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME)
0019 
0020 #define SOA_VIEW_VALUE_LIST(...) __VA_ARGS__
0021 
0022 /*
0023  * A macro defining a SoA view (collection of columns from multiple layouts or views.)
0024  *
0025  * Usage:
0026  * GENERATE_SOA_VIEW(PixelXYConstView, PixelXYView,
0027  *   SOA_VIEW_LAYOUT_LIST(
0028  *     SOA_VIEW_LAYOUT(PixelDigis,         pixelDigis),
0029  *     SOA_VIEW_LAYOUT(PixelRecHitsLayout, pixelsRecHit)
0030  *   ),
0031  *   SOA_VIEW_VALUE_LIST(
0032  *     SOA_VIEW_VALUE_RENAME(pixelDigis,   x,   digisX),
0033  *     SOA_VIEW_VALUE_RENAME(pixelDigis,   y,   digisY),
0034  *     SOA_VIEW_VALUE_RENAME(pixelsRecHit, x, recHitsX),
0035  *     SOA_VIEW_VALUE_RENAME(pixelsRecHit, y, recHitsY)
0036  *   )
0037  * );
0038  *
0039  */
0040 
0041 namespace cms::soa {
0042 
0043   /* Traits for the different column type scenarios */
0044   /* Value traits passes the class as is in the case of column type and return
0045    * an empty class with functions returning non-scalar as accessors. */
0046   template <class C, SoAColumnType COLUMN_TYPE>
0047   struct ConstValueTraits : public C {
0048     using C::C;
0049   };
0050 
0051   template <class C>
0052   struct ConstValueTraits<C, SoAColumnType::scalar> {
0053     // Just take to SoAValue type to generate the right constructor.
0054     SOA_HOST_DEVICE SOA_INLINE ConstValueTraits(size_type, const typename C::valueType*) {}
0055     SOA_HOST_DEVICE SOA_INLINE ConstValueTraits(size_type, const typename C::Params&) {}
0056     SOA_HOST_DEVICE SOA_INLINE ConstValueTraits(size_type, const typename C::ConstParams&) {}
0057     // Any attempt to do anything with the "scalar" value a const element will fail.
0058   };
0059 
0060 }  // namespace cms::soa
0061 
0062 /*
0063  * Members definitions macros for views
0064  */
0065 
0066 /**
0067  * Layout templates parametrization
0068  */
0069 #define _DECLARE_VIEW_LAYOUT_PARAMETRIZED_TEMPLATE_IMPL(TYPE, NAME)                            \
0070   (using BOOST_PP_CAT(TYPE, _default) = BOOST_PP_CAT(TYPE, _StagedTemplates) < VIEW_ALIGNMENT, \
0071    VIEW_ALIGNMENT_ENFORCEMENT > ;)
0072 
0073 #define _DECLARE_VIEW_LAYOUT_PARAMETRIZED_TEMPLATE(R, DATA, TYPE_NAME) \
0074   BOOST_PP_EXPAND(_DECLARE_VIEW_LAYOUT_PARAMETRIZED_TEMPLATE_IMPL TYPE_NAME)
0075 
0076 /**
0077  * Layout types aliasing for referencing by name
0078  */
0079 #define _DECLARE_VIEW_LAYOUT_TYPE_ALIAS_IMPL(TYPE, NAME) using BOOST_PP_CAT(TypeOf_, NAME) = TYPE;
0080 
0081 #define _DECLARE_VIEW_LAYOUT_TYPE_ALIAS(R, DATA, TYPE_NAME) \
0082   BOOST_PP_EXPAND(_DECLARE_VIEW_LAYOUT_TYPE_ALIAS_IMPL TYPE_NAME)
0083 
0084 /**
0085  * Member types aliasing for referencing by name
0086  */
0087 // clang-format off
0088 #define _DECLARE_VIEW_MEMBER_TYPE_ALIAS_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME, CAST)                             \
0089   using BOOST_PP_CAT(TypeOf_, LOCAL_NAME) =                                                                            \
0090       typename BOOST_PP_CAT(TypeOf_, LAYOUT_NAME)::Metadata::BOOST_PP_CAT(TypeOf_, LAYOUT_MEMBER);                     \
0091   using BOOST_PP_CAT(ParametersTypeOf_, LOCAL_NAME) =                                                                  \
0092       typename BOOST_PP_CAT(TypeOf_, LAYOUT_NAME)::Metadata::BOOST_PP_CAT(ParametersTypeOf_, LAYOUT_MEMBER);           \
0093   constexpr static cms::soa::SoAColumnType BOOST_PP_CAT(ColumnTypeOf_, LOCAL_NAME) =                                   \
0094       BOOST_PP_CAT(TypeOf_, LAYOUT_NAME)::Metadata::BOOST_PP_CAT(ColumnTypeOf_, LAYOUT_MEMBER);                        \
0095   using BOOST_PP_CAT(ConstAccessorOf_, LOCAL_NAME) =                                                                   \
0096     typename cms::soa::SoAAccessors<typename BOOST_PP_CAT(Metadata::TypeOf_, LOCAL_NAME)>::                            \
0097         template ColumnType<BOOST_PP_CAT(ColumnTypeOf_, LOCAL_NAME)>::template AccessType<                             \
0098             cms::soa::SoAAccessType::constAccess>::template Alignment<conditionalAlignment>::                          \
0099                 template RestrictQualifier<restrictQualify> ;                                                          \
0100   using BOOST_PP_CAT(MutableAccessorOf_, LOCAL_NAME) =                                                                 \
0101     typename cms::soa::SoAAccessors<typename BOOST_PP_CAT(Metadata::TypeOf_, LOCAL_NAME)>::                            \
0102         template ColumnType<BOOST_PP_CAT(ColumnTypeOf_, LOCAL_NAME)>::template AccessType<                             \
0103             cms::soa::SoAAccessType::mutableAccess>::template Alignment<conditionalAlignment>::                        \
0104                 template RestrictQualifier<restrictQualify> ;                                                          \
0105   SOA_HOST_DEVICE SOA_INLINE                                                                                           \
0106   const auto BOOST_PP_CAT(parametersOf_, LOCAL_NAME)() const {                                                         \
0107     return CAST(parent_.BOOST_PP_CAT(LOCAL_NAME, Parameters_));                                                        \
0108   };
0109 // clang-format on
0110 
0111 // DATA should be a function used to convert
0112 //   parent_.LOCAL_NAME ## Parameters_
0113 // to
0114 //   ParametersTypeOf_ ## LOCAL_NAME                (for a View)
0115 // or
0116 //   ParametersTypeOf_ ## LOCAL_NAME :: ConstType   (for a ConstView)
0117 // or empty, if no conversion is necessary.
0118 #define _DECLARE_VIEW_MEMBER_TYPE_ALIAS(R, DATA, LAYOUT_MEMBER_NAME) \
0119   BOOST_PP_EXPAND(_DECLARE_VIEW_MEMBER_TYPE_ALIAS_IMPL BOOST_PP_TUPLE_PUSH_BACK(LAYOUT_MEMBER_NAME, DATA))
0120 
0121 /**
0122  * Member type pointers for referencing by name
0123  */
0124 // clang-format off
0125 #define _DECLARE_VIEW_MEMBER_POINTERS_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME)                                     \
0126   SOA_HOST_DEVICE SOA_INLINE auto* BOOST_PP_CAT(addressOf_, LOCAL_NAME)() {                                            \
0127     return BOOST_PP_CAT(parametersOf_, LOCAL_NAME)().addr_;                                                            \
0128   };
0129 // clang-format on
0130 
0131 #define _DECLARE_VIEW_MEMBER_POINTERS(R, DATA, LAYOUT_MEMBER_NAME) \
0132   BOOST_PP_EXPAND(_DECLARE_VIEW_MEMBER_POINTERS_IMPL LAYOUT_MEMBER_NAME)
0133 
0134 /**
0135  * Member type const pointers for referencing by name
0136  */
0137 // clang-format off
0138 #define _DECLARE_VIEW_MEMBER_CONST_POINTERS_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME)                               \
0139   SOA_HOST_DEVICE SOA_INLINE auto const* BOOST_PP_CAT(addressOf_, LOCAL_NAME)() const {                                \
0140     return BOOST_PP_CAT(parametersOf_, LOCAL_NAME)().addr_;                                                            \
0141   };
0142 // clang-format on
0143 
0144 #define _DECLARE_VIEW_MEMBER_CONST_POINTERS(R, DATA, LAYOUT_MEMBER_NAME) \
0145   BOOST_PP_EXPAND(_DECLARE_VIEW_MEMBER_CONST_POINTERS_IMPL LAYOUT_MEMBER_NAME)
0146 
0147 /**
0148  * Generator of parameters (layouts/views) for constructor by layouts/views.
0149  */
0150 #define _DECLARE_VIEW_CONSTRUCTION_PARAMETERS_IMPL(LAYOUT_TYPE, LAYOUT_NAME, DATA) (DATA LAYOUT_TYPE & LAYOUT_NAME)
0151 
0152 #define _DECLARE_VIEW_CONSTRUCTION_PARAMETERS(R, DATA, TYPE_NAME) \
0153   BOOST_PP_EXPAND(_DECLARE_VIEW_CONSTRUCTION_PARAMETERS_IMPL BOOST_PP_TUPLE_PUSH_BACK(TYPE_NAME, DATA))
0154 
0155 /**
0156  * Generator of parameters for constructor by column.
0157  */
0158 #define _DECLARE_VIEW_CONSTRUCTION_BYCOLUMN_PARAMETERS_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME, DATA) \
0159   (DATA typename BOOST_PP_CAT(Metadata::ParametersTypeOf_, LOCAL_NAME)::TupleOrPointerType LOCAL_NAME)
0160 
0161 #define _DECLARE_VIEW_CONSTRUCTION_BYCOLUMN_PARAMETERS(R, DATA, LAYOUT_MEMBER_NAME) \
0162   BOOST_PP_EXPAND(                                                                  \
0163       _DECLARE_VIEW_CONSTRUCTION_BYCOLUMN_PARAMETERS_IMPL BOOST_PP_TUPLE_PUSH_BACK(LAYOUT_MEMBER_NAME, DATA))
0164 
0165 /**
0166  * Generator of member initialization from constructor.
0167  * We use a lambda with auto return type to handle multiple possible return types.
0168  */
0169 // clang-format off
0170 #define _DECLARE_VIEW_MEMBER_INITIALIZERS_IMPL(LAYOUT, MEMBER, NAME)                                                   \
0171   (BOOST_PP_CAT(NAME, Parameters_)([&]() -> auto {                                                                     \
0172     auto params = LAYOUT.metadata().BOOST_PP_CAT(parametersOf_, MEMBER)();                                             \
0173     if constexpr (alignmentEnforcement == AlignmentEnforcement::enforced)                                              \
0174       if (reinterpret_cast<intptr_t>(params.addr_) % alignment)                                                        \
0175         throw std::runtime_error("In constructor by layout: misaligned column: " #NAME);                               \
0176     return params;                                                                                                     \
0177   }()))
0178 // clang-format on
0179 
0180 #define _DECLARE_VIEW_MEMBER_INITIALIZERS(R, DATA, LAYOUT_MEMBER_NAME) \
0181   BOOST_PP_EXPAND(_DECLARE_VIEW_MEMBER_INITIALIZERS_IMPL LAYOUT_MEMBER_NAME)
0182 
0183 /**
0184  * Generator of size computation for constructor.
0185  * This is the per-layout part of the lambda checking they all have the same size.
0186  */
0187 // clang-format off
0188 #define _UPDATE_SIZE_OF_VIEW_IMPL(LAYOUT_TYPE, LAYOUT_NAME)                                                            \
0189   if (set) {                                                                                                           \
0190     if (ret != LAYOUT_NAME.metadata().size())                                                                          \
0191       throw std::runtime_error("In constructor by layout: different sizes from layouts.");                             \
0192   } else {                                                                                                             \
0193     ret = LAYOUT_NAME.metadata().size();                                                                               \
0194     set = true;                                                                                                        \
0195   }
0196 // clang-format on
0197 
0198 #define _UPDATE_SIZE_OF_VIEW(R, DATA, TYPE_NAME) BOOST_PP_EXPAND(_UPDATE_SIZE_OF_VIEW_IMPL TYPE_NAME)
0199 
0200 /**
0201  * Generator of member initialization from constructor.
0202  * We use a lambda with auto return type to handle multiple possible return types.
0203  */
0204 // clang-format off
0205 #define _DECLARE_VIEW_MEMBER_INITIALIZERS_BYCOLUMN_IMPL(LAYOUT, MEMBER, NAME)                                          \
0206   (                                                                                                                    \
0207     BOOST_PP_CAT(NAME, Parameters_)([&]() -> auto {                                                                    \
0208       if constexpr (alignmentEnforcement == AlignmentEnforcement::enforced)                                            \
0209         if (Metadata:: BOOST_PP_CAT(ParametersTypeOf_, NAME)::checkAlignment(NAME, alignment))                         \
0210           throw std::runtime_error("In constructor by column: misaligned column: " #NAME);                             \
0211       return NAME;                                                                                                     \
0212     }())                                                                                                               \
0213   )
0214 // clang-format on
0215 
0216 #define _DECLARE_VIEW_MEMBER_INITIALIZERS_BYCOLUMN(R, DATA, LAYOUT_MEMBER_NAME) \
0217   BOOST_PP_EXPAND(_DECLARE_VIEW_MEMBER_INITIALIZERS_BYCOLUMN_IMPL LAYOUT_MEMBER_NAME)
0218 
0219 /**
0220  * Generator of layout list.
0221  */
0222 #define _DECLARE_LAYOUT_LIST_IMPL(LAYOUT, NAME) (NAME)
0223 
0224 #define _DECLARE_LAYOUT_LIST(R, DATA, LAYOUT_MEMBER_NAME) BOOST_PP_EXPAND(_DECLARE_LAYOUT_LIST_IMPL LAYOUT_MEMBER_NAME)
0225 
0226 /**
0227  * Generator of view member list.
0228  */
0229 #define _DECLARE_VIEW_MEMBER_LIST_IMPL(LAYOUT, MEMBER, NAME) (NAME)
0230 
0231 #define _DECLARE_VIEW_MEMBER_LIST(R, DATA, LAYOUT_MEMBER_NAME) \
0232   BOOST_PP_EXPAND(_DECLARE_VIEW_MEMBER_LIST_IMPL LAYOUT_MEMBER_NAME)
0233 
0234 /**
0235  * Generator of view member list.
0236  */
0237 #define _DECLARE_VIEW_OTHER_MEMBER_LIST_IMPL(LAYOUT, MEMBER, NAME) \
0238   (const_cast_SoAParametersImpl(other.BOOST_PP_CAT(NAME, Parameters_)).tupleOrPointer())
0239 
0240 #define _DECLARE_VIEW_OTHER_MEMBER_LIST(R, DATA, LAYOUT_MEMBER_NAME) \
0241   BOOST_PP_EXPAND(_DECLARE_VIEW_OTHER_MEMBER_LIST_IMPL LAYOUT_MEMBER_NAME)
0242 
0243 /**
0244  * Generator of member initializer for copy constructor.
0245  */
0246 #define _DECLARE_VIEW_MEMBER_INITIALIZERS_FROM_OTHER_IMPL(LAYOUT, MEMBER, LOCAL_NAME, DATA) \
0247   (BOOST_PP_CAT(MEMBER, Parameters_){DATA.BOOST_PP_CAT(MEMBER, Parameters_)})
0248 
0249 #define _DECLARE_VIEW_MEMBER_INITIALIZERS_FROM_OTHER(R, DATA, LAYOUT_MEMBER_NAME) \
0250   BOOST_PP_EXPAND(_DECLARE_VIEW_MEMBER_INITIALIZERS_FROM_OTHER_IMPL BOOST_PP_TUPLE_PUSH_BACK(LAYOUT_MEMBER_NAME, DATA))
0251 
0252 /**
0253  * Generator of member assignment for assignment operator.
0254  */
0255 #define _DECLARE_VIEW_MEMBER_ASSIGNMENT_FROM_OTHER_IMPL(LAYOUT, MEMBER, LOCAL_NAME, DATA) \
0256   BOOST_PP_CAT(MEMBER, Parameters_) = DATA.BOOST_PP_CAT(MEMBER, Parameters_);
0257 
0258 #define _DECLARE_VIEW_MEMBER_ASSIGNMENT_FROM_OTHER(R, DATA, LAYOUT_MEMBER_NAME) \
0259   BOOST_PP_EXPAND(_DECLARE_VIEW_MEMBER_ASSIGNMENT_FROM_OTHER_IMPL BOOST_PP_TUPLE_PUSH_BACK(LAYOUT_MEMBER_NAME, DATA))
0260 
0261 /**
0262  * Generator of element members initializer.
0263  */
0264 #define _DECLARE_VIEW_ELEM_MEMBER_INIT_IMPL(LAYOUT, MEMBER, LOCAL_NAME, DATA) (LOCAL_NAME(DATA, LOCAL_NAME))
0265 
0266 #define _DECLARE_VIEW_ELEM_MEMBER_INIT(R, DATA, LAYOUT_MEMBER_NAME) \
0267   BOOST_PP_EXPAND(_DECLARE_VIEW_ELEM_MEMBER_INIT_IMPL BOOST_PP_TUPLE_PUSH_BACK(LAYOUT_MEMBER_NAME, DATA))
0268 
0269 /**
0270  * Helper macro extracting the data type from metadata of a layout or view
0271  */
0272 #define _COLUMN_TYPE(LAYOUT_NAME, LAYOUT_MEMBER) \
0273   typename std::remove_pointer<decltype(BOOST_PP_CAT(LAYOUT_NAME, Type)()::LAYOUT_MEMBER())>::type
0274 
0275 /**
0276  * Generator of parameters for (non-const) element subclass (expanded comma separated).
0277  */
0278 #define _DECLARE_VIEW_ELEMENT_VALUE_ARG_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME, DATA) \
0279   (DATA typename BOOST_PP_CAT(Metadata::ParametersTypeOf_, LOCAL_NAME) LOCAL_NAME)
0280 
0281 #define _DECLARE_VIEW_ELEMENT_VALUE_ARG(R, DATA, LAYOUT_MEMBER_NAME) \
0282   _DECLARE_VIEW_ELEMENT_VALUE_ARG_IMPL BOOST_PP_TUPLE_PUSH_BACK(LAYOUT_MEMBER_NAME, DATA)
0283 
0284 /**
0285  * Generator of parameters for (const) element subclass (expanded comma separated).
0286  */
0287 #define _DECLARE_CONST_VIEW_ELEMENT_VALUE_ARG_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME, DATA) \
0288   (DATA typename BOOST_PP_CAT(Metadata::ParametersTypeOf_, LOCAL_NAME)::ConstType LOCAL_NAME)
0289 
0290 #define _DECLARE_CONST_VIEW_ELEMENT_VALUE_ARG(R, DATA, LAYOUT_MEMBER_NAME) \
0291   _DECLARE_CONST_VIEW_ELEMENT_VALUE_ARG_IMPL BOOST_PP_TUPLE_PUSH_BACK(LAYOUT_MEMBER_NAME, DATA)
0292 
0293 /**
0294  * Generator of member initialization for constructor of element subclass
0295  */
0296 #define _DECLARE_VIEW_CONST_ELEM_MEMBER_INIT_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME, DATA) \
0297   (BOOST_PP_CAT(LOCAL_NAME, _)(DATA, LOCAL_NAME))
0298 
0299 /* declare AoS-like element value args for contructor; these should expand,for columns only */
0300 #define _DECLARE_VIEW_CONST_ELEM_MEMBER_INIT(R, DATA, LAYOUT_MEMBER_NAME) \
0301   BOOST_PP_EXPAND(_DECLARE_VIEW_CONST_ELEM_MEMBER_INIT_IMPL BOOST_PP_TUPLE_PUSH_BACK(LAYOUT_MEMBER_NAME, DATA))
0302 
0303 /**
0304  * Declaration of the members accessors of the const element subclass
0305  */
0306 // clang-format off
0307 #define _DECLARE_VIEW_CONST_ELEMENT_ACCESSOR_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME)                              \
0308   SOA_HOST_DEVICE SOA_INLINE                                                                                           \
0309       const typename SoAConstValueWithConf<BOOST_PP_CAT(Metadata::ColumnTypeOf_, LOCAL_NAME),                          \
0310       const typename BOOST_PP_CAT(Metadata::TypeOf_, LOCAL_NAME)>::RefToConst                                          \
0311       LOCAL_NAME() const {                                                                                             \
0312     return BOOST_PP_CAT(LOCAL_NAME, _)();                                                                              \
0313   }
0314 // clang-format on
0315 
0316 #define _DECLARE_VIEW_CONST_ELEMENT_ACCESSOR(R, DATA, LAYOUT_MEMBER_NAME) \
0317   _DECLARE_VIEW_CONST_ELEMENT_ACCESSOR_IMPL LAYOUT_MEMBER_NAME
0318 
0319 /**
0320  * Declaration of the private members of the const element subclass
0321  */
0322 // clang-format off
0323 #define _DECLARE_VIEW_CONST_ELEMENT_VALUE_MEMBER_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME)                          \
0324   const cms::soa::ConstValueTraits<SoAConstValueWithConf<BOOST_PP_CAT(Metadata::ColumnTypeOf_, LOCAL_NAME),            \
0325                                                          typename BOOST_PP_CAT(Metadata::TypeOf_, LOCAL_NAME)>,        \
0326                                    BOOST_PP_CAT(Metadata::ColumnTypeOf_, LOCAL_NAME)>                                  \
0327       BOOST_PP_CAT(LOCAL_NAME, _);
0328 // clang-format on
0329 
0330 #define _DECLARE_VIEW_CONST_ELEMENT_VALUE_MEMBER(R, DATA, LAYOUT_MEMBER_NAME) \
0331   _DECLARE_VIEW_CONST_ELEMENT_VALUE_MEMBER_IMPL LAYOUT_MEMBER_NAME
0332 
0333 /**
0334  * Generator of the member-by-member copy operator of the element subclass.
0335  */
0336 #define _DECLARE_VIEW_ELEMENT_VALUE_COPY_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME)                 \
0337   if constexpr (Metadata::BOOST_PP_CAT(ColumnTypeOf_, LOCAL_NAME) != cms::soa::SoAColumnType::scalar) \
0338     LOCAL_NAME() = _soa_impl_other.LOCAL_NAME();
0339 
0340 #define _DECLARE_VIEW_ELEMENT_VALUE_COPY(R, DATA, LAYOUT_MEMBER_NAME) \
0341   BOOST_PP_EXPAND(_DECLARE_VIEW_ELEMENT_VALUE_COPY_IMPL LAYOUT_MEMBER_NAME)
0342 
0343 /**
0344  * Declaration of the private members of the const element subclass
0345  */
0346 // clang-format off
0347 #define _DECLARE_VIEW_ELEMENT_VALUE_MEMBER_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME)                                \
0348   SoAValueWithConf<BOOST_PP_CAT(Metadata::ColumnTypeOf_, LOCAL_NAME),                                                  \
0349                    typename BOOST_PP_CAT(Metadata::TypeOf_, LOCAL_NAME)>                                               \
0350       LOCAL_NAME;
0351 // clang-format on
0352 
0353 #define _DECLARE_VIEW_ELEMENT_VALUE_MEMBER(R, DATA, LAYOUT_MEMBER_NAME) \
0354   _DECLARE_VIEW_ELEMENT_VALUE_MEMBER_IMPL LAYOUT_MEMBER_NAME
0355 
0356 /**
0357  * Parameters passed to const element subclass constructor in operator[]
0358  */
0359 #define _DECLARE_VIEW_CONST_ELEMENT_CONSTR_CALL_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME) \
0360   (BOOST_PP_CAT(LOCAL_NAME, Parameters_))
0361 
0362 #define _DECLARE_VIEW_CONST_ELEMENT_CONSTR_CALL(R, DATA, LAYOUT_MEMBER_NAME) \
0363   BOOST_PP_EXPAND(_DECLARE_VIEW_CONST_ELEMENT_CONSTR_CALL_IMPL LAYOUT_MEMBER_NAME)
0364 
0365 /**
0366  * Parameters passed to element subclass constructor in operator[]
0367  *
0368  * The use of const_cast (inside const_cast_SoAParametersImpl) is safe because the constructor of a View binds only to
0369  * non-const arguments.
0370  */
0371 #define _DECLARE_VIEW_ELEMENT_CONSTR_CALL_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME) \
0372   (const_cast_SoAParametersImpl(base_type::BOOST_PP_CAT(LOCAL_NAME, Parameters_)))
0373 
0374 #define _DECLARE_VIEW_ELEMENT_CONSTR_CALL(R, DATA, LAYOUT_MEMBER_NAME) \
0375   BOOST_PP_EXPAND(_DECLARE_VIEW_ELEMENT_CONSTR_CALL_IMPL LAYOUT_MEMBER_NAME)
0376 
0377 /**
0378  * Direct access to column pointer and indexed access
0379  */
0380 // clang-format off
0381 #define _DECLARE_VIEW_SOA_ACCESSOR_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME)                                        \
0382   /* Column or scalar */                                                                                               \
0383   SOA_HOST_DEVICE SOA_INLINE                                                                                           \
0384   typename cms::soa::SoAAccessors<typename BOOST_PP_CAT(Metadata::TypeOf_, LOCAL_NAME)>::                              \
0385         template ColumnType<BOOST_PP_CAT(Metadata::ColumnTypeOf_, LOCAL_NAME)>::template AccessType<                   \
0386             cms::soa::SoAAccessType::mutableAccess>::template Alignment<conditionalAlignment>::                        \
0387                  template RestrictQualifier<restrictQualify>::NoParamReturnType                                        \
0388   LOCAL_NAME() {                                                                                                       \
0389     return typename cms::soa::SoAAccessors<typename BOOST_PP_CAT(Metadata::TypeOf_, LOCAL_NAME)>::                     \
0390         template ColumnType<BOOST_PP_CAT(Metadata::ColumnTypeOf_, LOCAL_NAME)>::template AccessType<                   \
0391             cms::soa::SoAAccessType::mutableAccess>::template Alignment<conditionalAlignment>::                        \
0392                 template RestrictQualifier<restrictQualify>(const_cast_SoAParametersImpl(                              \
0393                     base_type:: BOOST_PP_CAT(LOCAL_NAME, Parameters_)))();                                             \
0394   }                                                                                                                    \
0395   SOA_HOST_DEVICE SOA_INLINE                                                                                           \
0396   typename cms::soa::SoAAccessors<typename BOOST_PP_CAT(Metadata::TypeOf_, LOCAL_NAME)>::                              \
0397         template ColumnType<BOOST_PP_CAT(Metadata::ColumnTypeOf_, LOCAL_NAME)>::template AccessType<                   \
0398             cms::soa::SoAAccessType::mutableAccess>::template Alignment<conditionalAlignment>::                        \
0399                  template RestrictQualifier<restrictQualify>::ParamReturnType                                          \
0400   LOCAL_NAME(size_type _soa_impl_index) {                                                                              \
0401     if constexpr (rangeChecking == cms::soa::RangeChecking::enabled) {                                                 \
0402       if (_soa_impl_index >= base_type::elements_ or _soa_impl_index < 0)                                              \
0403         SOA_THROW_OUT_OF_RANGE("Out of range index in mutable " #LOCAL_NAME "(size_type index)",                       \
0404           _soa_impl_index, base_type::elements_)                                                                       \
0405     }                                                                                                                  \
0406     return typename cms::soa::SoAAccessors<typename BOOST_PP_CAT(Metadata::TypeOf_, LOCAL_NAME)>::                     \
0407         template ColumnType<BOOST_PP_CAT(Metadata::ColumnTypeOf_, LOCAL_NAME)>::template AccessType<                   \
0408             cms::soa::SoAAccessType::mutableAccess>::template Alignment<conditionalAlignment>::                        \
0409                 template RestrictQualifier<restrictQualify>(const_cast_SoAParametersImpl(                              \
0410                     base_type:: BOOST_PP_CAT(LOCAL_NAME, Parameters_)))(_soa_impl_index);                              \
0411   }
0412 // clang-format on
0413 
0414 #define _DECLARE_VIEW_SOA_ACCESSOR(R, DATA, LAYOUT_MEMBER_NAME) \
0415   BOOST_PP_EXPAND(_DECLARE_VIEW_SOA_ACCESSOR_IMPL LAYOUT_MEMBER_NAME)
0416 
0417 /**
0418  * Direct access to column pointer (const) and indexed access.
0419  */
0420 // clang-format off
0421 #define _DECLARE_VIEW_SOA_CONST_ACCESSOR_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME)                                  \
0422   /* Column or scalar */                                                                                               \
0423   SOA_HOST_DEVICE SOA_INLINE                                                                                           \
0424   typename cms::soa::SoAAccessors<typename BOOST_PP_CAT(Metadata::TypeOf_, LOCAL_NAME)>::                              \
0425         template ColumnType<BOOST_PP_CAT(Metadata::ColumnTypeOf_, LOCAL_NAME)>::template AccessType<                   \
0426             cms::soa::SoAAccessType::constAccess>::template Alignment<conditionalAlignment>::                          \
0427                 template RestrictQualifier<restrictQualify>::NoParamReturnType                                         \
0428   LOCAL_NAME() const {                                                                                                 \
0429     return typename cms::soa::SoAAccessors<typename BOOST_PP_CAT(Metadata::TypeOf_, LOCAL_NAME)>::                     \
0430         template ColumnType<BOOST_PP_CAT(Metadata::ColumnTypeOf_, LOCAL_NAME)>::template AccessType<                   \
0431             cms::soa::SoAAccessType::constAccess>::template Alignment<conditionalAlignment>::                          \
0432                 template RestrictQualifier<restrictQualify>(BOOST_PP_CAT(LOCAL_NAME, Parameters_))();                  \
0433   }                                                                                                                    \
0434   SOA_HOST_DEVICE SOA_INLINE                                                                                           \
0435   typename cms::soa::SoAAccessors<typename BOOST_PP_CAT(Metadata::TypeOf_, LOCAL_NAME)>::                              \
0436         template ColumnType<BOOST_PP_CAT(Metadata::ColumnTypeOf_, LOCAL_NAME)>::template AccessType<                   \
0437             cms::soa::SoAAccessType::constAccess>::template Alignment<conditionalAlignment>::                          \
0438                 template RestrictQualifier<restrictQualify>::ParamReturnType                                           \
0439   LOCAL_NAME(size_type _soa_impl_index) const {                                                                        \
0440     if constexpr (rangeChecking == cms::soa::RangeChecking::enabled) {                                                 \
0441       if (_soa_impl_index >= elements_ or _soa_impl_index < 0)                                                         \
0442         SOA_THROW_OUT_OF_RANGE("Out of range index in const " #LOCAL_NAME "(size_type index)",                         \
0443           _soa_impl_index, elements_)                                                                                  \
0444     }                                                                                                                  \
0445     return typename cms::soa::SoAAccessors<typename BOOST_PP_CAT(Metadata::TypeOf_, LOCAL_NAME)>::                     \
0446         template ColumnType<BOOST_PP_CAT(Metadata::ColumnTypeOf_, LOCAL_NAME)>::template AccessType<                   \
0447             cms::soa::SoAAccessType::constAccess>::template Alignment<conditionalAlignment>::                          \
0448                 template RestrictQualifier<restrictQualify>(BOOST_PP_CAT(LOCAL_NAME, Parameters_))(_soa_impl_index);   \
0449   }
0450 // clang-format on
0451 
0452 #define _DECLARE_VIEW_SOA_CONST_ACCESSOR(R, DATA, LAYOUT_MEMBER_NAME) \
0453   BOOST_PP_EXPAND(_DECLARE_VIEW_SOA_CONST_ACCESSOR_IMPL LAYOUT_MEMBER_NAME)
0454 
0455 /**
0456  * SoA class member declaration (column pointers and parameters).
0457  */
0458 #define _DECLARE_VIEW_SOA_MEMBER_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME, DATA) \
0459   typename BOOST_PP_CAT(Metadata::ParametersTypeOf_, LOCAL_NAME) BOOST_PP_CAT(LOCAL_NAME, Parameters_);
0460 
0461 #define _DECLARE_VIEW_SOA_MEMBER(R, DATA, LAYOUT_MEMBER_NAME) \
0462   BOOST_PP_EXPAND(_DECLARE_VIEW_SOA_MEMBER_IMPL BOOST_PP_TUPLE_PUSH_BACK(LAYOUT_MEMBER_NAME, DATA))
0463 
0464 /**
0465  * Const SoA class member declaration (column pointers and parameters).
0466  */
0467 #define _DECLARE_CONST_VIEW_SOA_MEMBER_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME, DATA) \
0468   typename BOOST_PP_CAT(Metadata::ParametersTypeOf_, LOCAL_NAME)::ConstType BOOST_PP_CAT(LOCAL_NAME, Parameters_);
0469 
0470 #define _DECLARE_CONST_VIEW_SOA_MEMBER(R, DATA, LAYOUT_MEMBER_NAME) \
0471   BOOST_PP_EXPAND(_DECLARE_CONST_VIEW_SOA_MEMBER_IMPL BOOST_PP_TUPLE_PUSH_BACK(LAYOUT_MEMBER_NAME, DATA))
0472 
0473 /**
0474  * Assign the value of the view from the values in the value_element.
0475  */
0476 
0477 // clang-format off
0478 #define _TRIVIAL_VIEW_ASSIGN_VALUE_ELEMENT_IMPL(VALUE_TYPE, CPP_TYPE, NAME, ARGS)                                      \
0479   _SWITCH_ON_TYPE(VALUE_TYPE,                                                                                          \
0480       /* Scalar (empty) */                                                                                             \
0481       ,                                                                                                                \
0482       /* Column */                                                                                                     \
0483       NAME() = _soa_impl_value.NAME;                                                                                   \
0484       ,                                                                                                                \
0485       /* Eigen column */                                                                                               \
0486       NAME() = _soa_impl_value.NAME;                                                                                   \
0487 )
0488 // clang-format on
0489 
0490 #define _TRIVIAL_VIEW_ASSIGN_VALUE_ELEMENT(R, DATA, TYPE_NAME) _TRIVIAL_VIEW_ASSIGN_VALUE_ELEMENT_IMPL TYPE_NAME
0491 
0492 /**
0493  * Generator of parameters for (const) view Metarecords subclass.
0494  */
0495 #define _DECLARE_CONST_VIEW_CONSTRUCTOR_COLUMNS_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME) \
0496   (typename Metadata::BOOST_PP_CAT(ParametersTypeOf_, LOCAL_NAME)::ConstType LOCAL_NAME)
0497 
0498 #define _DECLARE_CONST_VIEW_CONSTRUCTOR_COLUMNS(R, DATA, LAYOUT_MEMBER_NAME) \
0499   BOOST_PP_EXPAND(_DECLARE_CONST_VIEW_CONSTRUCTOR_COLUMNS_IMPL LAYOUT_MEMBER_NAME)
0500 
0501 /**
0502  * Generator of parameters for view Metarecords subclass.
0503  */
0504 #define _DECLARE_VIEW_CONSTRUCTOR_COLUMNS_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME) \
0505   (typename Metadata::BOOST_PP_CAT(ParametersTypeOf_, LOCAL_NAME) LOCAL_NAME)
0506 
0507 #define _DECLARE_VIEW_CONSTRUCTOR_COLUMNS(R, DATA, LAYOUT_MEMBER_NAME) \
0508   BOOST_PP_EXPAND(_DECLARE_VIEW_CONSTRUCTOR_COLUMNS_IMPL LAYOUT_MEMBER_NAME)
0509 
0510 /**
0511  * Generator of members for (const) view Metarecords subclass.
0512  */
0513 #define _DECLARE_STRUCT_CONST_DATA_MEMBER_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME) \
0514   typename Metadata::BOOST_PP_CAT(ParametersTypeOf_, LOCAL_NAME)::ConstType BOOST_PP_CAT(LOCAL_NAME, _);
0515 
0516 #define _DECLARE_STRUCT_CONST_DATA_MEMBER(R, DATA, LAYOUT_MEMBER_NAME) \
0517   BOOST_PP_EXPAND(_DECLARE_STRUCT_CONST_DATA_MEMBER_IMPL LAYOUT_MEMBER_NAME)
0518 
0519 /**
0520  * Generator of members for view Metarecords subclass.
0521  */
0522 #define _DECLARE_STRUCT_DATA_MEMBER_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME) \
0523   typename Metadata::BOOST_PP_CAT(ParametersTypeOf_, LOCAL_NAME) BOOST_PP_CAT(LOCAL_NAME, _);
0524 
0525 #define _DECLARE_STRUCT_DATA_MEMBER(R, DATA, LAYOUT_MEMBER_NAME) \
0526   BOOST_PP_EXPAND(_DECLARE_STRUCT_DATA_MEMBER_IMPL LAYOUT_MEMBER_NAME)
0527 
0528 /**
0529  * Assign the value of the records to the column parameters.
0530  */
0531 #define _STRUCT_ELEMENT_INITIALIZERS_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME) \
0532   (BOOST_PP_CAT(LOCAL_NAME, _){parent_.metadata().BOOST_PP_CAT(parametersOf_, LOCAL_NAME)()})
0533 
0534 #define _STRUCT_ELEMENT_INITIALIZERS(R, DATA, LAYOUT_MEMBER_NAME) \
0535   BOOST_PP_EXPAND(_STRUCT_ELEMENT_INITIALIZERS_IMPL LAYOUT_MEMBER_NAME)
0536 
0537 /**
0538  * Generator of accessors for (const) view Metarecords subclass.
0539  */
0540 #define _CONST_ACCESSORS_STRUCT_MEMBERS_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME)                    \
0541   const typename Metadata::BOOST_PP_CAT(ParametersTypeOf_, LOCAL_NAME)::ConstType& LOCAL_NAME() const { \
0542     return BOOST_PP_CAT(LOCAL_NAME, _);                                                                 \
0543   }
0544 
0545 #define _CONST_ACCESSORS_STRUCT_MEMBERS(R, DATA, LAYOUT_MEMBER_NAME) \
0546   BOOST_PP_EXPAND(_CONST_ACCESSORS_STRUCT_MEMBERS_IMPL LAYOUT_MEMBER_NAME)
0547 
0548 /**
0549  * Generator of accessors for (const) view Metarecords subclass.
0550  */
0551 #define _ACCESSORS_STRUCT_MEMBERS_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME)                \
0552   const typename Metadata::BOOST_PP_CAT(ParametersTypeOf_, LOCAL_NAME) & LOCAL_NAME() const { \
0553     return BOOST_PP_CAT(LOCAL_NAME, _);                                                       \
0554   }
0555 
0556 #define _ACCESSORS_STRUCT_MEMBERS(R, DATA, LAYOUT_MEMBER_NAME) \
0557   BOOST_PP_EXPAND(_ACCESSORS_STRUCT_MEMBERS_IMPL LAYOUT_MEMBER_NAME)
0558 
0559 // clang-format off
0560 #define _INITIALIZE_VIEW_PARAMETERS_AND_SIZE_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME)                              \
0561         if (not readyToSet) {                                                                                          \
0562           base_type::elements_ = LOCAL_NAME.size_;                                                                     \
0563           readyToSet = true;                                                                                           \
0564         }                                                                                                              \
0565         auto BOOST_PP_CAT(LOCAL_NAME, _tmp) = [&]() -> auto {                                                          \
0566           if (base_type::elements_ != LOCAL_NAME.size_)                                                                \
0567             throw std::runtime_error(                                                                                  \
0568               "In constructor by column pointers: number of elements not equal for every column: "                     \
0569               BOOST_PP_STRINGIZE(LOCAL_NAME));                                                                         \
0570           if constexpr (alignmentEnforcement == AlignmentEnforcement::enforced)                                        \
0571             if (Metadata:: BOOST_PP_CAT(ParametersTypeOf_, LOCAL_NAME)::checkAlignment(LOCAL_NAME, alignment))         \
0572               throw std::runtime_error("In constructor by column: misaligned column: " #LOCAL_NAME);                   \
0573           return LOCAL_NAME;                                                                                           \
0574             }();                                                                                                       \
0575         base_type::BOOST_PP_CAT(LOCAL_NAME, Parameters_) = BOOST_PP_CAT(LOCAL_NAME, _tmp); \
0576   // clang-format on
0577 
0578 #define _INITIALIZE_VIEW_PARAMETERS_AND_SIZE(R, DATA, LAYOUT_MEMBER_NAME) \
0579   BOOST_PP_EXPAND(_INITIALIZE_VIEW_PARAMETERS_AND_SIZE_IMPL LAYOUT_MEMBER_NAME)
0580 
0581 // clang-format off
0582 #define _INITIALIZE_CONST_VIEW_PARAMETERS_AND_SIZE_IMPL(LAYOUT_NAME, LAYOUT_MEMBER, LOCAL_NAME)                        \
0583         if (not readyToSet) {                                                                                          \
0584           elements_ = LOCAL_NAME.size_;                                                                                \
0585           readyToSet = true;                                                                                           \
0586         }                                                                                                              \
0587         auto BOOST_PP_CAT(LOCAL_NAME, _tmp) = [&]() -> auto {                                                          \
0588           if (elements_ != LOCAL_NAME.size_)                                                                           \
0589             throw std::runtime_error(                                                                                  \
0590               "In constructor by column pointers: number of elements not equal for every column: "                     \
0591               BOOST_PP_STRINGIZE(LOCAL_NAME));                                                                         \
0592           if constexpr (alignmentEnforcement == AlignmentEnforcement::enforced)                                        \
0593             if (Metadata:: BOOST_PP_CAT(ParametersTypeOf_, LOCAL_NAME)::checkAlignment(LOCAL_NAME, alignment))         \
0594               throw std::runtime_error("In constructor by column: misaligned column: " #LOCAL_NAME);                   \
0595           return LOCAL_NAME;                                                                                           \
0596             }();                                                                                                       \
0597         BOOST_PP_CAT(LOCAL_NAME, Parameters_) = BOOST_PP_CAT(LOCAL_NAME, _tmp); \
0598   // clang-format on
0599 
0600 #define _INITIALIZE_CONST_VIEW_PARAMETERS_AND_SIZE(R, DATA, LAYOUT_MEMBER_NAME) \
0601   BOOST_PP_EXPAND(_INITIALIZE_CONST_VIEW_PARAMETERS_AND_SIZE_IMPL LAYOUT_MEMBER_NAME)
0602 
0603 /* ---- MUTABLE VIEW ------------------------------------------------------------------------------------------------ */
0604 // clang-format off
0605 #define _GENERATE_SOA_VIEW_PART_0(CONST_VIEW, VIEW, LAYOUTS_LIST, VALUE_LIST)                                          \
0606   template <CMS_SOA_BYTE_SIZE_TYPE VIEW_ALIGNMENT = cms::soa::CacheLineSize::defaultSize,                              \
0607             bool VIEW_ALIGNMENT_ENFORCEMENT = cms::soa::AlignmentEnforcement::relaxed,                                 \
0608             bool RESTRICT_QUALIFY = cms::soa::RestrictQualify::Default,                                                \
0609             bool RANGE_CHECKING = cms::soa::RangeChecking::Default>                                                    \
0610   struct VIEW : public CONST_VIEW<VIEW_ALIGNMENT, VIEW_ALIGNMENT_ENFORCEMENT, RESTRICT_QUALIFY, RANGE_CHECKING> {      \
0611     /* Declare the parametrized layouts as the default */                                                              \
0612     /*BOOST_PP_SEQ_CAT(_ITERATE_ON_ALL(_DECLARE_VIEW_LAYOUT_PARAMETRIZED_TEMPLATE, ~, LAYOUTS_LIST))   */              \
0613     /* these could be moved to an external type trait to free up the symbol names */                                   \
0614     using self_type = VIEW;                                                                                            \
0615     using base_type = CONST_VIEW<VIEW_ALIGNMENT, VIEW_ALIGNMENT_ENFORCEMENT, RESTRICT_QUALIFY, RANGE_CHECKING>;
0616 // clang-format on
0617 
0618 // clang-format off
0619 #define _GENERATE_SOA_VIEW_PART_0_NO_DEFAULTS(CONST_VIEW, VIEW, LAYOUTS_LIST, VALUE_LIST)                              \
0620   template <CMS_SOA_BYTE_SIZE_TYPE VIEW_ALIGNMENT,                                                                     \
0621             bool VIEW_ALIGNMENT_ENFORCEMENT,                                                                           \
0622             bool RESTRICT_QUALIFY,                                                                                     \
0623             bool RANGE_CHECKING>                                                                                       \
0624   struct VIEW : public CONST_VIEW<VIEW_ALIGNMENT, VIEW_ALIGNMENT_ENFORCEMENT, RESTRICT_QUALIFY, RANGE_CHECKING> {      \
0625     /* Declare the parametrized layouts as the default */                                                              \
0626     /*BOOST_PP_SEQ_CAT(_ITERATE_ON_ALL(_DECLARE_VIEW_LAYOUT_PARAMETRIZED_TEMPLATE, ~, LAYOUTS_LIST))   */              \
0627     /* these could be moved to an external type trait to free up the symbol names */                                   \
0628     using self_type = VIEW;                                                                                            \
0629     using base_type = CONST_VIEW<VIEW_ALIGNMENT, VIEW_ALIGNMENT_ENFORCEMENT, RESTRICT_QUALIFY, RANGE_CHECKING>;
0630 // clang-format on
0631 
0632 /**
0633  * Split of the const view definition where the parametrized template alias for the layout is defined for layout trivial view.
0634  */
0635 
0636 // clang-format off
0637 #define _GENERATE_SOA_VIEW_PART_1(CONST_VIEW, VIEW, LAYOUTS_LIST, VALUE_LIST)                                          \
0638     using size_type = cms::soa::size_type;                                                                             \
0639     using byte_size_type = cms::soa::byte_size_type;                                                                   \
0640     using AlignmentEnforcement = cms::soa::AlignmentEnforcement;                                                       \
0641                                                                                                                        \
0642     /* For CUDA applications, we align to the 128 bytes of the cache lines.                                            \
0643      * See https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#global-memory-3-0 this is still valid      \
0644      * up to compute capability 8.X.                                                                                   \
0645      */                                                                                                                \
0646     constexpr static byte_size_type defaultAlignment = cms::soa::CacheLineSize::defaultSize;                           \
0647     constexpr static byte_size_type alignment = VIEW_ALIGNMENT;                                                        \
0648     constexpr static bool alignmentEnforcement = VIEW_ALIGNMENT_ENFORCEMENT;                                           \
0649     constexpr static byte_size_type conditionalAlignment =                                                             \
0650         alignmentEnforcement == AlignmentEnforcement::enforced ? alignment : 0;                                        \
0651     constexpr static bool restrictQualify = RESTRICT_QUALIFY;                                                          \
0652     constexpr static bool rangeChecking = RANGE_CHECKING;                                                              \
0653     /* Those typedefs avoid having commas in macros (which is problematic) */                                          \
0654     template <cms::soa::SoAColumnType COLUMN_TYPE, class C>                                                            \
0655     using SoAValueWithConf = cms::soa::SoAValue<COLUMN_TYPE, C, conditionalAlignment, restrictQualify>;                \
0656                                                                                                                        \
0657     template <cms::soa::SoAColumnType COLUMN_TYPE, class C>                                                            \
0658     using SoAConstValueWithConf = cms::soa::SoAConstValue<COLUMN_TYPE, C, conditionalAlignment, restrictQualify>;      \
0659                                                                                                                        \
0660     template <CMS_SOA_BYTE_SIZE_TYPE, bool, bool, bool>                                                                \
0661     friend struct VIEW;                                                                                                \
0662                                                                                                                        \
0663     /**                                                                                                                \
0664      * Helper/friend class allowing SoA introspection.                                                                 \
0665      */                                                                                                                \
0666     struct Metadata {                                                                                                  \
0667       friend VIEW;                                                                                                     \
0668       SOA_HOST_DEVICE SOA_INLINE size_type size() const { return parent_.elements_; }                                  \
0669       /* Alias layout or view types to name-derived identifyer to allow simpler definitions */                         \
0670       _ITERATE_ON_ALL(_DECLARE_VIEW_LAYOUT_TYPE_ALIAS, ~, LAYOUTS_LIST)                                                \
0671                                                                                                                        \
0672       /* Alias member types to name-derived identifyer to allow simpler definitions */                                 \
0673       _ITERATE_ON_ALL(_DECLARE_VIEW_MEMBER_TYPE_ALIAS, const_cast_SoAParametersImpl, VALUE_LIST)                       \
0674       _ITERATE_ON_ALL(_DECLARE_VIEW_MEMBER_POINTERS, ~, VALUE_LIST)                                                    \
0675       _ITERATE_ON_ALL(_DECLARE_VIEW_MEMBER_CONST_POINTERS, ~, VALUE_LIST)                                              \
0676                                                                                                                        \
0677       /* Forbid copying to avoid const correctness evasion */                                                          \
0678       Metadata& operator=(const Metadata&) = delete;                                                                   \
0679       Metadata(const Metadata&) = delete;                                                                              \
0680                                                                                                                        \
0681     private:                                                                                                           \
0682       SOA_HOST_DEVICE SOA_INLINE Metadata(const VIEW& _soa_impl_parent) : parent_(_soa_impl_parent) {}                 \
0683       const VIEW& parent_;                                                                                             \
0684     };                                                                                                                 \
0685                                                                                                                        \
0686     friend Metadata;                                                                                                   \
0687                                                                                                                        \
0688     /**                                                                                                                \
0689      * Helper/friend class allowing access to size from columns.                                                       \
0690      */                                                                                                                \
0691     struct Metarecords {                                                                                               \
0692       friend VIEW;                                                                                                     \
0693       Metarecords(const VIEW& _soa_impl_parent) :                                                                      \
0694                   parent_(_soa_impl_parent),                                                                           \
0695                   _ITERATE_ON_ALL_COMMA(_STRUCT_ELEMENT_INITIALIZERS, ~, VALUE_LIST) {}                                \
0696       _ITERATE_ON_ALL(_ACCESSORS_STRUCT_MEMBERS, ~, VALUE_LIST)                                                        \
0697       private:                                                                                                         \
0698         const VIEW& parent_;                                                                                           \
0699         _ITERATE_ON_ALL(_DECLARE_STRUCT_DATA_MEMBER, ~, VALUE_LIST)                                                    \
0700     };                                                                                                                 \
0701                                                                                                                        \
0702     SOA_HOST_DEVICE SOA_INLINE const Metadata metadata() const { return Metadata(*this); }                             \
0703     SOA_HOST_DEVICE SOA_INLINE Metadata metadata() { return Metadata(*this); }                                         \
0704     SOA_HOST_DEVICE SOA_INLINE const Metarecords records() const { return Metarecords(*this); }                        \
0705     SOA_HOST_DEVICE SOA_INLINE Metarecords records() { return Metarecords(*this); }                                    \
0706                                                                                                                        \
0707     /* Trivial constuctor */                                                                                           \
0708     VIEW() = default;                                                                                                  \
0709                                                                                                                        \
0710     /* Constructor relying on user provided layouts or views */                                                        \
0711     SOA_HOST_ONLY VIEW(_ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_CONSTRUCTION_PARAMETERS, BOOST_PP_EMPTY(), LAYOUTS_LIST))   \
0712         : base_type{_ITERATE_ON_ALL_COMMA(_DECLARE_LAYOUT_LIST, BOOST_PP_EMPTY(), LAYOUTS_LIST)} {}                    \
0713                                                                                                                        \
0714     /* Constructor relying on individually provided column addresses */                                                \
0715     SOA_HOST_ONLY VIEW(size_type _soa_impl_elements,                                                                   \
0716                         _ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_CONSTRUCTION_BYCOLUMN_PARAMETERS,                          \
0717                                               BOOST_PP_EMPTY(),                                                        \
0718                                               VALUE_LIST))                                                             \
0719         : base_type{_soa_impl_elements,                                                                                \
0720                     _ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_MEMBER_LIST, BOOST_PP_EMPTY(), VALUE_LIST)                     \
0721           } {}                                                                                                         \
0722                                                                                                                        \
0723     /* Constructor relying on individually provided column structs */                                                  \
0724     SOA_HOST_ONLY VIEW(_ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_CONSTRUCTOR_COLUMNS, BOOST_PP_EMPTY(), VALUE_LIST)) {       \
0725       bool readyToSet = false;                                                                                         \
0726       _ITERATE_ON_ALL(_INITIALIZE_VIEW_PARAMETERS_AND_SIZE, BOOST_PP_EMPTY(), VALUE_LIST)                              \
0727     }                                                                                                                  \
0728                                                                                                                        \
0729     /* Copiable */                                                                                                     \
0730     VIEW(VIEW const&) = default;                                                                                       \
0731     VIEW& operator=(VIEW const&) = default;                                                                            \
0732                                                                                                                        \
0733     /* Copy constructor for other parameters */                                                                        \
0734     template <CMS_SOA_BYTE_SIZE_TYPE OTHER_VIEW_ALIGNMENT,                                                             \
0735               bool OTHER_VIEW_ALIGNMENT_ENFORCEMENT,                                                                   \
0736               bool OTHER_RESTRICT_QUALIFY,                                                                             \
0737               bool OTHER_RANGE_CHECKING>                                                                               \
0738     VIEW(VIEW<OTHER_VIEW_ALIGNMENT, OTHER_VIEW_ALIGNMENT_ENFORCEMENT, OTHER_RESTRICT_QUALIFY,                          \
0739               OTHER_RANGE_CHECKING> const& other): base_type{other.elements_,                                          \
0740                 _ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_OTHER_MEMBER_LIST, BOOST_PP_EMPTY(), VALUE_LIST)                   \
0741               } {}                                                                                                     \
0742     /* Copy operator for other parameters */                                                                           \
0743     template <CMS_SOA_BYTE_SIZE_TYPE OTHER_VIEW_ALIGNMENT,                                                             \
0744               bool OTHER_VIEW_ALIGNMENT_ENFORCEMENT,                                                                   \
0745               bool OTHER_RESTRICT_QUALIFY,                                                                             \
0746               bool OTHER_RANGE_CHECKING>                                                                               \
0747     VIEW& operator=(VIEW<OTHER_VIEW_ALIGNMENT, OTHER_VIEW_ALIGNMENT_ENFORCEMENT, OTHER_RESTRICT_QUALIFY,               \
0748               OTHER_RANGE_CHECKING> const& other) { static_cast<base_type>(*this) = static_cast<base_type>(other); }   \
0749                                                                                                                        \
0750     /* Movable */                                                                                                      \
0751     VIEW(VIEW &&) = default;                                                                                           \
0752     VIEW& operator=(VIEW &&) = default;                                                                                \
0753                                                                                                                        \
0754     /* Trivial destuctor */                                                                                            \
0755     ~VIEW() = default;                                                                                                 \
0756                                                                                                                        \
0757     /* AoS-like accessor (const) */                                                                                    \
0758     using const_element = typename base_type::const_element;                                                           \
0759                                                                                                                        \
0760     using base_type::operator[];                                                                                       \
0761                                                                                                                        \
0762     /* AoS-like accessor (mutable) */                                                                                  \
0763     struct element {                                                                                                   \
0764       SOA_HOST_DEVICE SOA_INLINE constexpr                                                                             \
0765       element(size_type _soa_impl_index, /* Declare parameters */                                                      \
0766               _ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_ELEMENT_VALUE_ARG, BOOST_PP_EMPTY(), VALUE_LIST))                    \
0767           : _ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_ELEM_MEMBER_INIT, _soa_impl_index, VALUE_LIST) {}                      \
0768                                                                                                                        \
0769       SOA_HOST_DEVICE SOA_INLINE constexpr                                                                             \
0770       element& operator=(const element& _soa_impl_other) {                                                             \
0771         _ITERATE_ON_ALL(_DECLARE_VIEW_ELEMENT_VALUE_COPY, ~, VALUE_LIST)                                               \
0772         return *this;                                                                                                  \
0773       }                                                                                                                \
0774                                                                                                                        \
0775       SOA_HOST_DEVICE SOA_INLINE constexpr                                                                             \
0776       element& operator=(const const_element& _soa_impl_other) {                                                       \
0777         _ITERATE_ON_ALL(_DECLARE_VIEW_ELEMENT_VALUE_COPY, ~, VALUE_LIST)                                               \
0778         return *this;                                                                                                  \
0779       }
0780 // clang-format on
0781 
0782 // clang-format off
0783 #define _GENERATE_SOA_VIEW_PART_2(CONST_VIEW, VIEW, LAYOUTS_LIST, VALUE_LIST)                                          \
0784       _ITERATE_ON_ALL(_DECLARE_VIEW_ELEMENT_VALUE_MEMBER, ~, VALUE_LIST)                                               \
0785     };                                                                                                                 \
0786                                                                                                                        \
0787     SOA_HOST_DEVICE SOA_INLINE constexpr                                                                               \
0788     element operator[](size_type _soa_impl_index) {                                                                    \
0789       if constexpr (rangeChecking == cms::soa::RangeChecking::enabled) {                                               \
0790         if (_soa_impl_index >= base_type::elements_ or _soa_impl_index < 0)                                            \
0791           SOA_THROW_OUT_OF_RANGE("Out of range index in " #VIEW "::operator[]", _soa_impl_index, base_type::elements_) \
0792       }                                                                                                                \
0793       return element{_soa_impl_index, _ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_ELEMENT_CONSTR_CALL, ~, VALUE_LIST)};        \
0794     }                                                                                                                  \
0795                                                                                                                        \
0796     /* inherit const accessors from ConstView */                                                                       \
0797                                                                                                                        \
0798     /* non-const accessors */                                                                                          \
0799     _ITERATE_ON_ALL(_DECLARE_VIEW_SOA_ACCESSOR, ~, VALUE_LIST)                                                         \
0800                                                                                                                        \
0801     /* dump the SoA internal structure */                                                                              \
0802     template <typename T>                                                                                              \
0803     SOA_HOST_ONLY friend void dump();                                                                                  \
0804   };
0805 // clang-format on
0806 
0807 /* ---- CONST VIEW -------------------------------------------------------------------------------------------------- */
0808 // clang-format off
0809 #define _GENERATE_SOA_CONST_VIEW_PART_0(CONST_VIEW, VIEW, LAYOUTS_LIST, VALUE_LIST)                                    \
0810   template <CMS_SOA_BYTE_SIZE_TYPE VIEW_ALIGNMENT = cms::soa::CacheLineSize::defaultSize,                              \
0811             bool VIEW_ALIGNMENT_ENFORCEMENT = cms::soa::AlignmentEnforcement::relaxed,                                 \
0812             bool RESTRICT_QUALIFY = cms::soa::RestrictQualify::Default,                                                \
0813             bool RANGE_CHECKING = cms::soa::RangeChecking::Default>                                                    \
0814   struct CONST_VIEW {                                                                                                  \
0815     /* these could be moved to an external type trait to free up the symbol names */                                   \
0816     using self_type = CONST_VIEW;
0817 // clang-format on
0818 
0819 // clang-format off
0820 #define _GENERATE_SOA_CONST_VIEW_PART_0_NO_DEFAULTS(CONST_VIEW, VIEW, LAYOUTS_LIST, VALUE_LIST)                        \
0821   template <CMS_SOA_BYTE_SIZE_TYPE VIEW_ALIGNMENT,                                                                     \
0822             bool VIEW_ALIGNMENT_ENFORCEMENT,                                                                           \
0823             bool RESTRICT_QUALIFY,                                                                                     \
0824             bool RANGE_CHECKING>                                                                                       \
0825   struct CONST_VIEW {                                                                                                  \
0826     /* these could be moved to an external type trait to free up the symbol names */                                   \
0827     using self_type = CONST_VIEW;
0828 // clang-format on
0829 
0830 /**
0831  * Split of the const view definition where the parametrized template alias for the layout is defined for layout trivial view.
0832  */
0833 
0834 // clang-format off
0835 #define _GENERATE_SOA_CONST_VIEW_PART_1(CONST_VIEW, VIEW, LAYOUTS_LIST, VALUE_LIST, ...)                               \
0836     using size_type = cms::soa::size_type;                                                                             \
0837     using byte_size_type = cms::soa::byte_size_type;                                                                   \
0838     using AlignmentEnforcement = cms::soa::AlignmentEnforcement;                                                       \
0839                                                                                                                        \
0840     template <CMS_SOA_BYTE_SIZE_TYPE, bool, bool, bool>                                                                \
0841     friend struct VIEW;                                                                                                \
0842                                                                                                                        \
0843     template <CMS_SOA_BYTE_SIZE_TYPE, bool, bool, bool>                                                                \
0844     friend struct CONST_VIEW;                                                                                          \
0845                                                                                                                        \
0846     /* For CUDA applications, we align to the 128 bytes of the cache lines.                                            \
0847      * See https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#global-memory-3-0 this is still valid      \
0848      * up to compute capability 8.X.                                                                                   \
0849      */                                                                                                                \
0850     constexpr static byte_size_type defaultAlignment = cms::soa::CacheLineSize::defaultSize;                           \
0851     constexpr static byte_size_type alignment = VIEW_ALIGNMENT;                                                        \
0852     constexpr static bool alignmentEnforcement = VIEW_ALIGNMENT_ENFORCEMENT;                                           \
0853     constexpr static byte_size_type conditionalAlignment =                                                             \
0854         alignmentEnforcement == AlignmentEnforcement::enforced ? alignment : 0;                                        \
0855     constexpr static bool restrictQualify = RESTRICT_QUALIFY;                                                          \
0856     constexpr static bool rangeChecking = RANGE_CHECKING;                                                              \
0857     /* Those typedefs avoid having commas in macros (which is problematic) */                                          \
0858     template <cms::soa::SoAColumnType COLUMN_TYPE, class C>                                                            \
0859     using SoAValueWithConf = cms::soa::SoAValue<COLUMN_TYPE, C, conditionalAlignment, restrictQualify>;                \
0860                                                                                                                        \
0861     template <cms::soa::SoAColumnType COLUMN_TYPE, class C>                                                            \
0862     using SoAConstValueWithConf = cms::soa::SoAConstValue<COLUMN_TYPE, C, conditionalAlignment, restrictQualify>;      \
0863                                                                                                                        \
0864     /**                                                                                                                \
0865      * Helper/friend class allowing SoA introspection.                                                                 \
0866      */                                                                                                                \
0867     struct Metadata {                                                                                                  \
0868       friend CONST_VIEW;                                                                                               \
0869       SOA_HOST_DEVICE SOA_INLINE size_type size() const { return parent_.elements_; }                                  \
0870       /* Alias layout or view types to name-derived identifyer to allow simpler definitions */                         \
0871       _ITERATE_ON_ALL(_DECLARE_VIEW_LAYOUT_TYPE_ALIAS, ~, LAYOUTS_LIST)                                                \
0872                                                                                                                        \
0873       /* Alias member types to name-derived identifyer to allow simpler definitions */                                 \
0874       _ITERATE_ON_ALL(_DECLARE_VIEW_MEMBER_TYPE_ALIAS, BOOST_PP_EMPTY(), VALUE_LIST)                                   \
0875       _ITERATE_ON_ALL(_DECLARE_VIEW_MEMBER_CONST_POINTERS, ~, VALUE_LIST)                                              \
0876                                                                                                                        \
0877       /* Forbid copying to avoid const correctness evasion */                                                          \
0878       Metadata& operator=(const Metadata&) = delete;                                                                   \
0879       Metadata(const Metadata&) = delete;                                                                              \
0880                                                                                                                        \
0881     private:                                                                                                           \
0882       SOA_HOST_DEVICE SOA_INLINE Metadata(const CONST_VIEW& _soa_impl_parent) : parent_(_soa_impl_parent) {}           \
0883       const CONST_VIEW& parent_;                                                                                       \
0884     };                                                                                                                 \
0885                                                                                                                        \
0886     friend Metadata;                                                                                                   \
0887                                                                                                                        \
0888     /**                                                                                                                \
0889      * Helper/friend class allowing access to size from columns.                                                       \
0890      */                                                                                                                \
0891     struct Metarecords {                                                                                               \
0892       friend CONST_VIEW;                                                                                               \
0893       Metarecords(const CONST_VIEW& _soa_impl_parent) :                                                                \
0894                   parent_(_soa_impl_parent),                                                                           \
0895                   _ITERATE_ON_ALL_COMMA(_STRUCT_ELEMENT_INITIALIZERS, ~, VALUE_LIST) {}                                \
0896       _ITERATE_ON_ALL(_CONST_ACCESSORS_STRUCT_MEMBERS, ~, VALUE_LIST)                                                  \
0897       private:                                                                                                         \
0898         const CONST_VIEW& parent_;                                                                                     \
0899         _ITERATE_ON_ALL(_DECLARE_STRUCT_CONST_DATA_MEMBER, ~, VALUE_LIST)                                              \
0900     };                                                                                                                 \
0901     SOA_HOST_DEVICE SOA_INLINE const Metadata metadata() const { return Metadata(*this); }                             \
0902     SOA_HOST_DEVICE SOA_INLINE const Metarecords records() const { return Metarecords(*this); }                        \
0903                                                                                                                        \
0904     /* Trivial constuctor */                                                                                           \
0905     CONST_VIEW() = default;                                                                                            \
0906                                                                                                                        \
0907     /* Constructor relying on user provided layouts or views */                                                        \
0908     SOA_HOST_ONLY CONST_VIEW(_ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_CONSTRUCTION_PARAMETERS, const, LAYOUTS_LIST))        \
0909         : elements_([&]() -> size_type {                                                                               \
0910             bool set = false;                                                                                          \
0911             size_type ret = 0;                                                                                         \
0912             _ITERATE_ON_ALL(_UPDATE_SIZE_OF_VIEW, BOOST_PP_EMPTY(), LAYOUTS_LIST)                                      \
0913             return ret;                                                                                                \
0914           }()),                                                                                                        \
0915           _ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_MEMBER_INITIALIZERS, ~, VALUE_LIST) {}                                   \
0916                                                                                                                        \
0917     /* Constructor relying on individually provided column addresses */                                                \
0918     SOA_HOST_ONLY CONST_VIEW(size_type _soa_impl_elements,                                                             \
0919                         _ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_CONSTRUCTION_BYCOLUMN_PARAMETERS, const, VALUE_LIST))      \
0920         : elements_(_soa_impl_elements),                                                                               \
0921           _ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_MEMBER_INITIALIZERS_BYCOLUMN, ~, VALUE_LIST) {}                          \
0922                                                                                                                        \
0923     /* Constructor relying on individually provided column structs */                                                  \
0924     SOA_HOST_ONLY CONST_VIEW(_ITERATE_ON_ALL_COMMA(                                                                    \
0925                              _DECLARE_CONST_VIEW_CONSTRUCTOR_COLUMNS, BOOST_PP_EMPTY(), VALUE_LIST)) {                 \
0926       bool readyToSet = false;                                                                                         \
0927       _ITERATE_ON_ALL(_INITIALIZE_CONST_VIEW_PARAMETERS_AND_SIZE, BOOST_PP_EMPTY(), VALUE_LIST)                        \
0928     }                                                                                                                  \
0929                                                                                                                        \
0930     /* Copiable */                                                                                                     \
0931     CONST_VIEW(CONST_VIEW const&) = default;                                                                           \
0932     CONST_VIEW& operator=(CONST_VIEW const&) = default;                                                                \
0933                                                                                                                        \
0934     /* Copy constructor for other parameters */                                                                        \
0935     template <CMS_SOA_BYTE_SIZE_TYPE OTHER_VIEW_ALIGNMENT,                                                             \
0936               bool OTHER_VIEW_ALIGNMENT_ENFORCEMENT,                                                                   \
0937               bool OTHER_RESTRICT_QUALIFY,                                                                             \
0938               bool OTHER_RANGE_CHECKING>                                                                               \
0939     CONST_VIEW(CONST_VIEW<OTHER_VIEW_ALIGNMENT, OTHER_VIEW_ALIGNMENT_ENFORCEMENT, OTHER_RESTRICT_QUALIFY,              \
0940               OTHER_RANGE_CHECKING> const& other): CONST_VIEW{other.elements_,                                         \
0941                 _ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_OTHER_MEMBER_LIST, BOOST_PP_EMPTY(), VALUE_LIST)                   \
0942               } {}                                                                                                     \
0943     /* Copy operator for other parameters */                                                                           \
0944     template <CMS_SOA_BYTE_SIZE_TYPE OTHER_VIEW_ALIGNMENT,                                                             \
0945               bool OTHER_VIEW_ALIGNMENT_ENFORCEMENT,                                                                   \
0946               bool OTHER_RESTRICT_QUALIFY,                                                                             \
0947               bool OTHER_RANGE_CHECKING>                                                                               \
0948     CONST_VIEW& operator=(CONST_VIEW<OTHER_VIEW_ALIGNMENT, OTHER_VIEW_ALIGNMENT_ENFORCEMENT, OTHER_RESTRICT_QUALIFY,   \
0949               OTHER_RANGE_CHECKING> const& other) { *this = other; }                                                   \
0950                                                                                                                        \
0951     /* Movable */                                                                                                      \
0952     CONST_VIEW(CONST_VIEW &&) = default;                                                                               \
0953     CONST_VIEW& operator=(CONST_VIEW &&) = default;                                                                    \
0954                                                                                                                        \
0955     /* Trivial destuctor */                                                                                            \
0956     ~CONST_VIEW() = default;                                                                                           \
0957                                                                                                                        \
0958     /* AoS-like accessor (const) */                                                                                    \
0959     struct const_element {                                                                                             \
0960       SOA_HOST_DEVICE SOA_INLINE constexpr                                                                             \
0961       const_element(size_type _soa_impl_index, /* Declare parameters */                                                \
0962                     _ITERATE_ON_ALL_COMMA(_DECLARE_CONST_VIEW_ELEMENT_VALUE_ARG, const, VALUE_LIST))                   \
0963           : _ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_CONST_ELEM_MEMBER_INIT, _soa_impl_index, VALUE_LIST) {}                \
0964       _ITERATE_ON_ALL(_DECLARE_VIEW_CONST_ELEMENT_ACCESSOR, ~, VALUE_LIST)                                             \
0965                                                                                                                        \
0966       ENUM_IF_VALID(_ITERATE_ON_ALL(GENERATE_CONST_METHODS, ~, __VA_ARGS__))                                           \
0967                                                                                                                        \
0968     private:                                                                                                           \
0969       _ITERATE_ON_ALL(_DECLARE_VIEW_CONST_ELEMENT_VALUE_MEMBER, ~, VALUE_LIST)                                         \
0970     };                                                                                                                 \
0971                                                                                                                        \
0972     SOA_HOST_DEVICE SOA_INLINE constexpr                                                                               \
0973     const_element operator[](size_type _soa_impl_index) const {                                                        \
0974       if constexpr (rangeChecking == cms::soa::RangeChecking::enabled) {                                               \
0975         if (_soa_impl_index >= elements_ or _soa_impl_index < 0)                                                       \
0976           SOA_THROW_OUT_OF_RANGE("Out of range index in " #CONST_VIEW "::operator[]", _soa_impl_index, elements_)      \
0977       }                                                                                                                \
0978       return const_element{                                                                                            \
0979         _soa_impl_index, _ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_CONST_ELEMENT_CONSTR_CALL, ~, VALUE_LIST)                 \
0980       };                                                                                                               \
0981     }                                                                                                                  \
0982                                                                                                                        \
0983     /* const accessors */                                                                                              \
0984     _ITERATE_ON_ALL(_DECLARE_VIEW_SOA_CONST_ACCESSOR, ~, VALUE_LIST)                                                   \
0985                                                                                                                        \
0986     /* dump the SoA internal structure */                                                                              \
0987     template <typename T>                                                                                              \
0988     SOA_HOST_ONLY friend void dump();                                                                                  \
0989                                                                                                                        \
0990   private:                                                                                                             \
0991     size_type elements_ = 0;                                                                                           \
0992     _ITERATE_ON_ALL(_DECLARE_CONST_VIEW_SOA_MEMBER, const, VALUE_LIST)                                                 \
0993 };
0994 // clang-format on
0995 
0996 // clang-format off
0997 // MAJOR caveat: in order to propagate the LAYOUTS_LIST and VALUE_LIST
0998 #define _GENERATE_SOA_CONST_VIEW(CONST_VIEW, VIEW, LAYOUTS_LIST, VALUE_LIST)                                           \
0999    _GENERATE_SOA_CONST_VIEW_PART_0(CONST_VIEW, VIEW,                                                                   \
1000      SOA_VIEW_LAYOUT_LIST(LAYOUTS_LIST), SOA_VIEW_VALUE_LIST(VALUE_LIST))                                              \
1001    _GENERATE_SOA_CONST_VIEW_PART_1(CONST_VIEW, VIEW,                                                                   \
1002      SOA_VIEW_LAYOUT_LIST(LAYOUTS_LIST), SOA_VIEW_VALUE_LIST(VALUE_LIST), (_VALUE_TYPE_UNUSED, ~, ~))
1003 
1004 #define GENERATE_SOA_CONST_VIEW(CONST_VIEW, VIEW, LAYOUTS_LIST, VALUE_LIST)                                            \
1005    _GENERATE_SOA_CONST_VIEW(CONST_VIEW, BOOST_PP_CAT(CONST_VIEW, Unused_),                                             \
1006      SOA_VIEW_LAYOUT_LIST(LAYOUTS_LIST), SOA_VIEW_VALUE_LIST(VALUE_LIST))
1007 
1008 #define _GENERATE_SOA_TRIVIAL_CONST_VIEW(CLASS, LAYOUTS_LIST, VALUE_LIST, ...)                                         \
1009    _GENERATE_SOA_CONST_VIEW_PART_0_NO_DEFAULTS(ConstViewTemplateFreeParams, ViewTemplateFreeParams,                    \
1010      SOA_VIEW_LAYOUT_LIST(LAYOUTS_LIST), SOA_VIEW_VALUE_LIST(VALUE_LIST))                                              \
1011    using BOOST_PP_CAT(CLASS, _parametrized) = CLASS<VIEW_ALIGNMENT, VIEW_ALIGNMENT_ENFORCEMENT>;                       \
1012    _GENERATE_SOA_CONST_VIEW_PART_1(ConstViewTemplateFreeParams, ViewTemplateFreeParams,                                \
1013      SOA_VIEW_LAYOUT_LIST(LAYOUTS_LIST), SOA_VIEW_VALUE_LIST(VALUE_LIST), __VA_ARGS__)
1014 
1015 #define _GENERATE_SOA_VIEW(CONST_VIEW, VIEW, LAYOUTS_LIST, VALUE_LIST)                                                 \
1016    _GENERATE_SOA_VIEW_PART_0(CONST_VIEW, VIEW, SOA_VIEW_LAYOUT_LIST(LAYOUTS_LIST), SOA_VIEW_VALUE_LIST(VALUE_LIST))    \
1017    _GENERATE_SOA_VIEW_PART_1(CONST_VIEW, VIEW, SOA_VIEW_LAYOUT_LIST(LAYOUTS_LIST), SOA_VIEW_VALUE_LIST(VALUE_LIST))    \
1018    _GENERATE_SOA_VIEW_PART_2(CONST_VIEW, VIEW, SOA_VIEW_LAYOUT_LIST(LAYOUTS_LIST), SOA_VIEW_VALUE_LIST(VALUE_LIST))
1019 
1020 #define GENERATE_SOA_VIEW(CONST_VIEW, VIEW, LAYOUTS_LIST, VALUE_LIST)                                                  \
1021    _GENERATE_SOA_CONST_VIEW(CONST_VIEW, VIEW, SOA_VIEW_LAYOUT_LIST(LAYOUTS_LIST), SOA_VIEW_VALUE_LIST(VALUE_LIST))     \
1022    _GENERATE_SOA_VIEW(CONST_VIEW, VIEW, SOA_VIEW_LAYOUT_LIST(LAYOUTS_LIST), SOA_VIEW_VALUE_LIST(VALUE_LIST))
1023 
1024 #define _GENERATE_SOA_TRIVIAL_VIEW(CLASS, LAYOUTS_LIST, VALUE_LIST, ...)                                               \
1025    _GENERATE_SOA_VIEW_PART_0_NO_DEFAULTS(ConstViewTemplateFreeParams, ViewTemplateFreeParams,                          \
1026      SOA_VIEW_LAYOUT_LIST(LAYOUTS_LIST), SOA_VIEW_VALUE_LIST(VALUE_LIST))                                              \
1027    using BOOST_PP_CAT(CLASS, _parametrized) = CLASS<VIEW_ALIGNMENT, VIEW_ALIGNMENT_ENFORCEMENT>;                       \
1028    _GENERATE_SOA_VIEW_PART_1(ConstViewTemplateFreeParams, ViewTemplateFreeParams,                                      \
1029      SOA_VIEW_LAYOUT_LIST(LAYOUTS_LIST), SOA_VIEW_VALUE_LIST(VALUE_LIST))                                              \
1030                                                                                                                        \
1031    /* Extra operator=() for mutable element to emulate the aggregate initialisation syntax */                          \
1032    SOA_HOST_DEVICE SOA_INLINE constexpr element & operator=(const typename                                             \
1033        BOOST_PP_CAT(CLASS, _parametrized)::Metadata::value_element _soa_impl_value) {                                  \
1034      _ITERATE_ON_ALL(_TRIVIAL_VIEW_ASSIGN_VALUE_ELEMENT, ~, __VA_ARGS__)                                               \
1035      return *this;                                                                                                     \
1036    }                                                                                                                   \
1037                                                                                                                        \
1038    ENUM_IF_VALID(_ITERATE_ON_ALL(GENERATE_METHODS, ~, __VA_ARGS__))                                                    \
1039    ENUM_IF_VALID(_ITERATE_ON_ALL(GENERATE_CONST_METHODS, ~, __VA_ARGS__))                                              \
1040                                                                                                                        \
1041    _GENERATE_SOA_VIEW_PART_2(ConstViewTemplateFreeParams, ViewTemplateFreeParams,                                      \
1042      SOA_VIEW_LAYOUT_LIST(LAYOUTS_LIST), SOA_VIEW_VALUE_LIST(VALUE_LIST))
1043 // clang-format on
1044 
1045 /**
1046  * Helper macro turning layout field declaration into view field declaration.
1047  */
1048 #define _VIEW_FIELD_FROM_LAYOUT_IMPL(VALUE_TYPE, CPP_TYPE, NAME, ARGS, DATA) (DATA, NAME, NAME)
1049 
1050 #define _VIEW_FIELD_FROM_LAYOUT(R, DATA, VALUE_TYPE_NAME)                                         \
1051   BOOST_PP_IF(BOOST_PP_GREATER(BOOST_PP_TUPLE_ELEM(0, VALUE_TYPE_NAME), _VALUE_LAST_COLUMN_TYPE), \
1052               BOOST_PP_EMPTY(),                                                                   \
1053               BOOST_PP_EXPAND((_VIEW_FIELD_FROM_LAYOUT_IMPL BOOST_PP_TUPLE_PUSH_BACK(VALUE_TYPE_NAME, DATA))))
1054 
1055 #endif  // DataFormats_SoATemplate_interface_SoAView_h