diff --git a/DataFormats/SoATemplate/README.md b/DataFormats/SoATemplate/README.md
index c2d7f14461ef7..9af697b0aa449 100644
--- a/DataFormats/SoATemplate/README.md
+++ b/DataFormats/SoATemplate/README.md
@@ -80,16 +80,14 @@ and `SOA_CONST_ELEMENT_METHODS` macros. Each of these macros can be called only
 
 `SoABlocks` is a macro-generated templated class that enables structured composition of multiple `SoALayouts` into a single
 container, referred to as "blocks". Each block is a Layout, and the structure itself looks like multiple contigous memory 
-buffers of different sizes. The alignment is ensured to be the same for every block. 
-`SoABlocks` also supports `View` and `ConstView` classes, mirroring the structure of the underlying structs. The blocks 
-are built via composition and access to individual layouts and views is provided by name.
-
-It is also possible to generate methods inside `View` and `ConstView` using the `SOA_VIEW_METHODS` and 
-`SOA_CONST_VIEW_METHODS` in the same way as described in [Customized methods](#customized-methods).
+buffers of different sizes. The alignment is ensured to be the same for every block. `SoABlocks` also supports 
+`View` and `ConstView` classes. In addition to those fully parametrized templates, two further levels of parametrization are provided:
+`ViewTemplate`, `ViewTemplateFreeParams` and respectively `ConstViewTemplate`, `ConstViewTemplateFreeParams`, 
+mirroring the structure of the underlying structs. The blocks are built via composition and access to individual layouts 
+and views is provided by name.
 
 TODOs:
 - Add introspection utilities to print the structure and layout of a `SoABlocks` instance.
-- Extend support for fully templated `View`/`ConstView` classes beyond the default parameters.
 - Implement support for heterogeneous `deepCopy()` operations between different but compatible `SoABlocks` configurations.
 
 [An example of utilization is showed below.](#examples)
diff --git a/DataFormats/SoATemplate/interface/SoABlocks.h b/DataFormats/SoATemplate/interface/SoABlocks.h
index 3bb87da8a71cc..236f504014069 100644
--- a/DataFormats/SoATemplate/interface/SoABlocks.h
+++ b/DataFormats/SoATemplate/interface/SoABlocks.h
@@ -12,8 +12,8 @@
  * Declare accessors for the View of each block
  */
 #define _DECLARE_ACCESSORS_VIEW_BLOCKS_IMPL(VALUE_TYPE, NAME, LAYOUT_NAME)                \
-  SOA_HOST_DEVICE SOA_INLINE LAYOUT_NAME<ALIGNMENT>::View NAME() {                        \
-    return LAYOUT_NAME<ALIGNMENT>::const_cast_View(base_type::BOOST_PP_CAT(NAME, View_)); \
+  SOA_HOST_DEVICE SOA_INLINE ViewFor<LayoutFor<LAYOUT_NAME>> NAME() {                     \
+    return LayoutFor<LAYOUT_NAME>::const_cast_View(base_type::BOOST_PP_CAT(NAME, View_)); \
   }
 
 #define _DECLARE_ACCESSORS_VIEW_BLOCKS(R, DATA, NAME)                            \
@@ -25,7 +25,7 @@
  * Declare parameters for contructing the View of an SoA by blocks
  * using different views for each block
  */
-#define _DECLARE_VIEW_CONSTRUCTOR_BLOCKS_IMPL(VALUE_TYPE, NAME, LAYOUT_NAME) (LAYOUT_NAME<ALIGNMENT>::View NAME)
+#define _DECLARE_VIEW_CONSTRUCTOR_BLOCKS_IMPL(VALUE_TYPE, NAME, LAYOUT_NAME) (ViewFor<LayoutFor<LAYOUT_NAME>> NAME)
 
 #define _DECLARE_VIEW_CONSTRUCTOR_BLOCKS(R, DATA, NAME)                          \
   BOOST_PP_IF(BOOST_PP_GREATER(BOOST_PP_TUPLE_ELEM(0, NAME), _VALUE_TYPE_BLOCK), \
@@ -61,8 +61,10 @@
 /*
  * Declare accessors for the ConstView of each block
  */
-#define _DECLARE_ACCESSORS_CONST_VIEW_BLOCKS_IMPL(VALUE_TYPE, NAME, LAYOUT_NAME) \
-  SOA_HOST_DEVICE SOA_INLINE const LAYOUT_NAME<ALIGNMENT>::ConstView NAME() const { return BOOST_PP_CAT(NAME, View_); }
+#define _DECLARE_ACCESSORS_CONST_VIEW_BLOCKS_IMPL(VALUE_TYPE, NAME, LAYOUT_NAME)       \
+  SOA_HOST_DEVICE SOA_INLINE const ConstViewFor<LayoutFor<LAYOUT_NAME>> NAME() const { \
+    return BOOST_PP_CAT(NAME, View_);                                                  \
+  }
 
 #define _DECLARE_ACCESSORS_CONST_VIEW_BLOCKS(R, DATA, NAME)                      \
   BOOST_PP_IF(BOOST_PP_GREATER(BOOST_PP_TUPLE_ELEM(0, NAME), _VALUE_TYPE_BLOCK), \
@@ -85,7 +87,7 @@
  * using different const views for each block
  */
 #define _DECLARE_CONST_VIEW_CONSTRUCTOR_BLOCKS_IMPL(VALUE_TYPE, NAME, LAYOUT_NAME) \
-  (LAYOUT_NAME<ALIGNMENT>::ConstView NAME)
+  (ConstViewFor<LayoutFor<LAYOUT_NAME>> NAME)
 
 #define _DECLARE_CONST_VIEW_CONSTRUCTOR_BLOCKS(R, DATA, NAME)                    \
   BOOST_PP_IF(BOOST_PP_GREATER(BOOST_PP_TUPLE_ELEM(0, NAME), _VALUE_TYPE_BLOCK), \
@@ -116,7 +118,7 @@
  * Declare the data members for the ConstView of the SoA by blocks
  */
 #define _DECLARE_MEMBERS_CONST_VIEW_BLOCKS_IMPL(VALUE_TYPE, NAME, LAYOUT_NAME) \
-  LAYOUT_NAME<ALIGNMENT>::ConstView BOOST_PP_CAT(NAME, View_);
+  ConstViewFor<LayoutFor<LAYOUT_NAME>> BOOST_PP_CAT(NAME, View_);
 
 #define _DECLARE_MEMBERS_CONST_VIEW_BLOCKS(R, DATA, NAME)                        \
   BOOST_PP_IF(BOOST_PP_GREATER(BOOST_PP_TUPLE_ELEM(0, NAME), _VALUE_TYPE_BLOCK), \
@@ -127,7 +129,7 @@
  * Declare accessors for the Layout of each block
  */
 #define _DECLARE_LAYOUTS_ACCESSORS_IMPL(VALUE_TYPE, NAME, LAYOUT_NAME) \
-  LAYOUT_NAME<ALIGNMENT> NAME() { return BOOST_PP_CAT(NAME, _); }
+  LayoutFor<LAYOUT_NAME> NAME() { return BOOST_PP_CAT(NAME, _); }
 
 #define _DECLARE_LAYOUTS_ACCESSORS(R, DATA, NAME)                                \
   BOOST_PP_IF(BOOST_PP_GREATER(BOOST_PP_TUPLE_ELEM(0, NAME), _VALUE_TYPE_BLOCK), \
@@ -138,7 +140,7 @@
  * Computation of the size for each block
  */
 #define _ACCUMULATE_SOA_BLOCKS_SIZE_IMPL(VALUE_TYPE, NAME, LAYOUT_NAME)   \
-  _soa_impl_ret += LAYOUT_NAME<ALIGNMENT>::computeDataSize(sizes[index]); \
+  _soa_impl_ret += LayoutFor<LAYOUT_NAME>::computeDataSize(sizes[index]); \
   index++;
 
 #define _ACCUMULATE_SOA_BLOCKS_SIZE(R, DATA, NAME)                               \
@@ -150,8 +152,8 @@
  * Computation of the block location in the memory layout (at SoA by blocks construction time)
  */
 #define _DECLARE_MEMBER_CONSTRUCTION_BLOCKS_IMPL(VALUE_TYPE, NAME, LAYOUT_NAME) \
-  BOOST_PP_CAT(NAME, _) = LAYOUT_NAME<ALIGNMENT>(mem + offset, sizes_[index]);  \
-  offset += LAYOUT_NAME<ALIGNMENT>::computeDataSize(sizes_[index]);             \
+  BOOST_PP_CAT(NAME, _) = LayoutFor<LAYOUT_NAME>(mem + offset, sizes_[index]);  \
+  offset += LayoutFor<LAYOUT_NAME>::computeDataSize(sizes_[index]);             \
   index++;
 
 #define _DECLARE_MEMBER_CONSTRUCTION_BLOCKS(R, DATA, NAME)                       \
@@ -247,7 +249,7 @@
               BOOST_PP_EMPTY(),                                                  \
               BOOST_PP_EXPAND(_ROOT_FREE_SOA_BLOCK_COLUMN_OR_SCALAR_IMPL NAME))
 
-#define _DECLARE_MEMBERS_BLOCKS_IMPL(VALUE_TYPE, NAME, LAYOUT_NAME) LAYOUT_NAME<ALIGNMENT> BOOST_PP_CAT(NAME, _);
+#define _DECLARE_MEMBERS_BLOCKS_IMPL(VALUE_TYPE, NAME, LAYOUT_NAME) LayoutFor<LAYOUT_NAME> BOOST_PP_CAT(NAME, _);
 
 /*
  * Declare the data members for the SoA by blocks
@@ -265,12 +267,19 @@
   template <CMS_SOA_BYTE_SIZE_TYPE ALIGNMENT = cms::soa::CacheLineSize::defaultSize,                                   \
             bool ALIGNMENT_ENFORCEMENT = cms::soa::AlignmentEnforcement::relaxed>                                      \
   struct CLASS {                                                                                                       \
+    template <template <CMS_SOA_BYTE_SIZE_TYPE, bool> class LAYOUT>                                                    \
+    using LayoutFor = typename cms::soa::LayoutParameters<ALIGNMENT>::template                                         \
+                                AlignmentEnforcement<ALIGNMENT_ENFORCEMENT>::template Layout<LAYOUT>;                  \
     using size_type = cms::soa::size_type;                                                                             \
     using byte_size_type = cms::soa::byte_size_type;                                                                   \
     constexpr static byte_size_type alignment = ALIGNMENT;                                                             \
+    constexpr static bool alignmentEnforcement = ALIGNMENT_ENFORCEMENT;                                                \
                                                                                                                        \
-    struct ConstView;                                                                                                  \
-    struct View;                                                                                                       \
+    template <CMS_SOA_BYTE_SIZE_TYPE VIEW_ALIGNMENT = cms::soa::CacheLineSize::defaultSize,                            \
+            bool VIEW_ALIGNMENT_ENFORCEMENT = cms::soa::AlignmentEnforcement::relaxed,                                 \
+            bool RESTRICT_QUALIFY = cms::soa::RestrictQualify::Default,                                                \
+            bool RANGE_CHECKING = cms::soa::RangeChecking::Default>                                                    \
+    struct ViewTemplateFreeParams;                                                                                     \
                                                                                                                        \
     /* Helper function to compute the total number of blocks */                                                        \
     static constexpr size_type computeBlocksNumber() {                                                                 \
@@ -319,11 +328,34 @@
                                                                                                                        \
     _ITERATE_ON_ALL(_DECLARE_LAYOUTS_ACCESSORS, ~, __VA_ARGS__)                                                        \
                                                                                                                        \
-    struct ConstView {                                                                                                 \
-      friend struct View;                                                                                              \
+    template <std::size_t VIEW_ALIGNMENT, bool VIEW_ALIGNMENT_ENFORCEMENT, bool RESTRICT_QUALIFY, bool RANGE_CHECKING> \
+    struct ConstViewTemplateFreeParams {                                                                               \
+      using BOOST_PP_CAT(CLASS, _parametrized) = CLASS<VIEW_ALIGNMENT, VIEW_ALIGNMENT_ENFORCEMENT>;                    \
+                                                                                                                       \
+      template <typename LayoutT>                                                                                      \
+      using ConstViewFor = typename LayoutT::template ConstViewTemplate<RESTRICT_QUALIFY, RANGE_CHECKING>;             \
+                                                                                                                       \
+      using size_type = cms::soa::size_type;                                                                           \
+      using byte_size_type = cms::soa::byte_size_type;                                                                 \
+      using AlignmentEnforcement = cms::soa::AlignmentEnforcement;                                                     \
+                                                                                                                       \
+      template <CMS_SOA_BYTE_SIZE_TYPE, bool, bool, bool>                                                              \
+      friend struct ViewTemplateFreeParams;                                                                            \
+                                                                                                                       \
+      template <CMS_SOA_BYTE_SIZE_TYPE, bool, bool, bool>                                                              \
+      friend struct ConstViewTemplateFreeParams;                                                                       \
+                                                                                                                       \
+      constexpr static byte_size_type defaultAlignment = cms::soa::CacheLineSize::defaultSize;                         \
+      constexpr static byte_size_type alignment = VIEW_ALIGNMENT;                                                      \
+      constexpr static bool alignmentEnforcement = VIEW_ALIGNMENT_ENFORCEMENT;                                         \
+      constexpr static byte_size_type conditionalAlignment =                                                           \
+          alignmentEnforcement == AlignmentEnforcement::enforced ? alignment : 0;                                      \
+      constexpr static bool restrictQualify = RESTRICT_QUALIFY;                                                        \
+      constexpr static bool rangeChecking = RANGE_CHECKING;                                                            \
       /* Helper/friend class allowing SoA by blocks ConstView introspection. */                                        \
       struct Metadata {                                                                                                \
-        friend ConstView;                                                                                              \
+        friend ConstViewTemplateFreeParams;                                                                            \
+        using TypeOf_Layout = BOOST_PP_CAT(CLASS, _parametrized);                                                      \
         SOA_HOST_DEVICE SOA_INLINE std::array<size_type, blocksNumber> size() const { return parent_.sizes_; }         \
                                                                                                                        \
         /* Forbid copying to avoid const correctness evasion */                                                        \
@@ -331,35 +363,36 @@
         Metadata(const Metadata&) = delete;                                                                            \
                                                                                                                        \
       private:                                                                                                         \
-        SOA_HOST_DEVICE SOA_INLINE Metadata(const ConstView& _soa_impl_parent)                                         \
+        SOA_HOST_DEVICE SOA_INLINE Metadata(const ConstViewTemplateFreeParams& _soa_impl_parent)                       \
           : parent_(_soa_impl_parent) {}                                                                               \
-        const ConstView& parent_;                                                                                      \
+        const ConstViewTemplateFreeParams& parent_;                                                                    \
       };                                                                                                               \
                                                                                                                        \
       friend Metadata;                                                                                                 \
       SOA_HOST_DEVICE SOA_INLINE const Metadata metadata() const { return Metadata(*this); }                           \
                                                                                                                        \
       /* Trivial constuctor */                                                                                         \
-      ConstView() = default;                                                                                           \
+      ConstViewTemplateFreeParams() = default;                                                                         \
                                                                                                                        \
       /* Copiable */                                                                                                   \
-      ConstView(ConstView const&) = default;                                                                           \
-      ConstView& operator=(ConstView const&) = default;                                                                \
+      ConstViewTemplateFreeParams(ConstViewTemplateFreeParams const&) = default;                                       \
+      ConstViewTemplateFreeParams& operator=(ConstViewTemplateFreeParams const&) = default;                            \
                                                                                                                        \
       /* Movable */                                                                                                    \
-      ConstView(ConstView &&) = default;                                                                               \
-      ConstView& operator=(ConstView &&) = default;                                                                    \
+      ConstViewTemplateFreeParams(ConstViewTemplateFreeParams&&) = default;                                            \
+      ConstViewTemplateFreeParams& operator=(ConstViewTemplateFreeParams&&) = default;                                 \
                                                                                                                        \
       /* Trivial destuctor */                                                                                          \
-      ~ConstView() = default;                                                                                          \
+      ~ConstViewTemplateFreeParams() = default;                                                                        \
                                                                                                                        \
       /* Constructor relying on user provided Layout by blocks */                                                      \
-      SOA_HOST_ONLY ConstView(CLASS& blocks)                                                                           \
+      SOA_HOST_ONLY ConstViewTemplateFreeParams(const Metadata::TypeOf_Layout& blocks)                                 \
           : _ITERATE_ON_ALL_COMMA(_DECLARE_MEMBER_CONST_VIEW_CONSTRUCTION_BLOCKS, ~, __VA_ARGS__),                     \
             sizes_{blocks.sizes_} {}                                                                                   \
                                                                                                                        \
       /* Constructor relying on user provided const views for each block */                                            \
-      SOA_HOST_ONLY ConstView(_ITERATE_ON_ALL_COMMA(_DECLARE_CONST_VIEW_CONSTRUCTOR_BLOCKS, ~, __VA_ARGS__))           \
+      SOA_HOST_ONLY ConstViewTemplateFreeParams(                                                                       \
+            _ITERATE_ON_ALL_COMMA(_DECLARE_CONST_VIEW_CONSTRUCTOR_BLOCKS, ~, __VA_ARGS__))                             \
           : _ITERATE_ON_ALL_COMMA(_INITIALIZE_MEMBER_CONST_VIEW_BLOCKS, ~, __VA_ARGS__),                               \
             sizes_{{_ITERATE_ON_ALL_COMMA(_DECLARE_CONST_VIEW_SIZES, ~, __VA_ARGS__)}} {}                              \
                                                                                                                        \
@@ -371,11 +404,42 @@
         std::array<size_type, blocksNumber> sizes_;                                                                    \
     };                                                                                                                 \
                                                                                                                        \
-    struct View : ConstView {                                                                                          \
-      using base_type = ConstView;                                                                                     \
+    template <bool RESTRICT_QUALIFY, bool RANGE_CHECKING>                                                              \
+    using ConstViewTemplate = ConstViewTemplateFreeParams<ALIGNMENT, ALIGNMENT_ENFORCEMENT, RESTRICT_QUALIFY,          \
+      RANGE_CHECKING>;                                                                                                 \
+                                                                                                                       \
+    using ConstView = ConstViewTemplate<cms::soa::RestrictQualify::Default, cms::soa::RangeChecking::Default>;         \
+                                                                                                                       \
+    template <CMS_SOA_BYTE_SIZE_TYPE VIEW_ALIGNMENT,                                                                   \
+              bool VIEW_ALIGNMENT_ENFORCEMENT,                                                                         \
+              bool RESTRICT_QUALIFY,                                                                                   \
+              bool RANGE_CHECKING>                                                                                     \
+      struct ViewTemplateFreeParams                                                                                    \
+      : public ConstViewTemplateFreeParams<VIEW_ALIGNMENT, VIEW_ALIGNMENT_ENFORCEMENT,                                 \
+                                           RESTRICT_QUALIFY, RANGE_CHECKING> {                                         \
+      using BOOST_PP_CAT(CLASS, _parametrized) = CLASS<VIEW_ALIGNMENT, VIEW_ALIGNMENT_ENFORCEMENT>;                    \
+      template <typename LayoutT>                                                                                      \
+      using ViewFor = typename LayoutT::template ViewTemplate<RESTRICT_QUALIFY, RANGE_CHECKING>;                       \
+      using base_type =                                                                                                \
+        ConstViewTemplateFreeParams<VIEW_ALIGNMENT, VIEW_ALIGNMENT_ENFORCEMENT, RESTRICT_QUALIFY, RANGE_CHECKING>;     \
+      using size_type = cms::soa::size_type;                                                                           \
+      using byte_size_type = cms::soa::byte_size_type;                                                                 \
+      using AlignmentEnforcement = cms::soa::AlignmentEnforcement;                                                     \
+                                                                                                                       \
+      constexpr static byte_size_type defaultAlignment = cms::soa::CacheLineSize::defaultSize;                         \
+      constexpr static byte_size_type alignment = VIEW_ALIGNMENT;                                                      \
+      constexpr static bool alignmentEnforcement = VIEW_ALIGNMENT_ENFORCEMENT;                                         \
+      constexpr static byte_size_type conditionalAlignment =                                                           \
+          alignmentEnforcement == AlignmentEnforcement::enforced ? alignment : 0;                                      \
+      constexpr static bool restrictQualify = RESTRICT_QUALIFY;                                                        \
+      constexpr static bool rangeChecking = RANGE_CHECKING;                                                            \
+                                                                                                                       \
+      template <CMS_SOA_BYTE_SIZE_TYPE, bool, bool, bool>                                                              \
+      friend struct ViewTemplateFreeParams;                                                                            \
       /* Helper/friend class allowing SoA by blocks View introspection. */                                             \
       struct Metadata {                                                                                                \
-        friend View;                                                                                                   \
+        friend ViewTemplateFreeParams;                                                                                 \
+        using TypeOf_Layout = BOOST_PP_CAT(CLASS, _parametrized);                                                      \
         SOA_HOST_DEVICE SOA_INLINE std::array<size_type, blocksNumber> size() const { return parent_.sizes_; }         \
                                                                                                                        \
         /* Forbid copying to avoid const correctness evasion */                                                        \
@@ -383,9 +447,9 @@
         Metadata(const Metadata&) = delete;                                                                            \
                                                                                                                        \
       private:                                                                                                         \
-        SOA_HOST_DEVICE SOA_INLINE Metadata(const View& _soa_impl_parent)                                              \
+        SOA_HOST_DEVICE SOA_INLINE Metadata(const ViewTemplateFreeParams& _soa_impl_parent)                            \
           : parent_(_soa_impl_parent) {}                                                                               \
-        const View& parent_;                                                                                           \
+        const ViewTemplateFreeParams& parent_;                                                                         \
       };                                                                                                               \
                                                                                                                        \
       friend Metadata;                                                                                                 \
@@ -393,25 +457,25 @@
       SOA_HOST_DEVICE SOA_INLINE Metadata metadata() { return Metadata(*this); }                                       \
                                                                                                                        \
       /* Trivial constuctor */                                                                                         \
-      View() = default;                                                                                                \
+      ViewTemplateFreeParams() = default;                                                                              \
                                                                                                                        \
       /* Copiable */                                                                                                   \
-      View(View const&) = default;                                                                                     \
-      View& operator=(View const&) = default;                                                                          \
+      ViewTemplateFreeParams(ViewTemplateFreeParams const&) = default;                                                 \
+      ViewTemplateFreeParams& operator=(ViewTemplateFreeParams const&) = default;                                      \
                                                                                                                        \
       /* Movable */                                                                                                    \
-      View(View &&) = default;                                                                                         \
-      View& operator=(View &&) = default;                                                                              \
+      ViewTemplateFreeParams(ViewTemplateFreeParams&&) = default;                                                      \
+      ViewTemplateFreeParams& operator=(ViewTemplateFreeParams&&) = default;                                           \
                                                                                                                        \
       /* Trivial destuctor */                                                                                          \
-      ~View() = default;                                                                                               \
+      ~ViewTemplateFreeParams() = default;                                                                             \
                                                                                                                        \
       /* Constructor relying on user provided Layout by blocks */                                                      \
-      SOA_HOST_ONLY View(CLASS& blocks)                                                                                \
+      SOA_HOST_ONLY ViewTemplateFreeParams(Metadata::TypeOf_Layout& blocks)                                            \
           : base_type{blocks} {}                                                                                       \
                                                                                                                        \
       /* Constructor relying on user provided views for each block */                                                  \
-      SOA_HOST_ONLY View(_ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_CONSTRUCTOR_BLOCKS, ~, __VA_ARGS__)) :                    \
+      SOA_HOST_ONLY ViewTemplateFreeParams(_ITERATE_ON_ALL_COMMA(_DECLARE_VIEW_CONSTRUCTOR_BLOCKS, ~, __VA_ARGS__)) :  \
         base_type{_ITERATE_ON_ALL_COMMA(_INITIALIZE_MEMBER_VIEW_BLOCKS, ~, __VA_ARGS__)} {}                            \
                                                                                                                        \
       /* Accessors for the views for each block */                                                                     \
@@ -419,6 +483,9 @@
                                                                                                                        \
        /* Data members inherited from the ConstView */                                                                 \
     };                                                                                                                 \
+    template <bool RESTRICT_QUALIFY, bool RANGE_CHECKING>                                                              \
+    using ViewTemplate = ViewTemplateFreeParams<ALIGNMENT, ALIGNMENT_ENFORCEMENT, RESTRICT_QUALIFY, RANGE_CHECKING>;   \
+    using View = ViewTemplate<cms::soa::RestrictQualify::Default, cms::soa::RangeChecking::Default>;                   \
                                                                                                                        \
     /* TODO: implement Descriptor and ConstDescriptor for Blocks to enable heterogeneous deepCopy */                   \
     struct Descriptor;                                                                                                 \
diff --git a/DataFormats/SoATemplate/interface/SoACommon.h b/DataFormats/SoATemplate/interface/SoACommon.h
index b9533ad7f1ef1..135e0444eb4d6 100644
--- a/DataFormats/SoATemplate/interface/SoACommon.h
+++ b/DataFormats/SoATemplate/interface/SoACommon.h
@@ -195,6 +195,16 @@ namespace cms::soa {
     byte_size_type stride_ = 0;
   };
 
+  // Matryoshka template to avoid commas inside macros
+  template <CMS_SOA_BYTE_SIZE_TYPE ALIGNMENT>
+  struct LayoutParameters {
+    template <bool ALIGNMENT_ENFORCEMENT>
+    struct AlignmentEnforcement {
+      template <template <CMS_SOA_BYTE_SIZE_TYPE, bool> typename T>
+      using Layout = T<ALIGNMENT, ALIGNMENT_ENFORCEMENT>;
+    };
+  };
+
   // Matryoshka template to avoid commas inside macros
   template <SoAColumnType COLUMN_TYPE>
   struct SoAConstParameters_ColumnType {
diff --git a/DataFormats/SoATemplate/interface/SoALayout.h b/DataFormats/SoATemplate/interface/SoALayout.h
index 8f9a01a8b6ca6..e18bfde991128 100644
--- a/DataFormats/SoATemplate/interface/SoALayout.h
+++ b/DataFormats/SoATemplate/interface/SoALayout.h
@@ -1795,8 +1795,11 @@ _SWITCH_ON_TYPE(VALUE_TYPE,
     }                                                                                                                  \
                                                                                                                        \
     /* Helper to implement View as derived from ConstView in SoABlocks implementation */                               \
-    SOA_HOST_DEVICE SOA_INLINE static View const_cast_View(ConstView const& view)  {                                   \
-      return View{view.metadata().size(), _ITERATE_ON_ALL_COMMA(_DECLARE_CONST_CAST_COLUMNS, ~, __VA_ARGS__)};         \
+    template <bool RESTRICT_QUALIFY, bool RANGE_CHECKING>                                                              \
+    SOA_HOST_DEVICE SOA_INLINE static ViewTemplate<RESTRICT_QUALIFY, RANGE_CHECKING> const_cast_View(                  \
+      ConstViewTemplate<RESTRICT_QUALIFY, RANGE_CHECKING> const& view)  {                                              \
+      return ViewTemplate<RESTRICT_QUALIFY, RANGE_CHECKING>{                                                           \
+        view.metadata().size(), _ITERATE_ON_ALL_COMMA(_DECLARE_CONST_CAST_COLUMNS, ~, __VA_ARGS__)};                   \
     }                                                                                                                  \
                                                                                                                        \
     /*                                                                                                                 \
diff --git a/DataFormats/SoATemplate/test/SoABlocks_t.cc b/DataFormats/SoATemplate/test/SoABlocks_t.cc
index b9065e2a3218c..b2caee477386d 100644
--- a/DataFormats/SoATemplate/test/SoABlocks_t.cc
+++ b/DataFormats/SoATemplate/test/SoABlocks_t.cc
@@ -28,7 +28,6 @@ GENERATE_SOA_BLOCKS(SoABlocksTemplate,
                     SOA_BLOCK(scalars, SoATemplate))
 
 using SoABlocks = SoABlocksTemplate<>;
-// TODO: Implement template version of View and ConstView (ViewTemplate and ConstViewTemplate)
 using SoABlocksView = SoABlocks::View;
 using SoABlocksConstView = SoABlocks::ConstView;
 
@@ -44,6 +43,18 @@ TEST_CASE("SoABlocks") {
   SoABlocksView blocksView{blocks};
   SoABlocksConstView blocksConstView{blocks};
 
+  REQUIRE(SoABlocks::alignment == cms::soa::CacheLineSize::defaultSize);
+  REQUIRE(SoABlocks::alignmentEnforcement == cms::soa::AlignmentEnforcement::relaxed);
+
+  REQUIRE(blocks.position().alignment == cms::soa::CacheLineSize::defaultSize);
+  REQUIRE(blocks.position().alignmentEnforcement == cms::soa::AlignmentEnforcement::relaxed);
+
+  REQUIRE(blocks.pca().alignment == cms::soa::CacheLineSize::defaultSize);
+  REQUIRE(blocks.pca().alignmentEnforcement == cms::soa::AlignmentEnforcement::relaxed);
+
+  REQUIRE(blocks.scalars().alignment == cms::soa::CacheLineSize::defaultSize);
+  REQUIRE(blocks.scalars().alignmentEnforcement == cms::soa::AlignmentEnforcement::relaxed);
+
   // Verify position data
   REQUIRE(blocks.position().metadata().nextByte() == blocks.metadata().addressOf_pca());
   REQUIRE(blocks.pca().metadata().nextByte() == blocks.metadata().addressOf_scalars());
@@ -142,4 +153,85 @@ TEST_CASE("SoABlocks") {
     REQUIRE_THROWS_AS(blocksConstView.pca().vector_1(underflow), std::out_of_range);
     REQUIRE_THROWS_AS(blocksConstView.pca().vector_1(overflow), std::out_of_range);
   }
+
+  SECTION("Check template parameters") {
+    static constexpr cms::soa::byte_size_type testAlignment = 256;
+    static constexpr bool alignmentEnforcement = cms::soa::AlignmentEnforcement::enforced;
+
+    using SoABlocksTemplated = SoABlocksTemplate<testAlignment, alignmentEnforcement>;
+
+    std::array<cms::soa::size_type, 3> sizes{{10, 20, 1}};
+    const std::size_t blocksBufferSize = SoABlocksTemplated::computeDataSize(sizes);
+
+    std::unique_ptr<std::byte, decltype(std::free) *> buffer{
+        reinterpret_cast<std::byte *>(aligned_alloc(SoABlocksTemplated::alignment, blocksBufferSize)), std::free};
+
+    SoABlocksTemplated blocksTemplated(buffer.get(), sizes);
+
+    REQUIRE(SoABlocksTemplated::alignment == testAlignment);
+    REQUIRE(SoABlocksTemplated::alignmentEnforcement == alignmentEnforcement);
+
+    REQUIRE(blocksTemplated.position().alignment == testAlignment);
+    REQUIRE(blocksTemplated.position().alignmentEnforcement == alignmentEnforcement);
+
+    REQUIRE(blocksTemplated.pca().alignment == testAlignment);
+    REQUIRE(blocksTemplated.pca().alignmentEnforcement == alignmentEnforcement);
+
+    REQUIRE(blocksTemplated.scalars().alignment == testAlignment);
+    REQUIRE(blocksTemplated.scalars().alignmentEnforcement == alignmentEnforcement);
+  }
+
+  SECTION("Check view template parameters") {
+    using NoRangeCheckBlockView =
+        SoABlocks::ViewTemplate<cms::soa::RestrictQualify::Default, cms::soa::RangeChecking::disabled>;
+    NoRangeCheckBlockView noRangeCheckBlockView{blocks};
+
+    REQUIRE(noRangeCheckBlockView.restrictQualify == cms::soa::RestrictQualify::Default);
+    REQUIRE(noRangeCheckBlockView.rangeChecking == cms::soa::RangeChecking::disabled);
+    REQUIRE(noRangeCheckBlockView.position().restrictQualify == cms::soa::RestrictQualify::Default);
+    REQUIRE(noRangeCheckBlockView.position().rangeChecking == cms::soa::RangeChecking::disabled);
+    REQUIRE(noRangeCheckBlockView.pca().restrictQualify == cms::soa::RestrictQualify::Default);
+    REQUIRE(noRangeCheckBlockView.pca().rangeChecking == cms::soa::RangeChecking::disabled);
+    REQUIRE(noRangeCheckBlockView.scalars().restrictQualify == cms::soa::RestrictQualify::Default);
+    REQUIRE(noRangeCheckBlockView.scalars().rangeChecking == cms::soa::RangeChecking::disabled);
+
+    using NoRestrictBlockView =
+        SoABlocks::ViewTemplate<cms::soa::RestrictQualify::disabled, cms::soa::RangeChecking::Default>;
+    NoRestrictBlockView noRestrictBlockView{blocks};
+
+    REQUIRE(noRestrictBlockView.restrictQualify == cms::soa::RestrictQualify::disabled);
+    REQUIRE(noRestrictBlockView.rangeChecking == cms::soa::RangeChecking::Default);
+    REQUIRE(noRestrictBlockView.position().restrictQualify == cms::soa::RestrictQualify::disabled);
+    REQUIRE(noRestrictBlockView.position().rangeChecking == cms::soa::RangeChecking::Default);
+    REQUIRE(noRestrictBlockView.pca().restrictQualify == cms::soa::RestrictQualify::disabled);
+    REQUIRE(noRestrictBlockView.pca().rangeChecking == cms::soa::RangeChecking::Default);
+    REQUIRE(noRestrictBlockView.scalars().restrictQualify == cms::soa::RestrictQualify::disabled);
+    REQUIRE(noRestrictBlockView.scalars().rangeChecking == cms::soa::RangeChecking::Default);
+
+    using NoRangeCheckBlockConstView =
+        SoABlocks::ConstViewTemplate<cms::soa::RestrictQualify::Default, cms::soa::RangeChecking::disabled>;
+    NoRangeCheckBlockConstView noRangeCheckBlockConstView{blocks};
+
+    REQUIRE(noRangeCheckBlockConstView.restrictQualify == cms::soa::RestrictQualify::Default);
+    REQUIRE(noRangeCheckBlockConstView.rangeChecking == cms::soa::RangeChecking::disabled);
+    REQUIRE(noRangeCheckBlockConstView.position().restrictQualify == cms::soa::RestrictQualify::Default);
+    REQUIRE(noRangeCheckBlockConstView.position().rangeChecking == cms::soa::RangeChecking::disabled);
+    REQUIRE(noRangeCheckBlockConstView.pca().restrictQualify == cms::soa::RestrictQualify::Default);
+    REQUIRE(noRangeCheckBlockConstView.pca().rangeChecking == cms::soa::RangeChecking::disabled);
+    REQUIRE(noRangeCheckBlockConstView.scalars().restrictQualify == cms::soa::RestrictQualify::Default);
+    REQUIRE(noRangeCheckBlockConstView.scalars().rangeChecking == cms::soa::RangeChecking::disabled);
+
+    using NoRestrictBlockConstView =
+        SoABlocks::ConstViewTemplate<cms::soa::RestrictQualify::disabled, cms::soa::RangeChecking::Default>;
+    NoRestrictBlockConstView noRestrictBlockConstView{blocks};
+
+    REQUIRE(noRestrictBlockConstView.restrictQualify == cms::soa::RestrictQualify::disabled);
+    REQUIRE(noRestrictBlockConstView.rangeChecking == cms::soa::RangeChecking::Default);
+    REQUIRE(noRestrictBlockConstView.position().restrictQualify == cms::soa::RestrictQualify::disabled);
+    REQUIRE(noRestrictBlockConstView.position().rangeChecking == cms::soa::RangeChecking::Default);
+    REQUIRE(noRestrictBlockConstView.pca().restrictQualify == cms::soa::RestrictQualify::disabled);
+    REQUIRE(noRestrictBlockConstView.pca().rangeChecking == cms::soa::RangeChecking::Default);
+    REQUIRE(noRestrictBlockConstView.scalars().restrictQualify == cms::soa::RestrictQualify::disabled);
+    REQUIRE(noRestrictBlockConstView.scalars().rangeChecking == cms::soa::RangeChecking::Default);
+  }
 }