replace __external_exceptions by xtd::helpers::throw_helper

Author: gammasoft71

src/xtd.core/CMakeLists.txt

@@ -797,7 +797,6 @@ add_sources(
   include/xtd/internal/__enum_definition_to_enum_collection.hpp
   include/xtd/internal/__enum_introspection.hpp
   include/xtd/internal/__enumerable_collection.hpp
-  include/xtd/internal/__external_exceptions.hpp
   include/xtd/internal/__floating_point_formatter.hpp
   include/xtd/internal/__format_exception.hpp
   include/xtd/internal/__format_information.hpp
@@ -1218,7 +1217,6 @@ add_sources(
   src/xtd/diagnostics/trace_source.cpp 
   src/xtd/diagnostics/trace_switch.cpp 
   src/xtd/helpers/throw_helper.cpp
-  src/xtd/internal/__external_exceptions.cpp
   src/xtd/internal/__format_exception.cpp
   src/xtd/internal/__format_stringer.cpp
   src/xtd/internal/__iformatable_formatter.cpp

src/xtd.core/include/xtd/array.hpp

@@ -4,7 +4,7 @@
 #pragma once
 #define __XTD_CORE_INTERNAL__
 #include "internal/__array_definition.hpp"
-#include "internal/__external_exceptions.hpp"
+#include "helpers/throw_helper.hpp"
 #undef __XTD_CORE_INTERNAL__
 #include "collections/generic/helpers/equator.hpp"
 #include "collections/generic/enumerator.hpp"
@@ -109,13 +109,13 @@ namespace xtd {
 #include "array_.hpp"
 #undef __XTD_ARRAY_INTERNAL__
 #define __XTD_CORE_INTERNAL__
-#include "internal/__external_exceptions.hpp"
+#include "helpers/throw_helper.hpp"
 #undef __XTD_CORE_INTERNAL__
 
 /// @cond
 template<class source_t>
 const xtd::linq::enumerable::ienumerable<xtd::array<source_t>>& xtd::linq::enumerable::chunk(const ienumerable<source_t>& source, size_t size) {
-  if (size == 0) __throw_argument_out_of_range_exception(__FILE__, __LINE__, __func__);
+  if (size == 0) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
   static thread_local auto chunks = __opaque_xtd_linq_enumerable_collection__<xtd::array<source_t>> {};
   chunks = __opaque_xtd_linq_enumerable_collection__<xtd::array<source_t>> {};
   auto chunk = std::vector<source_t> {};

src/xtd.core/include/xtd/array_.hpp

@@ -58,27 +58,27 @@ template<class type_t, class allocator_t>
 inline type_t& xtd::basic_array<type_t, allocator_t>::operator()(const xtd::array<xtd::size>& indexes) {
   auto position = xtd::size {0};
   for (auto index1 = xtd::size {0}; index1 < indexes.size(); ++index1) {
-    if (indexes[index1] >= get_length(index1)) __throw_index_out_of_range_exception(__FILE__, __LINE__, __func__);
+    if (indexes[index1] >= get_length(index1)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
     auto multiplicand = xtd::size {1};
     for (auto index2 = index1 + 1; index2 < indexes.size(); ++index2)
       multiplicand *= get_length(index2);
     position += indexes[index1] * multiplicand;
   }
-  if (position >= size()) __throw_index_out_of_range_exception(__FILE__, __LINE__, __func__);
+  if (position >= size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
   return data_->items[position];
 }
 
 template<class type_t, class allocator_t>
 inline const type_t& xtd::basic_array<type_t, allocator_t>::operator()(const xtd::array<xtd::size>& indexes) const {
   auto position = xtd::size {0};
   for (auto index1 = xtd::size {0}; index1 < indexes.size(); ++index1) {
-    if (indexes[index1] >= get_length(index1)) __throw_index_out_of_range_exception(__FILE__, __LINE__, __func__);
+    if (indexes[index1] >= get_length(index1)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
     auto multiplicand = xtd::size {1};
     for (auto index2 = index1 + 1; index2 < indexes.size(); ++index2)
       multiplicand *= get_length(index2);
     position += indexes[index1] * multiplicand;
   }
-  if (position >= size()) __throw_index_out_of_range_exception(__FILE__, __LINE__, __func__);
+  if (position >= size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
   return data_->items[position];
 }
 

src/xtd.core/include/xtd/basic_array.hpp

@@ -239,15 +239,15 @@ namespace xtd {
     /// @return Reference to the requested element.
     /// @exception xtd::index_out_of_range_exception If `index` is not within the range of the container.
     virtual reference at(size_type index) {
-      if (index >= count()) __throw_index_out_of_range_exception(__FILE__, __LINE__, __func__);
+      if (index >= count()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
       return (reference)data_->items.at(index);
     }
     /// @brief Returns a reference to the element at specified location pos, with bounds checking.
     /// @param index The position of the element to return.
     /// @return Reference to the requested element.
     /// @exception xtd::index_out_of_range_exception If `index` is not within the range of the container.
     virtual const_reference at(size_type index) const {
-      if (index >= count()) __throw_index_out_of_range_exception(__FILE__, __LINE__, __func__);
+      if (index >= count()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
       return (reference)data_->items.at(index);
     }
 
@@ -261,9 +261,9 @@ namespace xtd {
 
     void copy_to(xtd::array<type_t>& array, size_type index) const override {
       /// @todo uncomment want array remamed into array.
-      //if (array.rank() != 1) __throw_argument_exception(__FILE__, __LINE__, __func__);
-      if (rank() != 1) __throw_rank_exception(__FILE__, __LINE__, __func__);
-      if (index + length() > array.size()) __throw_argument_out_of_range_exception(__FILE__, __LINE__, __func__);
+      //if (array.rank() != 1) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
+      if (rank() != 1) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::rank);
+      if (index + length() > array.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
       for (auto increment = size_type {0}; increment < length(); ++increment)
         array[index + increment] = at(increment);
     }
@@ -293,14 +293,14 @@ namespace xtd {
         explicit basic_array_enumerator(const basic_array& items, size_type version) : items_(items), version_(version) {}
 
         const value_type& current() const override {
-          if (version_ != items_.data_->version) __throw_invalid_operation_exception("Collection was modified; enumeration operation may not execute.", __FILE__, __LINE__, __func__);
+          if (version_ != items_.data_->version) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation, "Collection was modified; enumeration operation may not execute.");
           if (index_ < items_.count()) return items_[index_];
           static thread_local auto default_value = value_type {};
           return default_value;
         }
 
         bool move_next() override {
-          if (version_ != items_.data_->version) __throw_invalid_operation_exception("Collection was modified; enumeration operation may not execute.", __FILE__, __LINE__, __func__);
+          if (version_ != items_.data_->version) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation, "Collection was modified; enumeration operation may not execute.");
           return ++index_ < items_.count();
         }
 
@@ -343,7 +343,7 @@ namespace xtd {
     /// The following code example uses xtd::array::get_lower_bound and xtd::array::get_upper_bound to initialize a one-dimensional array and a multidimensional array.
     /// @include array_get_lower_bound.cpp
     constexpr size_type get_lower_bound(size_type dimension) const {
-      if (dimension >= rank()) __throw_argument_out_of_range_exception(__FILE__, __LINE__, __func__);
+      if (dimension >= rank()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
       return data_->lower_bound[dimension];
     }
 
@@ -355,7 +355,7 @@ namespace xtd {
     /// The following code example uses xtd::array::get_lower_bound and xtd::array::get_upper_bound to initialize a one-dimensional array and a multidimensional array.
     /// @include array_get_lower_bound.cpp
     constexpr size_type get_upper_bound(size_type dimension) const {
-      if (dimension >= rank()) __throw_argument_out_of_range_exception(__FILE__, __LINE__, __func__);
+      if (dimension >= rank()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
       return data_->upper_bound[dimension];
     }
 
@@ -385,7 +385,7 @@ namespace xtd {
     /// @remarks If the current size is less than `count`, additional default-inserted elements are appended.
     void resize(size_type new_size, value_type value) {
       if (new_size == length()) return;
-      if (new_size > max_size()) __throw_argument_out_of_range_exception(__FILE__, __LINE__, __func__);
+      if (new_size > max_size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
       ++data_->version;
       data_->items.resize(new_size, value);
       data_->upper_bound[0] = new_size - 1;
@@ -441,7 +441,7 @@ namespace xtd {
     /// The following code example shows how to determine the index of the first occurrence of a specified element.
     /// @include array_index_of.cpp
     static size_type index_of(const basic_array& array, const value_type& value, size_type index, size_type count) {
-      if (index > array.length() || index + count > array.length()) __throw_argument_out_of_range_exception(__FILE__, __LINE__, __func__);
+      if (index > array.length() || index + count > array.length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
 
       if (array.size() == 0) return npos;
       for (auto increment = size_type {0}; increment < count; ++increment) {
@@ -462,7 +462,7 @@ namespace xtd {
     /// @remarks This method uses std::reverse to reverse the order of the elements, such that the element at xtd::basic_array <type_t>[i], where `i` is any index within the range, moves to xtd::basic_array <type_t>[j], where `j` equals index plus index plus count minus `i` minus 1.
     /// @remarks This method is an O(n) operation, where n is `count`.
     static void reverse(basic_array& array, size_type index, size_type count) {
-      if (index > array.size() || index + count > array.size()) __throw_argument_out_of_range_exception(__FILE__, __LINE__, __func__);
+      if (index > array.size() || index + count > array.size()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
       if (count == 0) return;
       ++array.data_->version;
       std::reverse(array.data_->items.begin() + index, array.data_->items.begin() + index + count);
@@ -538,7 +538,7 @@ namespace xtd {
     basic_array(const array<size_type, 1>& lengths);
 
     basic_array(const_pointer array, size_type length) {
-      if (array == null) __throw_argument_null_exception(__FILE__, __LINE__, __func__);
+      if (array == null) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_null);
       data_->items = base_type {array, array + length};
       data_->upper_bound[0] = data_->items.size() - 1;
     }

src/xtd.core/include/xtd/collections/generic/enumerator.hpp

@@ -4,7 +4,7 @@
 #pragma once
 #include "ienumerator.hpp"
 #define __XTD_CORE_INTERNAL__
-#include "../../internal/__external_exceptions.hpp"
+#include "../../helpers/throw_helper.hpp"
 #undef __XTD_CORE_INTERNAL__
 #include "../../ptr.hpp"
 #include "../../static.hpp"
@@ -121,14 +121,14 @@ namespace xtd {
             explicit internal_enumerator(const collection_t& items, const vertion_t* current_version) : items_(items), version_(current_version ? *current_version : vertion_t {}), current_version_(current_version) {}
 
             const value_type& current() const override {
-              if (current_version_ && version_ != *current_version_) __throw_invalid_operation_exception("Collection was modified; enumeration operation may not execute.", __FILE__, __LINE__, __func__);
+              if (current_version_ && version_ != *current_version_) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation, "Collection was modified; enumeration operation may not execute.");
               if (iterator_ != items_.cend()) return *iterator_;
               static auto default_value_type = value_type {};
               return default_value_type;
             }
 
             bool move_next() override {
-              if (current_version_ && version_ != *current_version_) __throw_invalid_operation_exception("Collection was modified; enumeration operation may not execute.", __FILE__, __LINE__, __func__);
+              if (current_version_ && version_ != *current_version_) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation, "Collection was modified; enumeration operation may not execute.");
               if (!reset_) return ++iterator_ != items_.cend();
               reset_ = false;
               iterator_ = items_.cbegin();

src/xtd.core/include/xtd/collections/object_model/read_only_collection.hpp

@@ -4,7 +4,7 @@
 #pragma once
 #include "../generic/ilist.hpp"
 #define __XTD_CORE_INTERNAL__
-#include "../../internal/__external_exceptions.hpp"
+#include "../../helpers/throw_helper.hpp"
 #undef __XTD_CORE_INTERNAL__
 #include "../../size.hpp"
 #include <limits>
@@ -51,7 +51,7 @@ namespace xtd {
           generic::enumerator<list_type_t> get_enumerator() const noexcept {
             class empty_enumerator : public generic::ienumerator<list_type_t> {
             public:
-              const list_type_t& current() const override {__throw_argument_out_of_range_exception(__FILE__, __LINE__, __func__);}
+              const list_type_t& current() const override {xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);}
               bool move_next() override {return false;}
               void reset() override {}
             private:
@@ -60,8 +60,8 @@ namespace xtd {
           }
           xtd::size index_of(const list_type_t& item) const noexcept override {return npos;}
 
-          const list_type_t& operator [](xtd::size index) const override {__throw_argument_out_of_range_exception(__FILE__, __LINE__, __func__);}
-          list_type_t& operator [](xtd::size index) override {__throw_argument_out_of_range_exception(__FILE__, __LINE__, __func__);}
+          const list_type_t& operator [](xtd::size index) const override {xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);}
+          list_type_t& operator [](xtd::size index) override {xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);}
 
         private:
           bool is_fixed_size() const noexcept override {return false;}
@@ -254,7 +254,7 @@ namespace xtd {
         /// @}
 
       private:
-        reference operator [](size_type index) override {__throw_invalid_operation_exception(__FILE__, __LINE__, __func__);}
+        reference operator [](size_type index) override {xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation);}
         bool is_fixed_size() const noexcept override {return false;}
         bool is_read_only() const noexcept override {return false;}
         bool is_synchronized() const noexcept override {return false;}