using xtd::helpers::throw_helper class

Author: gammasoft71

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

@@ -36,6 +36,8 @@ namespace xtd {
       argument_null,
       /// @brief The argument is out of range.
       argument_out_of_range,
+      /// @brief The arithmetic operation is not valid.
+      arithmetic,
       /// @brief The post-phase action of a xtd::threading::barrier fails.
       barrier_post_phase,
       /// @brief The directory is not found.
@@ -88,6 +90,12 @@ namespace xtd {
       semaphore_full,
       /// @brief The lock is not valid.
       synchronization_lock,
+      /// @brief The thread is abort.
+      thread_abort,
+      /// @brief The thread is interrupted.
+      thread_interrupted,
+      /// @brief The thread state is not valid.
+      thread_state,
       /// @brief The access is denied.
       unauthorized_access,
     };

src/xtd.core/src/xtd/console.cpp

@@ -15,6 +15,7 @@
 
 using namespace xtd;
 using namespace xtd::collections::generic;
+using namespace xtd::helpers;
 using namespace xtd::io;
 
 namespace {
@@ -147,7 +148,7 @@ int32 console::input_code_page() {
 
 void console::input_code_page(int32 code_page) {
   register_cancel_key_press(); // Must be first...
-  if (!native::console::input_code_page(code_page)) throw io::io_exception {};
+  if (!native::console::input_code_page(code_page)) throw_helper::throws(exception_case::io);
 }
 
 bool console::is_error_redirected() {
@@ -192,7 +193,7 @@ int32 console::output_code_page() {
 
 void console::output_code_page(int32 code_page) {
   register_cancel_key_press(); // Must be first...
-  if (!native::console::output_code_page(code_page)) throw io::io_exception {};
+  if (!native::console::output_code_page(code_page)) throw_helper::throws(exception_case::io);
 }
 
 string console::title() {

src/xtd.core/src/xtd/date_time.cpp

@@ -14,6 +14,7 @@
 #include <tuple>
 
 using namespace xtd;
+using namespace xtd::helpers;
 
 namespace {
   // Number of ticks per time unit
@@ -457,7 +458,7 @@ string date_time::to_string(const string& format) const {
 string date_time::to_string(const string& format, const std::locale& loc) const {
   auto fmt = format;
   if (fmt.empty()) fmt = "G";
-  if (fmt.size() > 1) throw format_exception("Invalid format"_t);
+  if (fmt.size() > 1) throw_helper::throws(exception_case::format, "Invalid format"_t);
 
   [[maybe_unused]] auto [year, month, day, hour, minute, second, day_of_year, day_of_week] = get_date_time();
   switch (fmt[0]) {

src/xtd.core/src/xtd/environment.cpp

@@ -34,6 +34,7 @@ struct __update__macos_path__ {
 } __updmacpath__;
 
 using namespace xtd;
+using namespace xtd::helpers;
 using namespace xtd::io;
 using namespace xtd::threading;
 
@@ -70,7 +71,7 @@ class environment::signal_catcher {
     std::signal(signal, signal_catcher::on_abnormal_termination_occured);
     auto e = signal_cancel_event_args {xtd::signal::abnormal_termination};
     environment::on_cancel_signal(e);
-    if (!e.cancel()) environment::quick_exit(128 + last_signal_.value_or(signal)); //throw thread_abort_exception {};
+    if (!e.cancel()) environment::quick_exit(128 + last_signal_.value_or(signal)); //throw_helper::throws(exception_case::thread_abort);
   }
 
   static void on_floating_point_exception_occured(int32 signal) {
@@ -79,7 +80,7 @@ class environment::signal_catcher {
     environment::on_cancel_signal(e);
     if (!e.cancel()) {
       last_signal_ = signal;
-      throw arithmetic_exception {};
+      throw_helper::throws(exception_case::arithmetic);
     }
   }
 
@@ -89,7 +90,7 @@ class environment::signal_catcher {
     environment::on_cancel_signal(e);
     if (!e.cancel()) {
       last_signal_ = signal;
-      xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation);
+      throw_helper::throws(exception_case::invalid_operation);
     }
   }
 
@@ -334,7 +335,7 @@ xtd::string environment::get_environment_variable(const xtd::string& variable) {
 }
 
 string environment::get_environment_variable(const string& variable, environment_variable_target target) {
-  if (!enum_object<>::is_defined<environment_variable_target>(target)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument, "Invalid environment variable target value"_t);
+  if (!enum_object<>::is_defined<environment_variable_target>(target)) throw_helper::throws(exception_case::argument, "Invalid environment variable target value"_t);
   return native::environment::get_environment_variable(variable, as<int32>(target));
 }
 
@@ -343,7 +344,7 @@ std::map<std::string, std::string>& environment::get_environment_variables() {
 }
 
 std::map<std::string, std::string>& environment::get_environment_variables(environment_variable_target target) {
-  if (!enum_object<>::is_defined<environment_variable_target>(target)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument, "Invalid environment variable target value"_t);
+  if (!enum_object<>::is_defined<environment_variable_target>(target)) throw_helper::throws(exception_case::argument, "Invalid environment variable target value"_t);
   return native::environment::get_environment_variables(as<int32>(target));
 }
 
@@ -374,9 +375,9 @@ void environment::set_environment_variable(const xtd::string& variable, const xt
 }
 
 void environment::set_environment_variable(const string& variable, const string& value, environment_variable_target target) {
-  if (string::is_empty(variable)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument, "Environment variable name is empty"_t);
+  if (string::is_empty(variable)) throw_helper::throws(exception_case::argument, "Environment variable name is empty"_t);
 
-  if (!enum_object<>::is_defined<environment_variable_target>(target)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument, "Invalid environment variable target value"_t);
+  if (!enum_object<>::is_defined<environment_variable_target>(target)) throw_helper::throws(exception_case::argument, "Invalid environment variable target value"_t);
 
   if (string::is_empty(value)) {
     native::environment::get_environment_variables(as<int32>(target)).erase(variable);

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

@@ -13,9 +13,13 @@
 #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/threading/thread_abort_exception.hpp"
+#include "../../../include/xtd/threading/thread_interrupted_exception.hpp"
+#include "../../../include/xtd/threading/thread_state_exception.hpp"
 #include "../../../include/xtd/argument_exception.hpp"
 #include "../../../include/xtd/argument_null_exception.hpp"
 #include "../../../include/xtd/argument_out_of_range_exception.hpp"
+#include "../../../include/xtd/arithmetic_exception.hpp"
 #include "../../../include/xtd/format_exception.hpp"
 #include "../../../include/xtd/index_out_of_range_exception.hpp"
 #include "../../../include/xtd/invalid_cast_exception.hpp"
@@ -50,6 +54,7 @@ void throw_helper::throws(enum exception_case exception_case, const source_locat
     case exception_case::argument: throw argument_exception {to_stack_frame(location)};
     case exception_case::argument_null: throw argument_null_exception {to_stack_frame(location)};
     case exception_case::argument_out_of_range: throw argument_out_of_range_exception {to_stack_frame(location)};
+    case exception_case::arithmetic: throw arithmetic_exception {to_stack_frame(location)};
     case exception_case::barrier_post_phase: throw barrier_post_phase_exception {to_stack_frame(location)};
     case exception_case::directory_not_found: throw directory_not_found_exception {to_stack_frame(location)};
     case exception_case::end_of_stream: throw end_of_stream_exception {to_stack_frame(location)};
@@ -76,6 +81,9 @@ void throw_helper::throws(enum exception_case exception_case, const source_locat
     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::thread_abort: throw thread_abort_exception {to_stack_frame(location)};
+    case exception_case::thread_interrupted: throw thread_interrupted_exception {to_stack_frame(location)};
+    case exception_case::thread_state: throw thread_state_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"};
   }
@@ -88,6 +96,7 @@ void throw_helper::throws(enum exception_case exception_case, const char* messag
     case exception_case::argument: throw argument_exception {message, to_stack_frame(location)};
     case exception_case::argument_null: throw argument_null_exception {message, to_stack_frame(location)};
     case exception_case::argument_out_of_range: throw argument_out_of_range_exception {message, to_stack_frame(location)};
+    case exception_case::arithmetic: throw arithmetic_exception {message, to_stack_frame(location)};
     case exception_case::barrier_post_phase: throw barrier_post_phase_exception {message, to_stack_frame(location)};
     case exception_case::directory_not_found: throw directory_not_found_exception {message, to_stack_frame(location)};
     case exception_case::end_of_stream: throw end_of_stream_exception {message, to_stack_frame(location)};
@@ -114,6 +123,9 @@ void throw_helper::throws(enum exception_case exception_case, const char* messag
     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::thread_abort: throw thread_abort_exception {message, to_stack_frame(location)};
+    case exception_case::thread_interrupted: throw thread_interrupted_exception {message, to_stack_frame(location)};
+    case exception_case::thread_state: throw thread_state_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"};
   }

src/xtd.core/src/xtd/threading/thread.cpp

@@ -24,6 +24,7 @@
 
 using namespace xtd;
 using namespace xtd::diagnostics;
+using namespace xtd::helpers;
 using namespace xtd::threading;
 
 struct thread::data {
@@ -107,7 +108,7 @@ bool thread::auto_join() const noexcept {
 }
 
 thread& thread::auto_join(bool value) {
-  if (is_aborted() || is_stopped()) throw thread_state_exception {};
+  if (is_aborted() || is_stopped()) throw_helper::throws(exception_case::thread_state);
   data_->auto_join = value;
   return *this;
 }
@@ -178,7 +179,7 @@ xtd::threading::thread_priority thread::priority() const noexcept {
 
 thread& thread::priority(xtd::threading::thread_priority value) {
   if (!enum_object<>::is_defined(value)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
-  if (is_aborted() || is_stopped()) throw thread_state_exception {};
+  if (is_aborted() || is_stopped()) throw_helper::throws(exception_case::thread_state);
 
   if (data_->priority == value) return *this;
   data_->priority = value;
@@ -195,7 +196,7 @@ xtd::threading::thread_state thread::thread_state() const noexcept {
 }
 
 void thread::abort() {
-  if (is_unstarted() || is_suspended()) throw thread_state_exception {};
+  if (is_unstarted() || is_suspended()) throw_helper::throws(exception_case::thread_state);
 
   data_->state |= xtd::threading::thread_state::abort_requested;
 
@@ -230,7 +231,7 @@ void thread::join() {
 }
 
 bool thread::join(int32 milliseconds_timeout) {
-  if (is_unstarted()) throw thread_state_exception {};
+  if (is_unstarted()) throw_helper::throws(exception_case::thread_state);
   if (milliseconds_timeout < timeout::infinite) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
 
   if (data_->interrupted == true) interrupt_internal();
@@ -282,7 +283,7 @@ bool thread::join_all(const time_span& timeout) {
 }
 
 void thread::resume() {
-  if (is_unstarted() || !is_suspended()) throw thread_state_exception {};
+  if (is_unstarted() || !is_suspended()) throw_helper::throws(exception_case::thread_state);
 
   native::thread::resume(data_->handle);
   data_->state &= ~xtd::threading::thread_state::suspended;
@@ -312,27 +313,27 @@ void thread::spin_wait(int32 iterations) {
 }
 
 void thread::start() {
-  if (!is_unstarted()) throw thread_state_exception {};
+  if (!is_unstarted()) throw_helper::throws(exception_case::thread_state);
   if (data_->thread_start.is_empty() && data_->parameterized_thread_start.is_empty()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation);
   data_->state &= ~xtd::threading::thread_state::unstarted;
   data_->joinable = true;
   data_->parameter = nullptr;
   data_->handle = native::thread::create([&](intptr arg) {
     reinterpret_cast<threading::thread*>(arg)->thread_proc();
   }, reinterpret_cast<intptr>(data_->safe_thread), data_->max_stack_size, is_suspended(), data_->thread_id);
-  if (data_->handle == invalid_handle) throw io::io_exception {};
+  if (data_->handle == invalid_handle) throw_helper::throws(exception_case::io);
 }
 
 void thread::start(std::any param) {
-  if (!is_unstarted()) throw thread_state_exception {};
+  if (!is_unstarted()) throw_helper::throws(exception_case::thread_state);
   if (data_->parameterized_thread_start.is_empty()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation);
   data_->state &= ~xtd::threading::thread_state::unstarted;
   data_->joinable = true;
   data_->parameter = param;
   data_->handle = native::thread::create([](intptr arg) {
     reinterpret_cast<thread*>(arg)->thread_proc();
   }, reinterpret_cast<intptr>(data_->safe_thread), data_->max_stack_size, is_suspended(), data_->thread_id);
-  if (data_->handle == invalid_handle) throw io::io_exception {};
+  if (data_->handle == invalid_handle) throw_helper::throws(exception_case::io);
 }
 
 thread thread::start_new(const xtd::threading::thread_start& start) {
@@ -348,7 +349,7 @@ thread thread::start_new(const xtd::threading::parameterized_thread_start& start
 }
 
 void thread::suspend() {
-  if (!is_alive()) throw thread_state_exception {};
+  if (!is_alive()) throw_helper::throws(exception_case::thread_state);
 
   data_->state |= xtd::threading::thread_state::suspend_requested;
   native::thread::suspend(data_->handle);
@@ -485,7 +486,7 @@ void thread::interrupt_internal() {
   data_->interrupted = false;
   data_->state &= ~xtd::threading::thread_state::wait_sleep_join;
   if (data_->managed_thread_id == 1) environment::raise(signal::interrupt);
-  else throw thread_interrupted_exception {};
+  else throw_helper::throws(exception_case::thread_interrupted);
 }
 
 bool thread::is_aborted() const noexcept {
@@ -546,8 +547,8 @@ void thread::thread_proc() {
   else if (!data_->parameterized_thread_start.is_empty()) data_->parameterized_thread_start(data_->parameter);
   else xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation);
 
-  if (is_aborted()) throw thread_abort_exception {};
-  if (is_aborted()) throw thread_interrupted_exception {};
+  if (is_aborted()) throw_helper::throws(exception_case::thread_abort);
+  if (is_aborted()) throw_helper::throws(exception_case::thread_interrupted);
 
   data_->state |= xtd::threading::thread_state::stopped;
   data_->end_thread_event.set();

src/xtd.core/src/xtd/timers/timer.cpp

@@ -6,6 +6,7 @@
 #include "../../../include/xtd/math.hpp"
 
 using namespace xtd;
+using namespace xtd::helpers;
 using namespace xtd::threading;
 using namespace xtd::timers;
 
@@ -68,7 +69,7 @@ bool timer::enabled() const noexcept {
 }
 
 timer& timer::enabled(bool value) {
-  if (data_->closed) throw object_closed_exception {};
+  if (data_->closed) throw_helper::throws(exception_case::object_closed);
   if (data_->enabled && !value) data_->sleep.set();
   data_->enabled = value;
   if (value) thread_pool::queue_user_work_item(data_->timer_proc, this);
@@ -80,7 +81,7 @@ double timer::interval() const noexcept {
 }
 
 timer& timer::interval(double value) {
-  if (data_->closed) throw object_closed_exception {};
+  if (data_->closed) throw_helper::throws(exception_case::object_closed);
   if (math::ceiling(value) < 0 || math::ceiling(value) > int32_object::max_value) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
   data_->interval = time_span::from_milliseconds(value);
   return *this;
@@ -101,7 +102,7 @@ timer& timer::synchronizing_object(std::nullptr_t value) {
 }
 
 void timer::close() {
-  if (data_->closed) throw object_closed_exception {};
+  if (data_->closed) throw_helper::throws(exception_case::object_closed);
   stop();
   data_->event.wait_one();
   data_->closed = true;