updated build system

support/include/utils/collection.hpp

@@ -24,6 +24,7 @@
 
 #include "utils/config.hpp"
 
+#include "utils/error.hpp"
 #include "utils/string.hpp"
 
 namespace repertory::utils::collection {
@@ -69,24 +70,75 @@ inline auto includes(const col_t &collection,
          collection.end();
 }
 
-template <typename val_t, typename string_t>
-[[nodiscard]] inline auto
-from_hex_string_t(std::basic_string_view<typename string_t::value_type> str,
-                  val_t &val) -> bool {
+template <typename val_t>
+[[nodiscard]] inline auto from_hex_string_t(std::string_view str,
+                                            val_t &val) -> bool {
   static constexpr const auto base16{16};
 
-  val.clear();
-  if (not(str.length() % 2U)) {
-    for (std::size_t i = 0U; i < str.length(); i += 2U) {
-      val.emplace_back(static_cast<typename val_t::value_type>(
-          std::strtol(string_t{str.substr(i, 2U)}.c_str(), nullptr, base16)));
+  static constexpr const std::string_view function_name{
+      static_cast<const char *>(__FUNCTION__),
+  };
+
+  try {
+    val.clear();
+
+    std::string fmt_val{str};
+    utils::string::trim(fmt_val);
+    if (fmt_val.empty()) {
+      return true;
+    }
+
+    fmt_val = utils::string::to_lower(fmt_val);
+    if (utils::string::begins_with(fmt_val, "0x")) {
+      fmt_val = fmt_val.substr(2U);
+    }
+
+    if (fmt_val.empty()) {
+      throw std::runtime_error("hex string is invalid|" + std::string{str});
+    }
+
+    if (fmt_val.length() % 2U) {
+      fmt_val = '0' + fmt_val;
+    }
+
+    auto iter = std::find_if_not(
+        fmt_val.begin(), fmt_val.end(), [](auto cur_char) -> bool {
+          auto check = static_cast<std::uint32_t>(cur_char);
+          return ((check >= 48U && check <= 57U) ||
+                  (check >= 97U && check <= 102U));
+        });
+    if (iter != fmt_val.end()) {
+      auto invalid_idx{std::distance(fmt_val.begin(), iter)};
+      throw std::range_error(
+          "invalid character in hex string|" + std::to_string(invalid_idx) +
+          '|' + std::string(1U, str.at(invalid_idx)) + '|' + std::string{str});
+    }
+
+    val.resize(fmt_val.length() / 2U);
+    for (std::size_t idx = 0U; idx < fmt_val.length(); idx += 2U) {
+      val.at(idx / 2U) = static_cast<typename val_t::value_type>(
+          std::strtoul(fmt_val.substr(idx, 2U).c_str(), nullptr, base16));
     }
 
     return true;
+  } catch (const std::exception &e) {
+    utils::error::handle_exception(function_name, e);
+  } catch (...) {
+    utils::error::handle_exception(function_name);
   }
 
+  val.clear();
   return false;
 }
+template <typename val_t>
+inline auto from_hex_string(std::string_view str, val_t &val) -> bool {
+  return from_hex_string_t<val_t>(str, val);
+}
+
+template <typename val_t>
+inline auto from_hex_string(std::wstring_view str, val_t &val) -> bool {
+  return from_hex_string_t<val_t>(utils::string::to_utf8(str), val);
+}
 
 template <typename col_t>
 inline auto remove_element(col_t &collection,
@@ -96,16 +148,6 @@ inline auto remove_element(col_t &collection,
   return collection;
 }
 
-template <typename val_t>
-inline auto from_hex_string(std::string_view str, val_t &val) -> bool {
-  return from_hex_string_t<val_t, std::string>(str, val);
-}
-
-template <typename val_t>
-inline auto from_hex_string(std::wstring_view str, val_t &val) -> bool {
-  return from_hex_string_t<val_t, std::wstring>(str, val);
-}
-
 template <typename col_t>
 inline auto to_hex_string(const col_t &collection) -> std::string {
   static_assert(sizeof(typename col_t::value_type) == 1U,