Update delegate library

Author: endurodave

Delegate/Delegate.h

@@ -9,7 +9,7 @@
 /// @brief Delegate series of classes are used to invoke a function synchronously. 
 /// @details Delgates support binding to free functions, class instance functions, class 
 /// static function, and std::function targets. Lambda functions can be bound to a delegate 
-/// when assigned to a `std::function`. The classes are not thread safe.
+/// when assigned to a `std::function`. The classes are not thread-safe.
 /// 
 /// Limitations:
 /// 
@@ -23,6 +23,7 @@
 #include <memory>
 #include "DelegateOpt.h"
 
+/// The delegate library namespace
 namespace DelegateLib {
 
 /// @brief Non-template base class for all delegates.

Delegate/DelegateAsync.h

@@ -12,10 +12,13 @@
 /// sending a clone of the object to the destination thread message queue. The destination 
 /// thread calls `Invoke()` to invoke the target function.
 /// 
+/// Argument data is created on the heap using `operator new` for transport thought a thread 
+/// message queue. An optional fixed-block allocator is available. See `USE_ALLOCATOR`. 
+/// 
 /// `RetType operator()(Args... args)` - called by the source thread to initiate the async
-/// function call. May throw `std::bad_alloc` if dynamic storage allocation fails and USE_ASSERTS 
-/// is not defined. Clone() may also throw `std::bad_alloc`. All other delegate class functions do 
-/// not throw exceptions.
+/// function call. May throw `std::bad_alloc` if dynamic storage allocation fails and `USE_ASSERTS` 
+/// is not defined. Clone() may also throw `std::bad_alloc` unless `USE_ASSERTS`. All other delegate 
+/// class functions do not throw exceptions.
 ///
 /// `void Invoke(std::shared_ptr<DelegateMsg> msg)` - called by the destination
 /// thread to invoke the target function. The destination thread must not call any other
@@ -49,6 +52,22 @@
 
 namespace DelegateLib {
 
+// Helper trait to check if a type is a reference to a std::shared_ptr
+template <typename T>
+struct is_shared_ptr_reference : std::false_type {};
+
+template <typename T>
+struct is_shared_ptr_reference<std::shared_ptr<T>&> : std::true_type {};
+
+template <typename T>
+struct is_shared_ptr_reference<std::shared_ptr<T>*> : std::true_type {};
+
+template <typename T>
+struct is_shared_ptr_reference<const std::shared_ptr<T>&> : std::true_type {};
+
+template <typename T>
+struct is_shared_ptr_reference<const std::shared_ptr<T>* > : std::true_type {};
+
 /// @brief Stores all function arguments suitable for non-blocking asynchronous calls.
 /// Argument data is stored in the heap.
 /// @tparam Args The argument types of the bound delegate function.
@@ -265,8 +284,8 @@ class DelegateFreeAsync<RetType(Args...)> : public DelegateFree<RetType(Args...)
             // undefined. In other words:
             // void MyFunc(std::shared_ptr<T> data)		// Ok!
             // void MyFunc(std::shared_ptr<T>& data)	// Error if DelegateAsync or DelegateSpAsync target!
-            static_assert(!(std::disjunction_v<is_shared_ptr<Args>...> &&
-                (std::disjunction_v<std::is_lvalue_reference<Args>, std::is_pointer<Args>> || ...)),
+            static_assert(!(
+                std::disjunction_v<is_shared_ptr_reference<Args>...>),
                 "std::shared_ptr reference argument not allowed");
         }
     }
@@ -565,8 +584,8 @@ class DelegateMemberAsync<TClass, RetType(Args...)> : public DelegateMember<TCla
             // undefined. In other words:
             // void MyFunc(std::shared_ptr<T> data)		// Ok!
             // void MyFunc(std::shared_ptr<T>& data)	// Error if DelegateAsync or DelegateSpAsync target!
-            static_assert(!(std::disjunction_v<is_shared_ptr<Args>...> &&
-                (std::disjunction_v<std::is_lvalue_reference<Args>, std::is_pointer<Args>> || ...)),
+            static_assert(!(
+                std::disjunction_v<is_shared_ptr_reference<Args>...>),
                 "std::shared_ptr reference argument not allowed");
         }
     }
@@ -806,8 +825,8 @@ class DelegateFunctionAsync<RetType(Args...)> : public DelegateFunction<RetType(
             // undefined. In other words:
             // void MyFunc(std::shared_ptr<T> data)		// Ok!
             // void MyFunc(std::shared_ptr<T>& data)	// Error if DelegateAsync or DelegateSpAsync target!
-            static_assert(!(std::disjunction_v<is_shared_ptr<Args>...> &&
-                (std::disjunction_v<std::is_lvalue_reference<Args>, std::is_pointer<Args>> || ...)),
+            static_assert(!(
+                std::disjunction_v<is_shared_ptr_reference<Args>...>),
                 "std::shared_ptr reference argument not allowed");
         }
     }

Delegate/DelegateAsyncWait.h

@@ -21,11 +21,12 @@
 /// the target function is not invoked. 
 /// 
 /// The `m_lock` mutex is used to protect shared state data between the source and destination 
-/// threads using the two thread safe functions below:
+/// threads using the two thread-safe functions below:
 ///
 /// `RetType operator()(Args... args)` - called by the source thread to initiate the async
-/// function call. May throw `std::bad_alloc` if dynamic storage allocation fails. Clone()
-/// also may throw `std::bad_alloc`. All other delegate class functions do not throw exceptions.
+/// function call. May throw `std::bad_alloc` if dynamic storage allocation fails and `USE_ASSERTS` 
+/// is not defined. Clone() also may throw `std::bad_alloc` unless 'USE_ASSERTS'. All other delegate 
+/// class functions do not throw exceptions.
 ///
 /// `void Invoke(std::shared_ptr<DelegateMsg> msg)` - called by the destination
 /// thread to invoke the target function. The destination thread must not call any other

Delegate/DelegateLib.h

@@ -8,8 +8,6 @@
 /// @file
 /// @brief DelegateLib.h is a single include to obtain all delegate functionality. 
 ///
-/// @mainpage C++ Delegate Library Documentation
-///
 /// A C++ delegate library capable of invoking any callable function either synchronously   
 /// or asynchronously on a user specified thread of control.
 /// 

Delegate/DelegateOpt.h

@@ -21,8 +21,9 @@
 // If USE_ASSERTS defined above, consider defining USE_ALLOCATOR to prevent 
 // std::list usage within delegate library from throwing a std::bad_alloc 
 // exception. The std_allocator calls assert if out of memory. 
+// See master CMakeLists.txt for info on enabling the fixed-block allocator.
 #ifdef USE_ALLOCATOR
-    // Use stl_allocator fixed block allocator for dynamic storage allocation
+    // Use stl_allocator fixed-block allocator for dynamic storage allocation
     #include "xlist.h"
     #include "stl_allocator.h"
 #else

Delegate/MulticastDelegateSafe.h

@@ -3,7 +3,7 @@
 
 /// @file
 /// @brief Delegate container for storing and iterating over a collection of 
-/// delegate instances. Class is thread safe.
+/// delegate instances. Class is thread-safe.
 
 #include "MulticastDelegate.h"
 #include <mutex>

Delegate/UnicastDelegate.h

@@ -13,7 +13,7 @@ namespace DelegateLib {
 template <class R>
 struct UnicastDelegate; // Not defined
 
-/// @brief A non-thread safe delegate container storing one delegate. Void and  
+/// @brief A non-thread-safe delegate container storing one delegate. Void and  
 /// non-void return values supported. 
 template<class RetType, class... Args>
 class UnicastDelegate<RetType(Args...)>