From 2010d85fb4a5d3e57c5deee3279918ba5aea75bc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andreas=20S=C3=BC=C3=9Fenbach?= <asuessenbach@nvidia.com>
Date: Thu, 3 Jul 2025 10:29:37 +0200
Subject: [PATCH] Remove redundant occurrences of VULKAN_HPP_NAMESPACE:: in
 vulkan_shared.hpp (#2207)

---
 snippets/SharedHandleSpecializations.hpp | 56 +++++++++++------------
 vulkan/vulkan_raii.hpp                   | 21 +++++++--
 vulkan/vulkan_shared.hpp                 | 57 +++++++++++-------------
 3 files changed, 73 insertions(+), 61 deletions(-)

diff --git a/snippets/SharedHandleSpecializations.hpp b/snippets/SharedHandleSpecializations.hpp
index 81f3f10..f50738c 100644
--- a/snippets/SharedHandleSpecializations.hpp
+++ b/snippets/SharedHandleSpecializations.hpp
@@ -5,12 +5,12 @@ enum class SwapchainOwns
   yes,
 };
 
-struct ImageHeader : SharedHeader<DestructorTypeOf<VULKAN_HPP_NAMESPACE::Image>, typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter>
+struct ImageHeader : SharedHeader<DestructorTypeOf<Image>, typename SharedHandleTraits<Image>::deleter>
 {
-  ImageHeader( SharedHandle<DestructorTypeOf<VULKAN_HPP_NAMESPACE::Image>>       parent,
-               typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter deleter = typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter(),
-               SwapchainOwns                                                     swapchainOwned = SwapchainOwns::no ) VULKAN_HPP_NOEXCEPT
-    : SharedHeader<DestructorTypeOf<VULKAN_HPP_NAMESPACE::Image>, typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter>( std::move( parent ),
+  ImageHeader( SharedHandle<DestructorTypeOf<Image>>       parent,
+               typename SharedHandleTraits<Image>::deleter deleter        = typename SharedHandleTraits<Image>::deleter(),
+               SwapchainOwns                               swapchainOwned = SwapchainOwns::no ) VULKAN_HPP_NOEXCEPT
+    : SharedHeader<DestructorTypeOf<Image>, typename SharedHandleTraits<Image>::deleter>( std::move( parent ),
                                                                                                                                       std::move( deleter ) )
     , swapchainOwned( swapchainOwned )
   {
@@ -20,25 +20,25 @@ struct ImageHeader : SharedHeader<DestructorTypeOf<VULKAN_HPP_NAMESPACE::Image>,
 };
 
 template <>
-class SharedHandle<VULKAN_HPP_NAMESPACE::Image> : public SharedHandleBase<VULKAN_HPP_NAMESPACE::Image, ImageHeader>
+class SharedHandle<Image> : public SharedHandleBase<Image, ImageHeader>
 {
-  using BaseType    = SharedHandleBase<VULKAN_HPP_NAMESPACE::Image, ImageHeader>;
-  using DeleterType = typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter;
+  using BaseType    = SharedHandleBase<Image, ImageHeader>;
+  using DeleterType = typename SharedHandleTraits<Image>::deleter;
   friend BaseType;
 
 public:
   SharedHandle() = default;
 
-  explicit SharedHandle( VULKAN_HPP_NAMESPACE::Image                                 handle,
-                         SharedHandle<DestructorTypeOf<VULKAN_HPP_NAMESPACE::Image>> parent,
-                         SwapchainOwns                                               swapchain_owned = SwapchainOwns::no,
-                         DeleterType                                                 deleter         = DeleterType() ) VULKAN_HPP_NOEXCEPT
+  explicit SharedHandle( Image                                 handle,
+                         SharedHandle<DestructorTypeOf<Image>> parent,
+                         SwapchainOwns                         swapchain_owned = SwapchainOwns::no,
+                         DeleterType                           deleter         = DeleterType() ) VULKAN_HPP_NOEXCEPT
     : BaseType( handle, std::move( parent ), std::move( deleter ), swapchain_owned )
   {
   }
 
 protected:
-  static void internalDestroy( const ImageHeader & control, VULKAN_HPP_NAMESPACE::Image handle ) VULKAN_HPP_NOEXCEPT
+  static void internalDestroy( const ImageHeader & control, Image handle ) VULKAN_HPP_NOEXCEPT
   {
     if ( control.swapchainOwned == SwapchainOwns::no )
     {
@@ -49,41 +49,41 @@ protected:
 
 struct SwapchainHeader
 {
-  SwapchainHeader( SharedHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR>                           surface,
-                   SharedHandle<DestructorTypeOf<VULKAN_HPP_NAMESPACE::SwapchainKHR>>       parent,
-                   typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::SwapchainKHR>::deleter deleter =
-                     typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::SwapchainKHR>::deleter() ) VULKAN_HPP_NOEXCEPT
+  SwapchainHeader( SharedHandle<SurfaceKHR>                           surface,
+                   SharedHandle<DestructorTypeOf<SwapchainKHR>>       parent,
+                   typename SharedHandleTraits<SwapchainKHR>::deleter deleter =
+                     typename SharedHandleTraits<SwapchainKHR>::deleter() ) VULKAN_HPP_NOEXCEPT
     : surface( std::move( surface ) )
     , parent( std::move( parent ) )
     , deleter( std::move( deleter ) )
   {
   }
 
-  SharedHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR>                           surface{};
-  SharedHandle<DestructorTypeOf<VULKAN_HPP_NAMESPACE::SwapchainKHR>>       parent{};
-  typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::SwapchainKHR>::deleter deleter{};
+  SharedHandle<SurfaceKHR>                           surface{};
+  SharedHandle<DestructorTypeOf<SwapchainKHR>>       parent{};
+  typename SharedHandleTraits<SwapchainKHR>::deleter deleter{};
 };
 
 template <>
-class SharedHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR> : public SharedHandleBase<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainHeader>
+class SharedHandle<SwapchainKHR> : public SharedHandleBase<SwapchainKHR, SwapchainHeader>
 {
-  using BaseType    = SharedHandleBase<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainHeader>;
-  using DeleterType = typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::SwapchainKHR>::deleter;
+  using BaseType    = SharedHandleBase<SwapchainKHR, SwapchainHeader>;
+  using DeleterType = typename SharedHandleTraits<SwapchainKHR>::deleter;
   friend BaseType;
 
 public:
   SharedHandle() = default;
 
-  explicit SharedHandle( VULKAN_HPP_NAMESPACE::SwapchainKHR                                 handle,
-                         SharedHandle<DestructorTypeOf<VULKAN_HPP_NAMESPACE::SwapchainKHR>> parent,
-                         SharedHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR>                     surface,
-                         DeleterType                                                        deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
+  explicit SharedHandle( SwapchainKHR                                 handle,
+                         SharedHandle<DestructorTypeOf<SwapchainKHR>> parent,
+                         SharedHandle<SurfaceKHR>                     surface,
+                         DeleterType                                  deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
     : BaseType( handle, std::move( surface ), std::move( parent ), std::move( deleter ) )
   {
   }
 
 public:
-  const SharedHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR> & getSurface() const VULKAN_HPP_NOEXCEPT
+  const SharedHandle<SurfaceKHR> & getSurface() const VULKAN_HPP_NOEXCEPT
   {
     return getHeader().surface;
   }
diff --git a/vulkan/vulkan_raii.hpp b/vulkan/vulkan_raii.hpp
index 8e3c753..7a18d93 100644
--- a/vulkan/vulkan_raii.hpp
+++ b/vulkan/vulkan_raii.hpp
@@ -8830,11 +8830,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
-      VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM const & operator*() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM const & operator*() const & VULKAN_HPP_NOEXCEPT
       {
         return m_dataGraphPipelineSessionARM;
       }
 
+      VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM const && operator*() const && VULKAN_HPP_NOEXCEPT
+      {
+        return std::move( m_dataGraphPipelineSessionARM );
+      }
+
       operator VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM() const VULKAN_HPP_NOEXCEPT
       {
         return m_dataGraphPipelineSessionARM;
@@ -14749,11 +14754,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
-      VULKAN_HPP_NAMESPACE::TensorARM const & operator*() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::TensorARM const & operator*() const & VULKAN_HPP_NOEXCEPT
       {
         return m_tensorARM;
       }
 
+      VULKAN_HPP_NAMESPACE::TensorARM const && operator*() const && VULKAN_HPP_NOEXCEPT
+      {
+        return std::move( m_tensorARM );
+      }
+
       operator VULKAN_HPP_NAMESPACE::TensorARM() const VULKAN_HPP_NOEXCEPT
       {
         return m_tensorARM;
@@ -14875,11 +14885,16 @@ namespace VULKAN_HPP_NAMESPACE
         return *this;
       }
 
-      VULKAN_HPP_NAMESPACE::TensorViewARM const & operator*() const VULKAN_HPP_NOEXCEPT
+      VULKAN_HPP_NAMESPACE::TensorViewARM const & operator*() const & VULKAN_HPP_NOEXCEPT
       {
         return m_tensorViewARM;
       }
 
+      VULKAN_HPP_NAMESPACE::TensorViewARM const && operator*() const && VULKAN_HPP_NOEXCEPT
+      {
+        return std::move( m_tensorViewARM );
+      }
+
       operator VULKAN_HPP_NAMESPACE::TensorViewARM() const VULKAN_HPP_NOEXCEPT
       {
         return m_tensorViewARM;
diff --git a/vulkan/vulkan_shared.hpp b/vulkan/vulkan_shared.hpp
index ff649aa..73c2720 100644
--- a/vulkan/vulkan_shared.hpp
+++ b/vulkan/vulkan_shared.hpp
@@ -1051,14 +1051,12 @@ namespace VULKAN_HPP_NAMESPACE
     yes,
   };
 
-  struct ImageHeader : SharedHeader<DestructorTypeOf<VULKAN_HPP_NAMESPACE::Image>, typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter>
+  struct ImageHeader : SharedHeader<DestructorTypeOf<Image>, typename SharedHandleTraits<Image>::deleter>
   {
-    ImageHeader(
-      SharedHandle<DestructorTypeOf<VULKAN_HPP_NAMESPACE::Image>>       parent,
-      typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter deleter        = typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter(),
-      SwapchainOwns                                                     swapchainOwned = SwapchainOwns::no ) VULKAN_HPP_NOEXCEPT
-      : SharedHeader<DestructorTypeOf<VULKAN_HPP_NAMESPACE::Image>, typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter>( std::move( parent ),
-                                                                                                                                        std::move( deleter ) )
+    ImageHeader( SharedHandle<DestructorTypeOf<Image>>       parent,
+                 typename SharedHandleTraits<Image>::deleter deleter        = typename SharedHandleTraits<Image>::deleter(),
+                 SwapchainOwns                               swapchainOwned = SwapchainOwns::no ) VULKAN_HPP_NOEXCEPT
+      : SharedHeader<DestructorTypeOf<Image>, typename SharedHandleTraits<Image>::deleter>( std::move( parent ), std::move( deleter ) )
       , swapchainOwned( swapchainOwned )
     {
     }
@@ -1067,25 +1065,25 @@ namespace VULKAN_HPP_NAMESPACE
   };
 
   template <>
-  class SharedHandle<VULKAN_HPP_NAMESPACE::Image> : public SharedHandleBase<VULKAN_HPP_NAMESPACE::Image, ImageHeader>
+  class SharedHandle<Image> : public SharedHandleBase<Image, ImageHeader>
   {
-    using BaseType    = SharedHandleBase<VULKAN_HPP_NAMESPACE::Image, ImageHeader>;
-    using DeleterType = typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::Image>::deleter;
+    using BaseType    = SharedHandleBase<Image, ImageHeader>;
+    using DeleterType = typename SharedHandleTraits<Image>::deleter;
     friend BaseType;
 
   public:
     SharedHandle() = default;
 
-    explicit SharedHandle( VULKAN_HPP_NAMESPACE::Image                                 handle,
-                           SharedHandle<DestructorTypeOf<VULKAN_HPP_NAMESPACE::Image>> parent,
-                           SwapchainOwns                                               swapchain_owned = SwapchainOwns::no,
-                           DeleterType                                                 deleter         = DeleterType() ) VULKAN_HPP_NOEXCEPT
+    explicit SharedHandle( Image                                 handle,
+                           SharedHandle<DestructorTypeOf<Image>> parent,
+                           SwapchainOwns                         swapchain_owned = SwapchainOwns::no,
+                           DeleterType                           deleter         = DeleterType() ) VULKAN_HPP_NOEXCEPT
       : BaseType( handle, std::move( parent ), std::move( deleter ), swapchain_owned )
     {
     }
 
   protected:
-    static void internalDestroy( const ImageHeader & control, VULKAN_HPP_NAMESPACE::Image handle ) VULKAN_HPP_NOEXCEPT
+    static void internalDestroy( const ImageHeader & control, Image handle ) VULKAN_HPP_NOEXCEPT
     {
       if ( control.swapchainOwned == SwapchainOwns::no )
       {
@@ -1096,41 +1094,40 @@ namespace VULKAN_HPP_NAMESPACE
 
   struct SwapchainHeader
   {
-    SwapchainHeader( SharedHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR>                           surface,
-                     SharedHandle<DestructorTypeOf<VULKAN_HPP_NAMESPACE::SwapchainKHR>>       parent,
-                     typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::SwapchainKHR>::deleter deleter =
-                       typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::SwapchainKHR>::deleter() ) VULKAN_HPP_NOEXCEPT
+    SwapchainHeader( SharedHandle<SurfaceKHR>                           surface,
+                     SharedHandle<DestructorTypeOf<SwapchainKHR>>       parent,
+                     typename SharedHandleTraits<SwapchainKHR>::deleter deleter = typename SharedHandleTraits<SwapchainKHR>::deleter() ) VULKAN_HPP_NOEXCEPT
       : surface( std::move( surface ) )
       , parent( std::move( parent ) )
       , deleter( std::move( deleter ) )
     {
     }
 
-    SharedHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR>                           surface{};
-    SharedHandle<DestructorTypeOf<VULKAN_HPP_NAMESPACE::SwapchainKHR>>       parent{};
-    typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::SwapchainKHR>::deleter deleter{};
+    SharedHandle<SurfaceKHR>                           surface{};
+    SharedHandle<DestructorTypeOf<SwapchainKHR>>       parent{};
+    typename SharedHandleTraits<SwapchainKHR>::deleter deleter{};
   };
 
   template <>
-  class SharedHandle<VULKAN_HPP_NAMESPACE::SwapchainKHR> : public SharedHandleBase<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainHeader>
+  class SharedHandle<SwapchainKHR> : public SharedHandleBase<SwapchainKHR, SwapchainHeader>
   {
-    using BaseType    = SharedHandleBase<VULKAN_HPP_NAMESPACE::SwapchainKHR, SwapchainHeader>;
-    using DeleterType = typename SharedHandleTraits<VULKAN_HPP_NAMESPACE::SwapchainKHR>::deleter;
+    using BaseType    = SharedHandleBase<SwapchainKHR, SwapchainHeader>;
+    using DeleterType = typename SharedHandleTraits<SwapchainKHR>::deleter;
     friend BaseType;
 
   public:
     SharedHandle() = default;
 
-    explicit SharedHandle( VULKAN_HPP_NAMESPACE::SwapchainKHR                                 handle,
-                           SharedHandle<DestructorTypeOf<VULKAN_HPP_NAMESPACE::SwapchainKHR>> parent,
-                           SharedHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR>                     surface,
-                           DeleterType                                                        deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
+    explicit SharedHandle( SwapchainKHR                                 handle,
+                           SharedHandle<DestructorTypeOf<SwapchainKHR>> parent,
+                           SharedHandle<SurfaceKHR>                     surface,
+                           DeleterType                                  deleter = DeleterType() ) VULKAN_HPP_NOEXCEPT
       : BaseType( handle, std::move( surface ), std::move( parent ), std::move( deleter ) )
     {
     }
 
   public:
-    const SharedHandle<VULKAN_HPP_NAMESPACE::SurfaceKHR> & getSurface() const VULKAN_HPP_NOEXCEPT
+    const SharedHandle<SurfaceKHR> & getSurface() const VULKAN_HPP_NOEXCEPT
     {
       return getHeader().surface;
     }