initial commit, copy everything to new repository

include/ss/extract.hpp

@@ -0,0 +1,391 @@
+#pragma once
+
+#include <cstring>
+#include <functional>
+#include <limits>
+#include <optional>
+#include <stdexcept>
+#include <string>
+
+#ifdef SS_THROW_ON_INVALID
+#define SS_THROW_OR_NULL(x) throw std::invalid_argument(x)
+#define SS_THROW_OR_FALSE(x) throw std::invalid_argument(x)
+#else
+#define SS_THROW_OR_NULL(x) return std::nullopt
+#define SS_THROW_OR_FALSE(x) return false
+#endif
+
+namespace ss {
+
+// todo
+// taken from
+// https://gist.github.com/oschonrock/67fc870ba067ebf0f369897a9d52c2dd
+
+////////////////
+// number converters
+////////////////
+template <typename T>
+std::enable_if_t<std::is_floating_point_v<T>, T> pow10(int n) {
+        T ret = 1.0;
+        T r = 10.0;
+        if (n < 0) {
+                n = -n;
+                r = 0.1;
+        }
+
+        while (n) {
+                if (n & 1) {
+                        ret *= r;
+                }
+                r *= r;
+                n >>= 1;
+        }
+        return ret;
+}
+
+template <typename T>
+std::enable_if_t<std::is_floating_point_v<T>, std::optional<T>> to_num(
+    const char* begin, const char* const end) {
+        if (begin == end) {
+                SS_THROW_OR_NULL("floating point");
+        }
+        int sign = 1;
+        T int_part = 0.0;
+        T frac_part = 0.0;
+        bool has_frac = false;
+        bool has_exp = false;
+
+        // +/- sign
+        if (*begin == '-') {
+                ++begin;
+                sign = -1;
+        }
+
+        while (begin != end) {
+                if (*begin >= '0' && *begin <= '9') {
+                        int_part = int_part * 10 + (*begin - '0');
+                } else if (*begin == '.') {
+                        has_frac = true;
+                        ++begin;
+                        break;
+                } else if (*begin == 'e') {
+                        has_exp = true;
+                        ++begin;
+                        break;
+                } else {
+                        SS_THROW_OR_NULL("floating point");
+                }
+                ++begin;
+        }
+
+        if (has_frac) {
+                T frac_exp = 0.1;
+
+                while (begin != end) {
+                        if (*begin >= '0' && *begin <= '9') {
+                                frac_part += frac_exp * (*begin - '0');
+                                frac_exp *= 0.1;
+                        } else if (*begin == 'e') {
+                                has_exp = true;
+                                ++begin;
+                                break;
+                        } else {
+                                SS_THROW_OR_NULL("floating point");
+                        }
+                        ++begin;
+                }
+        }
+
+        // parsing exponent part
+        T exp_part = 1.0;
+        if (begin != end && has_exp) {
+                int exp_sign = 1;
+                if (*begin == '-') {
+                        exp_sign = -1;
+                        ++begin;
+                } else if (*begin == '+') {
+                        ++begin;
+                }
+
+                int e = 0;
+                while (begin != end && *begin >= '0' && *begin <= '9') {
+                        e = e * 10 + *begin - '0';
+                        ++begin;
+                }
+
+                exp_part = pow10<T>(exp_sign * e);
+        }
+
+        if (begin != end) {
+                SS_THROW_OR_NULL("floating point");
+        }
+
+        return sign * (int_part + frac_part) * exp_part;
+}
+
+inline std::optional<short> from_char(char c) {
+        if (c >= '0' && c <= '9') {
+                return c - '0';
+        }
+        SS_THROW_OR_NULL("integral");
+}
+
+#if defined(__clang__) || defined(__GNUC__) || defined(__GUNG__)
+////////////////
+// mul overflow detection
+////////////////
+template <typename T>
+bool mul_overflow(T& result, T operand) {
+        return __builtin_mul_overflow(result, operand, &result);
+}
+
+template <>
+inline bool mul_overflow(int& result, int operand) {
+        return __builtin_smul_overflow(result, operand, &result);
+}
+
+template <>
+inline bool mul_overflow(long& result, long operand) {
+        return __builtin_smull_overflow(result, operand, &result);
+}
+
+template <>
+inline bool mul_overflow(long long& result, long long operand) {
+        return __builtin_smulll_overflow(result, operand, &result);
+}
+
+template <>
+inline bool mul_overflow(unsigned int& result, unsigned int operand) {
+        return __builtin_umul_overflow(result, operand, &result);
+}
+
+template <>
+inline bool mul_overflow(unsigned long& result, unsigned long operand) {
+        return __builtin_umull_overflow(result, operand, &result);
+}
+
+template <>
+inline bool mul_overflow(unsigned long long& result,
+                         unsigned long long operand) {
+        return __builtin_umulll_overflow(result, operand, &result);
+}
+
+////////////////
+// addition overflow detection
+////////////////
+
+template <typename T>
+inline bool add_overflow(T& result, T operand) {
+        return __builtin_add_overflow(result, operand, &result);
+}
+
+template <>
+inline bool add_overflow(int& result, int operand) {
+        return __builtin_sadd_overflow(result, operand, &result);
+}
+
+template <>
+inline bool add_overflow(long& result, long operand) {
+        return __builtin_saddl_overflow(result, operand, &result);
+}
+
+template <>
+inline bool add_overflow(long long& result, long long operand) {
+        return __builtin_saddll_overflow(result, operand, &result);
+}
+
+template <>
+inline bool add_overflow(unsigned int& result, unsigned int operand) {
+        return __builtin_uadd_overflow(result, operand, &result);
+}
+
+template <>
+inline bool add_overflow(unsigned long& result, unsigned long operand) {
+        return __builtin_uaddl_overflow(result, operand, &result);
+}
+
+template <>
+inline bool add_overflow(unsigned long long& result,
+                         unsigned long long operand) {
+        return __builtin_uaddll_overflow(result, operand, &result);
+}
+
+////////////////
+// substraction overflow detection
+////////////////
+template <typename T>
+inline bool sub_overflow(T& result, T operand) {
+        return __builtin_sub_overflow(result, operand, &result);
+}
+
+template <>
+inline bool sub_overflow(int& result, int operand) {
+        return __builtin_ssub_overflow(result, operand, &result);
+}
+
+template <>
+inline bool sub_overflow(long& result, long operand) {
+        return __builtin_ssubl_overflow(result, operand, &result);
+}
+
+template <>
+inline bool sub_overflow(long long& result, long long operand) {
+        return __builtin_ssubll_overflow(result, operand, &result);
+}
+
+template <>
+inline bool sub_overflow(unsigned int& result, unsigned int operand) {
+        return __builtin_usub_overflow(result, operand, &result);
+}
+
+template <>
+inline bool sub_overflow(unsigned long& result, unsigned long operand) {
+        return __builtin_usubl_overflow(result, operand, &result);
+}
+
+template <>
+inline bool sub_overflow(unsigned long long& result,
+                         unsigned long long operand) {
+        return __builtin_usubll_overflow(result, operand, &result);
+}
+
+template <typename T, typename F>
+bool shift_and_add_overflow(T& value, T digit, F add_last_digit_owerflow) {
+        if (mul_overflow<T>(value, 10) ||
+            add_last_digit_owerflow(value, digit)) {
+                return true;
+        }
+        return false;
+}
+#else
+
+#warning "use clang or gcc!!!"
+template <typename T, typename U>
+bool shift_and_add_overflow(T& value, T digit, U is_negative) {
+        digit = (is_negative) ? -digit : digit;
+        T old_value = value;
+        value = 10 * value + digit;
+
+        T expected_old_value = (value - digit) / 10;
+        if (old_value != expected_old_value) {
+                return true;
+        }
+        return false;
+}
+
+#endif
+
+template <typename T>
+std::enable_if_t<std::is_integral_v<T>, std::optional<T>> to_num(
+    const char* begin, const char* end) {
+        if (begin == end) {
+                SS_THROW_OR_NULL("integral");
+        }
+        bool is_negative = false;
+        if constexpr (std::is_signed_v<T>) {
+                is_negative = *begin == '-';
+                if (is_negative) {
+                        ++begin;
+                }
+        }
+
+#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
+        auto add_last_digit_owerflow =
+            (is_negative) ? sub_overflow<T> : add_overflow<T>;
+#else
+        auto add_last_digit_owerflow = is_negative;
+#endif
+
+        T value = 0;
+        for (auto i = begin; i != end; ++i) {
+                if (auto digit = from_char(*i);
+                    !digit ||
+                    shift_and_add_overflow<T>(value, digit.value(),
+                                              add_last_digit_owerflow)) {
+                        SS_THROW_OR_NULL("integral");
+                }
+        }
+
+        return value;
+}
+
+////////////////
+// extract
+////////////////
+
+namespace error {
+template <typename T>
+struct unsupported_type {
+        constexpr static bool value = false;
+};
+} /* namespace */
+
+template <typename T>
+std::enable_if_t<!std::is_integral_v<T> && !std::is_floating_point_v<T>, bool>
+extract(const char*, const char*, T&) {
+
+        static_assert(error::unsupported_type<T>::value,
+                      "Conversion for given type is not defined, an "
+                      "\'extract\' function needs to be defined!");
+}
+
+////////////////
+// extract specialization
+////////////////
+
+template <typename T>
+std::enable_if_t<std::is_integral_v<T> || std::is_floating_point_v<T>, bool>
+extract(const char* begin, const char* end, T& value) {
+        auto optional_value = to_num<T>(begin, end);
+#ifndef SS_THROW_ON_INVALID
+        if (!optional_value) {
+                return false;
+        }
+#endif
+        value = optional_value.value();
+        return true;
+}
+
+template <>
+inline bool extract(const char* begin, const char* end, bool& value) {
+        if (end == begin + 1) {
+                if (*begin == '1') {
+                        value = true;
+                        return true;
+                } else if (*begin == '0') {
+                        value = false;
+                        return true;
+                }
+        } else {
+                size_t size = end - begin;
+                if (size == 4 && strncmp(begin, "true", size) == 0) {
+                        value = true;
+                        return true;
+                } else if (size == 5 && strncmp(begin, "false", size) == 0) {
+                        value = false;
+                        return true;
+                }
+        }
+
+        SS_THROW_OR_FALSE("boolean");
+}
+
+template <>
+inline bool extract(const char* begin, const char* end, char& value) {
+        value = *begin;
+        if (end != begin + 1) {
+                SS_THROW_OR_FALSE("character");
+        }
+        return true;
+}
+
+template <>
+inline bool extract(const char* begin, const char* end, std::string& value) {
+        value = std::string(begin, end);
+        return true;
+}
+
+#undef SS_THROW_OR_NULL
+#undef SS_THROW_OR_FALSE
+
+} /* ss */