Replace throw() with noexcept.

Author: fdwr

Application.ixx

@@ -24,7 +24,7 @@ public:
     static int DisplayError(__in_z const char16_t* message, __in_z_opt const char16_t* formatString, int functionResult);
     static void Fail(__in_z const char16_t* message, __in_z_opt const char16_t* formatString, int functionResult);
     static void DebugLog(const char16_t* logMessage, ...);
-    static HRESULT ExceptionToHResult() throw();
+    static HRESULT ExceptionToHResult() noexcept;
 };
 
 HINSTANCE Application::g_hModule = nullptr;

Attributes.h

@@ -140,9 +140,9 @@ struct Attribute
     static bool IsTypeParsable(Attribute::Type type); // Requires parsing, not just a string of characters.
     static Type GetBaseType(Attribute::Type type);
 
-    bool IsTypeArray() const throw() { return IsTypeArray(this->type); }
-    bool AreCompatibleTypes(Attribute::Type type2) const throw() { return AreCompatibleTypes(this->type, type2); }
-    size_t GetTypeSizeof() const throw() { return GetTypeSizeof(this->type); }
+    bool IsTypeArray() const noexcept { return IsTypeArray(this->type); }
+    bool AreCompatibleTypes(Attribute::Type type2) const noexcept { return AreCompatibleTypes(this->type, type2); }
+    size_t GetTypeSizeof() const noexcept { return GetTypeSizeof(this->type); }
 
     char16_t const* GetPredefinedValueName(uint32_t valueIndex) const;
 

Common.ArrayRef.ixx

@@ -26,10 +26,10 @@ public:
     WrapperType(ResourceType resource) : resource_(resource) {}
     WrapperType(WrapperType<ResourceType> const& other) : resource_(other.resource_) {}
     inline WrapperType() { resource_ = 0; }
-    inline operator ResourceType() const throw() { return resource_; }
-    inline operator ResourceType&() throw() { return resource_; }
-    inline ResourceType* operator&() throw() { return &resource_; }
-    inline ResourceType operator->() const throw() { return resource_; }
+    inline operator ResourceType() const noexcept { return resource_; }
+    inline operator ResourceType&() noexcept { return resource_; }
+    inline ResourceType* operator&() noexcept { return &resource_; }
+    inline ResourceType operator->() const noexcept { return resource_; }
     inline WrapperType& operator=(ResourceType resource) { resource_ = resource; return *this; }
 
     ResourceType resource_;

Common.AutoResource.Windows.h

@@ -7,7 +7,7 @@ template <
 >
 struct HandleResourceTypePolicy : public DefaultResourceTypePolicy<ResourceType>
 {
-    inline static void Release(ResourceType resource) throw()
+    inline static void Release(ResourceType resource) noexcept
     {
         if (resource != 0)
         {
@@ -21,7 +21,7 @@ struct HandleResourceTypePolicy : public DefaultResourceTypePolicy<ResourceType>
 
 
 // Releasing function for WaitHandleResource to pass to use with HandleResourceTypePolicy.
-inline void WaitHandleUnregister(HANDLE handle) throw()
+inline void WaitHandleUnregister(HANDLE handle) noexcept
 {
     if (handle != nullptr)
     {
@@ -52,15 +52,15 @@ using WaitHandleResource = AutoResource<HANDLE, HandleResourceTypePolicy<HANDLE,
 
 struct ComResourceTypePolicy : public DefaultResourceTypePolicy<IUnknown*>
 {
-    inline static void Acquire(_Inout_opt_ IUnknown* resource) throw()
+    inline static void Acquire(_Inout_opt_ IUnknown* resource) noexcept
     {
         if (resource != nullptr)
         {
             resource->AddRef();
         }
     }
 
-    inline static void Release(_Inout_opt_ IUnknown* resource) throw()
+    inline static void Release(_Inout_opt_ IUnknown* resource) noexcept
     {
         if (resource != nullptr)
         {

Common.AutoResource.h

@@ -49,7 +49,7 @@
 template <typename ResourceType = void*> // type of the resource held onto
 struct DefaultResourceTypePolicy
 {
-    inline static void InitializeEmpty(_Out_ ResourceType* resource) throw()
+    inline static void InitializeEmpty(_Out_ ResourceType* resource) noexcept
     {
         // Most resources (pointers to memory, HGLOBALS, HGDIOBJ...)
         // are indicated as empty by setting to 0/NULL. If a resource
@@ -62,17 +62,17 @@ struct DefaultResourceTypePolicy
         *resource = 0;
     }
 
-    inline static bool IsNull(ResourceType resource) throw()
+    inline static bool IsNull(ResourceType resource) noexcept
     {
         return (resource == 0);
     }
 
-    inline static void Acquire(ResourceType resource) throw()
+    inline static void Acquire(ResourceType resource) noexcept
     {
         // Do nothing.
     }
 
-    inline static void Release(ResourceType resource) throw()
+    inline static void Release(ResourceType resource) noexcept
     {
         // Do nothing.
     }
@@ -121,7 +121,7 @@ class AutoResource
         ResourceTypePolicy::InitializeEmpty(Cast(&resource_));
     }
 
-    inline ~AutoResource() throw()
+    inline ~AutoResource() noexcept
     {
         // Notice we merely free the resource and do not zero the resource,
         // since we actually prefer to leave the value intact, not because
@@ -137,14 +137,14 @@ class AutoResource
 
     // Implicitly promote to the resource type for all the times the resource
     // handle/pointer is passed by value to a function.
-    inline operator ResourceType() const throw()
+    inline operator ResourceType() const noexcept
     {
         return resource_;
     }
 
     // Explicit getter for times when the compiler becomes confused
     // during overload resolution.
-    inline ResourceType Get() const throw()
+    inline ResourceType Get() const noexcept
     {
         return resource_;
     }
@@ -156,27 +156,27 @@ class AutoResource
     // since needing the address of a resource is not only for the sake of
     // out params - it's perfectly legitimate as an in param too, such as with
     // WaitForMultipleObjects().
-    inline operator ResourceType&() throw()
+    inline operator ResourceType&() noexcept
     {
         return resource_;
     }
 
     // Used when passed as an out parameter to any function,
     // or when the caller needs a pointer to a pointer.
     // If modified directly, the caller is responsible for managing the object.
-    inline ResourceType* operator&() throw()
+    inline ResourceType* operator&() noexcept
     {
         return &resource_;
     }
 
     // Explicitly named form.
-    inline ResourceType* Address() throw()
+    inline ResourceType* Address() noexcept
     {
         return &resource_;
     }
 
     // Explicitly named form.
-    inline ResourceType& Reference() throw()
+    inline ResourceType& Reference() noexcept
     {
         return resource_;
     }
@@ -185,7 +185,7 @@ class AutoResource
     //
     // ComPtr<ICat> cat;
     // cat->Meow();
-    inline ResourceType operator->() const throw()
+    inline ResourceType operator->() const noexcept
     {
         return resource_;
     }
@@ -253,7 +253,7 @@ class AutoResource
     }
 
     // Abandon the resource without freeing it.
-    inline void Abandon() throw()
+    inline void Abandon() noexcept
     {
         ResourceTypePolicy::InitializeEmpty(Cast(&resource_));
     }
@@ -262,7 +262,7 @@ class AutoResource
     // this Attach does not increment the ref count, which is symmetric
     // to Detach().
     // * No self-assignment checking is done here.
-    ResourceType Attach(ResourceType resource) throw()
+    ResourceType Attach(ResourceType resource) noexcept
     {
         DEBUG_ASSERT(resource != resource_);
         std::swap(resource_, resource);
@@ -272,7 +272,7 @@ class AutoResource
 
     // Lets go of the resource without freeing it, but returning it
     // to the caller.
-    ResourceType Detach() throw()
+    ResourceType Detach() noexcept
     {
         ResourceType resource = resource_;
         ResourceTypePolicy::InitializeEmpty(Cast(&resource_));
@@ -284,18 +284,18 @@ class AutoResource
     //
     //  p1.Attach(p2.Detach())   ->   p1.Steal(p2)
     //
-    inline void Steal(Self& other) throw()
+    inline void Steal(Self& other) noexcept
     {
         swap(other);
         other.Clear();
     }
 
-    inline bool IsNull() const throw()
+    inline bool IsNull() const noexcept
     {
         return ResourceTypePolicy::IsNull(resource_);
     }
 
-    inline bool IsSet() const throw()
+    inline bool IsSet() const noexcept
     {
         return !ResourceTypePolicy::IsNull(resource_);
     }
@@ -308,7 +308,7 @@ class AutoResource
         Clear();
     }
 
-    inline void swap(ResourceType& resource) throw()
+    inline void swap(ResourceType& resource) noexcept
     {
         std::swap(resource_, resource);
     }
@@ -353,7 +353,7 @@ namespace std
     void swap(
         AutoResource<ResourceType, ResourceTypePolicy, BaseResourceType>& lhs,
         AutoResource<ResourceType, ResourceTypePolicy, BaseResourceType>& rhs
-        ) throw()
+        ) noexcept
     {
         lhs.swap(rhs);
     }
@@ -387,7 +387,7 @@ using UnownedMemoryPointer = AutoResource<ResourceType*, UnownedMemoryPointerPol
 template <typename ResourceType>
 struct OwnedMemoryPointerPolicy : public DefaultResourceTypePolicy<ResourceType>
 {
-    inline static void Release(ResourceType resource) throw()
+    inline static void Release(ResourceType resource) noexcept
     {
         if (resource != nullptr)
         {

Common.ListSubstringPrioritizer.h

@@ -1,45 +1,45 @@
-//----------------------------------------------------------------------------
-//  Author:     Dwayne Robinson
-//  History:    2015-06-19 Created
-//----------------------------------------------------------------------------
-#pragma once
-
-
-class ListSubstringPrioritizer
-{
-    struct IndexAndWeight
-    {
-        enum WeightValue
-        {
-            WeightValueStringPrefix = 0,
-            WeightValueWordPrefix = 1,
-            WeightValueSubstring = 2,
-            WeightValueNoMatch = 3,
-        };
-
-        uint32_t index;
-        WeightValue weight;
-
-        bool operator < (IndexAndWeight const& other) const throw()
-        {
-            return weight < other.weight;
-        }
-    };
-
-public:
-    using WeightValue = IndexAndWeight::WeightValue;
-
-    ListSubstringPrioritizer(
-        array_ref<char16_t const> filterString,
-        uint32_t itemCount
-        );
-
-    WeightValue GetStringWeight(array_ref<char16_t const> name);
-    void SetItemWeight(uint32_t itemIndex, WeightValue weight);
-    array_ref<uint32_t> GetItemIndices(_Out_ array_ref<uint32_t> items, bool excludeMismatches);
-
-private:
-    std::vector<IndexAndWeight> items_;
-    std::u16string filterString_;
-    std::u16string majusculeName_;
-};
+//----------------------------------------------------------------------------
+//  Author:     Dwayne Robinson
+//  History:    2015-06-19 Created
+//----------------------------------------------------------------------------
+#pragma once
+
+
+class ListSubstringPrioritizer
+{
+    struct IndexAndWeight
+    {
+        enum WeightValue
+        {
+            WeightValueStringPrefix = 0,
+            WeightValueWordPrefix = 1,
+            WeightValueSubstring = 2,
+            WeightValueNoMatch = 3,
+        };
+
+        uint32_t index;
+        WeightValue weight;
+
+        bool operator < (IndexAndWeight const& other) const noexcept
+        {
+            return weight < other.weight;
+        }
+    };
+
+public:
+    using WeightValue = IndexAndWeight::WeightValue;
+
+    ListSubstringPrioritizer(
+        array_ref<char16_t const> filterString,
+        uint32_t itemCount
+        );
+
+    WeightValue GetStringWeight(array_ref<char16_t const> name);
+    void SetItemWeight(uint32_t itemIndex, WeightValue weight);
+    array_ref<uint32_t> GetItemIndices(_Out_ array_ref<uint32_t> items, bool excludeMismatches);
+
+private:
+    std::vector<IndexAndWeight> items_;
+    std::u16string filterString_;
+    std::u16string majusculeName_;
+};