[math] add structured bindings to displacement vectors 2D 3D and LorentzVector

Fixes #11806

Author: ferdymercury

math/genvector/inc/Math/GenVector/DisplacementVector2D.h

@@ -166,6 +166,7 @@ namespace ROOT {
         /**
            get internal data into 2 Scalar numbers.
            These are for example (x,y) for a cartesian vector or (r,phi) for a polar vector
+           \note Alternatively, you may use structured bindings: `auto const [a, b] = v`.
         */
         void GetCoordinates( Scalar& a, Scalar& b) const
         { fCoordinates.GetCoordinates(a, b);  }
@@ -538,12 +539,32 @@ namespace ROOT {
 
      }  // op>> <>()
 
-
+     // Structured bindings
+     template <std::size_t I, class CoordSystem, class Tag>
+     typename CoordSystem::Scalar get(DisplacementVector2D<CoordSystem, Tag> const& p)
+     {
+        static_assert(I < 2);
+        if constexpr (I == 0) {
+           return p.x();
+        } else {
+           return p.y();
+        }
+     }
 
   }  // namespace Math
 
 }  // namespace ROOT
 
+// Structured bindings
+#include <tuple>
+namespace std {
+   template <class CoordSystem, class Tag>
+   struct tuple_size<ROOT::Math::DisplacementVector2D<CoordSystem, Tag>> : integral_constant<size_t, 2> {};
+   template <size_t I, class CoordSystem, class Tag>
+   struct tuple_element<I, ROOT::Math::DisplacementVector2D<CoordSystem, Tag>> {
+      static_assert(I < 2);
+      using type = typename CoordSystem::Scalar;
+   };
+}
 
 #endif /* ROOT_Math_GenVector_DisplacementVector2D  */
-

math/genvector/inc/Math/GenVector/DisplacementVector3D.h

@@ -209,6 +209,7 @@ namespace ROOT {
 
       /**
          get internal data into 3 Scalar numbers
+         \note Alternatively, you may use structured bindings: `auto const [a, b, c] = v`.
        */
       void GetCoordinates( Scalar& a, Scalar& b, Scalar& c ) const
                             { fCoordinates.GetCoordinates(a, b, c);  }
@@ -698,12 +699,35 @@ namespace ROOT {
 
     }  // op>> <>()
 
-
+    // Structured bindings
+    template <std::size_t I, class CoordSystem, class Tag>
+    typename CoordSystem::Scalar get(DisplacementVector3D<CoordSystem, Tag> const& p)
+    {
+       static_assert(I < 3);
+       if constexpr (I == 0) {
+          return p.x();
+       } else if constexpr (I == 1) {
+          return p.y();
+       } else {
+          return p.z();
+       }
+    }
 
   }  // namespace Math
 
 }  // namespace ROOT
 
+// Structured bindings
+#include <tuple>
+namespace std {
+   template <class CoordSystem, class Tag>
+   struct tuple_size<ROOT::Math::DisplacementVector3D<CoordSystem, Tag>> : integral_constant<size_t, 3> {};
+   template <size_t I, class CoordSystem, class Tag>
+   struct tuple_element<I, ROOT::Math::DisplacementVector3D<CoordSystem, Tag>> {
+      static_assert(I < 3);
+      using type = typename CoordSystem::Scalar;
+   };
+}
 
 #endif /* ROOT_Math_GenVector_DisplacementVector3D  */
 

math/genvector/inc/Math/GenVector/LorentzVector.h

@@ -203,6 +203,7 @@ Pt (or rho) refers to transverse momentum, whereas eta refers to pseudorapidity.
 
        /**
           get internal data into 4 Scalar numbers
+          \note Alternatively, you may use structured bindings: `auto const [a, b, c, d] = v`.
        */
        void GetCoordinates( Scalar& a, Scalar& b, Scalar& c, Scalar & d ) const
        { fCoordinates.GetCoordinates(a, b, c, d);  }
@@ -861,12 +862,38 @@ Pt (or rho) refers to transverse momentum, whereas eta refers to pseudorapidity.
 
      }  // op>> <>()
 
-
+    // Structured bindings
+    template <std::size_t I, class CoordSystem>
+    typename CoordSystem::Scalar get(LorentzVector<CoordSystem> const& p)
+    {
+       static_assert(I < 4);
+       if constexpr (I == 0) {
+          return p.X();
+       } else if constexpr (I == 1) {
+          return p.Y();
+       } else if constexpr (I == 2) {
+          return p.Z();
+       } else {
+          return p.E();
+       }
+    }
 
   } // end namespace Math
 
 } // end namespace ROOT
 
+// Structured bindings
+#include <tuple>
+namespace std {
+   template <class CoordSystem>
+   struct tuple_size<ROOT::Math::LorentzVector<CoordSystem>> : integral_constant<size_t, 4> {};
+   template <size_t I, class CoordSystem>
+   struct tuple_element<I, ROOT::Math::LorentzVector<CoordSystem>> {
+      static_assert(I < 4);
+      using type = typename CoordSystem::Scalar;
+   };
+}
+
 #include <sstream>
 namespace cling
 {