using xtd::helpers::throw_helper class

Author: gammasoft71

src/xtd.core/include/xtd/helpers/exception_case.hpp

@@ -64,6 +64,8 @@ namespace xtd {
       io,
       /// @brief The key is not found.
       key_not_found,
+      /// @brief The lock recursion is not valid.
+      lock_recursion,
       /// @brief The method or operation is not implemented.
       not_implemented,
       /// @brief The method or operation is not supported.
@@ -82,6 +84,10 @@ namespace xtd {
       platform_not_supported,
       /// @brief The rank is not valid.
       rank,
+      /// @brief The semaphore is full.
+      semaphore_full,
+      /// @brief The lock is not valid.
+      synchronization_lock,
       /// @brief The access is denied.
       unauthorized_access,
     };

src/xtd.core/include/xtd/helpers/throw_helper.hpp

@@ -42,13 +42,13 @@ namespace xtd {
       /// @param message The message associate to the exception.
       [[noreturn]] static void throws(xtd::helpers::exception_case exception_case, const char* message, const source_location& location = source_location::current());
       /// @brief Throws an exption with specified exception case, and message.
-      /// @param exception_case One of xtd::helpers::exception_case values.
+      /// @param exception_case The xtd::helpers::exception_case::format_not_iformatable value.
       /// @param type The type associate to the exception.
-      /// @remarks This overload is used with the xtd::helpers::exception_case::format_not_iformatable value.
+      /// @remarks This overload can only be used with the xtd::helpers::exception_case::format_not_iformatable value.
       [[noreturn]] static void throws(xtd::helpers::exception_case exception_case, const xtd::type& type, const source_location& location = source_location::current());
-      /// @brief Throws an exption with specified exception.
-      /// @tparam exception_t The exceptio type to throw.
-      /// @param arguments The arguments of the exceptio to throw.
+      /// @brief Throws an exption with specified exception type.
+      /// @tparam exception_t The exception type to throw.
+      /// @param arguments The arguments of the exception to throw.
       template<class exception_t, class ...args_t>
       [[noreturn]] static void throws(args_t... arguments) {
         throw exception_t(arguments...);

src/xtd.core/include/xtd/threading/lock_recursion_exception.hpp

@@ -10,7 +10,7 @@
 namespace xtd {
   /// @brief The xtd::threading namespace provides classes and interfaces that enable multithreaded programming. In addition to classes for synchronizing thread activities and access to data ( xtd::threading::mutex, xtd::threading::monitor, xtd::threading::interlocked, xtd::threading::auto_reset_event, and so on), this namespace includes a xtd::threading::thread_pool class that allows you to use a pool of system-supplied threads, and a xtd::threading::timer class that executes callback methods on thread pool threads.
   namespace threading {
-    /// @brief The exception that is thrown when a Thread is in an invalid ThreadState for the method call.
+    /// @brief The exception that is thrown when recursive entry into a lock is not compatible with the recursion policy for the lock.
     /// ```cpp
     /// class lock_recursion_exception : public xtd::system_exception
     /// ```

src/xtd.core/src/xtd/helpers/throw_helper.cpp

@@ -10,6 +10,9 @@
 #include "../../../include/xtd/io/path_too_long_exception.hpp"
 #include "../../../include/xtd/threading/abandoned_mutex_exception.hpp"
 #include "../../../include/xtd/threading/barrier_post_phase_exception.hpp"
+#include "../../../include/xtd/threading/lock_recursion_exception.hpp"
+#include "../../../include/xtd/threading/semaphore_full_exception.hpp"
+#include "../../../include/xtd/threading/synchronization_lock_exception.hpp"
 #include "../../../include/xtd/argument_exception.hpp"
 #include "../../../include/xtd/argument_null_exception.hpp"
 #include "../../../include/xtd/argument_out_of_range_exception.hpp"
@@ -61,6 +64,7 @@ void throw_helper::throws(enum exception_case exception_case, const source_locat
     case exception_case::invalid_operation: throw invalid_operation_exception {to_stack_frame(location)};
     case exception_case::io: throw io_exception {to_stack_frame(location)};
     case exception_case::key_not_found: throw key_not_found_exception {to_stack_frame(location)};
+    case exception_case::lock_recursion: throw lock_recursion_exception {to_stack_frame(location)};
     case exception_case::not_implemented: throw not_implemented_exception {to_stack_frame(location)};
     case exception_case::not_supported: throw not_supported_exception {to_stack_frame(location)};
     case exception_case::null_pointer: throw null_pointer_exception {to_stack_frame(location)};
@@ -70,6 +74,8 @@ void throw_helper::throws(enum exception_case exception_case, const source_locat
     case exception_case::path_too_long: throw path_too_long_exception {to_stack_frame(location)};
     case exception_case::platform_not_supported: throw platform_not_supported_exception {to_stack_frame(location)};
     case exception_case::rank: throw rank_exception {to_stack_frame(location)};
+    case exception_case::semaphore_full: throw semaphore_full_exception {to_stack_frame(location)};
+    case exception_case::synchronization_lock: throw synchronization_lock_exception {to_stack_frame(location)};
     case exception_case::unauthorized_access: throw unauthorized_access_exception {to_stack_frame(location)};
     default: throw argument_exception {"Invalid xtd::helpers::exception_case value"};
   }
@@ -96,6 +102,7 @@ void throw_helper::throws(enum exception_case exception_case, const char* messag
     case exception_case::invalid_operation: throw invalid_operation_exception {message, to_stack_frame(location)};
     case exception_case::io: throw io_exception {message, to_stack_frame(location)};
     case exception_case::key_not_found: throw key_not_found_exception {message, to_stack_frame(location)};
+    case exception_case::lock_recursion: throw lock_recursion_exception {message, to_stack_frame(location)};
     case exception_case::not_implemented: throw not_implemented_exception {message, to_stack_frame(location)};
     case exception_case::not_supported: throw not_supported_exception {message, to_stack_frame(location)};
     case exception_case::null_pointer: throw null_pointer_exception {message, to_stack_frame(location)};
@@ -105,11 +112,15 @@ void throw_helper::throws(enum exception_case exception_case, const char* messag
     case exception_case::path_too_long: throw path_too_long_exception {message, to_stack_frame(location)};
     case exception_case::platform_not_supported: throw platform_not_supported_exception {message, to_stack_frame(location)};
     case exception_case::rank: throw rank_exception {message, to_stack_frame(location)};
+    case exception_case::semaphore_full: throw semaphore_full_exception {message, to_stack_frame(location)};
+    case exception_case::synchronization_lock: throw synchronization_lock_exception {message, to_stack_frame(location)};
     case exception_case::unauthorized_access: throw unauthorized_access_exception {message, to_stack_frame(location)};
     default: throw argument_exception {"Invalid xtd::helpers::exception_case value"};
   }
 }
 
 void throw_helper::throws(enum exception_case exception_case, const xtd::type& type, const source_location& location) {
-  throws(exception_case, (exception_case == exception_case::format_not_iformatable ? string::format("The `{0}` type does not inherit from `xtd::iformat` or the specialisation for the `{0}` type in the `xtd::to_string` specialisation method does not exist.", typeof_(type).full_name()) : typeof_(type).full_name()).c_str(), location);
+  if (exception_case == exception_case::format_not_iformatable)
+    throws(exception_case, string::format("The `{0}` type does not inherit from `xtd::iformat` or the specialisation for the `{0}` type in the `xtd::to_string` specialisation method does not exist.", typeof_(type).full_name()).c_str(), location);
+  throw argument_exception {"This overload can only be used with the xtd::helpers::exception_case::format_not_iformatable value."};
 }

src/xtd.core/src/xtd/threading/monitor.cpp

@@ -17,6 +17,7 @@
 
 using namespace xtd;
 using namespace xtd::diagnostics;
+using namespace xtd::helpers;
 using namespace xtd::threading;
 
 struct monitor::item {
@@ -46,7 +47,7 @@ void monitor::exit_ptr(object_ptr obj) {
   get_static_data().monitor_items_critical_section.enter();
   if (!is_entered_ptr(obj)) {
     get_static_data().monitor_items_critical_section.leave();
-    throw synchronization_lock_exception {};
+    throw_helper::throws(exception_case::synchronization_lock);
   }
 
   item saved;
@@ -88,7 +89,7 @@ void monitor::pulse_ptr(object_ptr obj) {
   get_static_data().monitor_items_critical_section.leave();
 
   if (monitor_item == nullptr) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation);
-  if (monitor_item->thread_id.value() != thread::current_thread().thread_id()) throw synchronization_lock_exception {};
+  if (monitor_item->thread_id.value() != thread::current_thread().thread_id()) throw_helper::throws(exception_case::synchronization_lock);
 
   monitor_item->condition_variable.pulse();
 }
@@ -100,7 +101,7 @@ void monitor::pulse_all_ptr(object_ptr obj) {
   get_static_data().monitor_items_critical_section.leave();
 
   if (monitor_item == nullptr) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation);
-  if (monitor_item->thread_id.value() != thread::current_thread().thread_id()) throw synchronization_lock_exception {};
+  if (monitor_item->thread_id.value() != thread::current_thread().thread_id()) throw_helper::throws(exception_case::synchronization_lock);
 
   monitor_item->condition_variable.pulse_all();
 }
@@ -131,7 +132,7 @@ bool monitor::wait_ptr(object_ptr obj, int32 milliseconds_timeout) {
   get_static_data().monitor_items_critical_section.leave();
 
   if (monitor_item == nullptr) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation);
-  if (monitor_item->thread_id.value() != thread::current_thread().thread_id()) throw synchronization_lock_exception {};
+  if (monitor_item->thread_id.value() != thread::current_thread().thread_id()) throw_helper::throws(exception_case::synchronization_lock);
 
   return monitor_item->condition_variable.wait(monitor_item->critical_section, milliseconds_timeout);
 }

src/xtd.core/src/xtd/threading/mutex.cpp

@@ -7,6 +7,7 @@
 #include "../../../include/xtd/threading/abandoned_mutex_exception.hpp"
 
 using namespace xtd;
+using namespace xtd::helpers;
 using namespace xtd::threading;
 
 mutex::mutex() : mutex(false) {
@@ -22,7 +23,7 @@ mutex::mutex(const string& name, bool& created_new) : mutex(false, name, created
 }
 
 mutex::mutex(bool initially_owned, const string& name) : name_(name) {
-  if (name.size() > native::named_mutex::max_name_size()) throw io::path_too_long_exception {};
+  if (name.size() > native::named_mutex::max_name_size()) throw_helper::throws(exception_case::path_too_long);
   auto created_new = false;
   create(initially_owned, created_new);
 }
@@ -72,14 +73,14 @@ void mutex::lock() {
 
 mutex mutex::open_existing(const string& name) {
   if (name.empty()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
-  if (name.size() > native::named_mutex::max_name_size()) throw io::path_too_long_exception {};
+  if (name.size() > native::named_mutex::max_name_size()) throw_helper::throws(exception_case::path_too_long);
   auto result = mutex{};
-  if (!try_open_existing(name, result)) throw io::io_exception {};
+  if (!try_open_existing(name, result)) throw_helper::throws(exception_case::io);
   return result;
 }
 
 void mutex::release_mutex() {
-  if (!signal()) throw io::io_exception {};
+  if (!signal()) throw_helper::throws(exception_case::io);
 }
 
 bool mutex::try_lock() noexcept {
@@ -123,19 +124,19 @@ void mutex::unlock() {
 }
 
 bool mutex::signal() {
-  if (!mutex_) throw object_closed_exception {};
+  if (!mutex_) throw_helper::throws(exception_case::object_closed);
   auto io_error = false;
   auto result = mutex_->signal(io_error);
-  if (io_error) throw io::io_exception {};
+  if (io_error) throw_helper::throws(exception_case::io);
   return result;
 }
 
 bool mutex::wait(int32 milliseconds_timeout) {
-  if (!mutex_) throw object_closed_exception {};
+  if (!mutex_) throw_helper::throws(exception_case::object_closed);
   if (milliseconds_timeout < -1) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
   auto result = mutex_->wait(milliseconds_timeout);
-  if (result == 0xFFFFFFFF) throw io::io_exception {};
-  if (result == 0x00000080) throw abandoned_mutex_exception {};
+  if (result == 0xFFFFFFFF) throw_helper::throws(exception_case::io);
+  if (result == 0x00000080) throw_helper::throws(exception_case::abandoned_mutex);
   if (result == 0x00000102) return false;
   return true;
 }
@@ -144,10 +145,10 @@ void mutex::create(bool initially_owned, bool& created_new) {
   created_new = true;
   if (name_.empty()) {
     mutex_ = xtd::new_sptr<mutex::unnamed_mutex>();
-    if (!mutex_->create(initially_owned)) throw io::io_exception {};
+    if (!mutex_->create(initially_owned)) throw_helper::throws(exception_case::io);
   } else {
     mutex_ = xtd::new_sptr<mutex::named_mutex>();
     created_new = mutex_->create(initially_owned, name_);
-    if (!created_new && !mutex_->open(name_)) throw io::io_exception {};
+    if (!created_new && !mutex_->open(name_)) throw_helper::throws(exception_case::io);
   }
 }

src/xtd.core/src/xtd/threading/semaphore.cpp

@@ -8,6 +8,7 @@
 #include <atomic>
 
 using namespace xtd;
+using namespace xtd::helpers;
 using namespace xtd::threading;
 
 struct semaphore::data {
@@ -44,7 +45,7 @@ semaphore::semaphore(int32 initial_count, int32 maximum_count, const string& nam
 }
 
 semaphore::semaphore(int32 initial_count, int32 maximum_count, const string& name, bool& created_new) : data_(xtd::new_sptr<data>()) {
-  if (name.size() > native::named_semaphore::max_name_size()) throw io::path_too_long_exception {};
+  if (name.size() > native::named_semaphore::max_name_size()) throw_helper::throws(exception_case::path_too_long);
   if (initial_count > maximum_count) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
   if (maximum_count < 1 || initial_count < 0) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
   data_->name = name;
@@ -84,9 +85,9 @@ bool semaphore::equals(const semaphore& other) const noexcept {
 
 semaphore semaphore::open_existing(const string& name) {
   if (name.empty()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
-  if (name.size() > native::named_semaphore::max_name_size()) throw io::path_too_long_exception {};
+  if (name.size() > native::named_semaphore::max_name_size()) throw_helper::throws(exception_case::path_too_long);
   auto result = semaphore{};
-  if (!try_open_existing(name, result)) throw io::io_exception {};
+  if (!try_open_existing(name, result)) throw_helper::throws(exception_case::io);
   return result;
 }
 
@@ -96,13 +97,13 @@ int32 semaphore::release() {
 
 int32 semaphore::release(int32 release_count) {
   if (release_count < 1) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
-  if (!semaphore_) throw object_closed_exception {};
-  if (data_->count + release_count > data_->maximum_count) throw semaphore_full_exception {};
+  if (!semaphore_) throw_helper::throws(exception_case::object_closed);
+  if (data_->count + release_count > data_->maximum_count) throw_helper::throws(exception_case::semaphore_full);
   auto io_error = false;
   auto previous_count = -1;
   semaphore_->signal(io_error, release_count, previous_count);
   if (previous_count != -1) data_->count.exchange(previous_count);
-  if (io_error) throw io::io_exception {};
+  if (io_error) throw_helper::throws(exception_case::io);
   previous_count = data_->count;
   data_->count += release_count;
   return previous_count;
@@ -126,11 +127,11 @@ bool semaphore::signal() {
 }
 
 bool semaphore::wait(int32 milliseconds_timeout) {
-  if (!semaphore_) throw object_closed_exception {};
+  if (!semaphore_) throw_helper::throws(exception_case::object_closed);
   if (milliseconds_timeout < -1) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
   auto result = semaphore_->wait(milliseconds_timeout);
-  if (result == 0xFFFFFFFF) throw io::io_exception {};
-  if (result == 0x00000080) throw abandoned_mutex_exception {};
+  if (result == 0xFFFFFFFF) throw_helper::throws(exception_case::io);
+  if (result == 0x00000080) throw_helper::throws(exception_case::abandoned_mutex);
   if (result == 0x00000102) return false;
   --data_->count;
   return true;
@@ -142,10 +143,10 @@ void semaphore::create(int32 initial_count, int32 maximum_count, bool& created_n
   created_new = true;
   if (data_->name.empty()) {
     semaphore_ = xtd::new_sptr<semaphore::unnamed_semaphore>();
-    if (!semaphore_->create(initial_count, maximum_count)) throw io::io_exception {};
+    if (!semaphore_->create(initial_count, maximum_count)) throw_helper::throws(exception_case::io);
   } else {
     semaphore_ = xtd::new_sptr<semaphore::named_semaphore>();
     created_new = semaphore_->create(initial_count, maximum_count, data_->name);
-    if (!created_new && !semaphore_->open(data_->name)) throw io::io_exception {};
+    if (!created_new && !semaphore_->open(data_->name)) throw_helper::throws(exception_case::io);
   }
 }

src/xtd.core/src/xtd/threading/spin_lock.cpp

@@ -8,6 +8,7 @@
 
 using namespace xtd;
 using namespace xtd::diagnostics;
+using namespace xtd::helpers;
 using namespace xtd::threading;
 
 struct spin_lock::data {
@@ -46,7 +47,7 @@ void spin_lock::exit() {
 }
 
 void spin_lock::exit(bool use_memory_barrier) {
-  if (data_->enable_thread_owner_tracking && data_->thread_id != thread::current_thread().thread_id()) throw synchronization_lock_exception {};
+  if (data_->enable_thread_owner_tracking && data_->thread_id != thread::current_thread().thread_id()) throw_helper::throws(exception_case::synchronization_lock);
   if (use_memory_barrier) std::atomic_thread_fence(std::memory_order_acquire);
   if (data_->enable_thread_owner_tracking) data_->thread_id = thread::invalid_thread_id;
   data_->flag.clear(std::memory_order_release);
@@ -62,7 +63,7 @@ void spin_lock::try_enter(const time_span& timeout, bool& lock_taken) {
 }
 
 void spin_lock::try_enter(int32 milliseconds_timeout, bool& lock_taken) {
-  if (data_->enable_thread_owner_tracking && data_->thread_id == thread::current_thread().thread_id()) throw lock_recursion_exception {};
+  if (data_->enable_thread_owner_tracking && data_->thread_id == thread::current_thread().thread_id()) throw_helper::throws(exception_case::lock_recursion);
   lock_taken = false;
   auto sw = stopwatch::start_new();
   while (data_->flag.test_and_set(std::memory_order_acquire)) {