Merge pull request #22 from red0124/bugfix/multiline_on_custom_delimiter

Fix bug where the default delimiter would be used for multiline data

.gitignore

@@ -6,3 +6,5 @@ build/
 hbuild/
 subprojects/*
 !subprojects/*.wrap
+ssp.cpp
+ssp.bin

CMakeLists.txt

@@ -2,8 +2,8 @@ cmake_minimum_required(VERSION 3.14)
 
 project(
     ssp
-    VERSION 0.0.1
+    VERSION 1.4.0
-    DESCRIPTION "Static split parser"
+    DESCRIPTION "csv parser"
     HOMEPAGE_URL "https://github.com/red0124/ssp"
     LANGUAGES CXX
 )
@@ -11,22 +11,23 @@ project(
 # ---- Warning guard ----
 
 # Protect dependents from this project's warnings if the guard isn't disabled
-set(ssp_warning_guard SYSTEM)
+set(SSP_WARNING_GUARD SYSTEM)
-if(ssp_INCLUDE_WITHOUT_SYSTEM)
+if(SSP_INCLUDE_WITHOUT_SYSTEM)
-  set(ssp_warning_guard "")
+    set(SSP_WARNING_GUARD "")
 endif()
 
 # ---- Dependencies ----
 
 include(FetchContent)
-FetchContent_Declare(
+fetchcontent_declare(
-  fast_float
+    fast_float
-  GIT_REPOSITORY https://github.com/red0124/fast_float.git
+    GIT_REPOSITORY https://github.com/red0124/fast_float.git
-  GIT_TAG origin/meson
+    GIT_TAG origin/meson
-  GIT_SHALLOW TRUE)
+    GIT_SHALLOW TRUE
+)
 
-FetchContent_MakeAvailable(fast_float)
+fetchcontent_makeavailable(fast_float)
-set(fast_float_source_dir "${FETCHCONTENT_BASE_DIR}/fast_float-src")
+set(FAST_FLOAT_SOURCE_DIR "${FETCHCONTENT_BASE_DIR}/fast_float-src")
 
 # ---- Declare library ----
 
@@ -35,10 +36,10 @@ add_library(ssp::ssp ALIAS ssp)
 
 target_include_directories(
     ssp
-    ${ssp_warning_guard}
+    ${SSP_WARNING_GUARD}
     INTERFACE
-    "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>"
+        "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>"
-    "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/fast_float>"
+        "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/fast_float>"
 )
 
 target_compile_features(ssp INTERFACE cxx_std_17)
@@ -46,8 +47,8 @@ target_compile_features(ssp INTERFACE cxx_std_17)
 target_link_libraries(
     ssp
     INTERFACE
-    "$<$<AND:$<CXX_COMPILER_ID:AppleClang,Clang>,$<VERSION_LESS:$<CXX_COMPILER_VERSION>,9.0>>:c++fs>"
+        "$<$<AND:$<CXX_COMPILER_ID:AppleClang,Clang>,$<VERSION_LESS:$<CXX_COMPILER_VERSION>,9.0>>:c++fs>"
-    "$<$<AND:$<CXX_COMPILER_ID:GNU>,$<VERSION_LESS:$<CXX_COMPILER_VERSION>,9.1>>:stdc++fs>"
+        "$<$<AND:$<CXX_COMPILER_ID:GNU>,$<VERSION_LESS:$<CXX_COMPILER_VERSION>,9.1>>:stdc++fs>"
 )
 
 # ---- Install ----
@@ -55,19 +56,21 @@ target_link_libraries(
 include(CMakePackageConfigHelpers)
 include(GNUInstallDirs)
 
-set(ssp_directory "ssp-${PROJECT_VERSION}")
+set(SSP_DIRECTORY "ssp-${PROJECT_VERSION}")
-set(ssp_include_directory "${CMAKE_INSTALL_INCLUDEDIR}")
+set(SSP_INCLUDE_DIRECTORY "${CMAKE_INSTALL_INCLUDEDIR}")
 
 install(
-    DIRECTORY "${PROJECT_SOURCE_DIR}/include/" "${fast_float_source_dir}/include/"
+    DIRECTORY
-    DESTINATION "${ssp_include_directory}"
+        "${PROJECT_SOURCE_DIR}/include/"
+        "${FAST_FLOAT_SOURCE_DIR}/include/"
+    DESTINATION "${SSP_INCLUDE_DIRECTORY}"
     COMPONENT ssp_Development
 )
 
 install(
     TARGETS ssp
     EXPORT sspTargets
-    INCLUDES DESTINATION "${ssp_include_directory}"
+    INCLUDES DESTINATION "${SSP_INCLUDE_DIRECTORY}"
 )
 
 write_basic_package_version_file(
@@ -76,11 +79,11 @@ write_basic_package_version_file(
     ARCH_INDEPENDENT
 )
 
-set(ssp_install_cmakedir "${CMAKE_INSTALL_LIBDIR}/cmake/${ssp_directory}")
+set(SSP_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/${SSP_DIRECTORY}")
 
 install(
     FILES "${PROJECT_BINARY_DIR}/ssp-config-version.cmake"
-    DESTINATION "${ssp_install_cmakedir}"
+    DESTINATION "${SSP_INSTALL_CMAKEDIR}"
     COMPONENT ssp_Development
 )
 
@@ -88,10 +91,10 @@ install(
     EXPORT sspTargets
     FILE ssp-config.cmake
     NAMESPACE ssp::
-    DESTINATION "${ssp_install_cmakedir}"
+    DESTINATION "${SSP_INSTALL_CMAKEDIR}"
     COMPONENT ssp_Development
 )
 
 if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
-  include(CPack)
+    include(CPack)
 endif()

README.md

@@ -53,22 +53,26 @@ Brian S. Wolfe 40 1.9
 Bill (Heath) Gates 65 3.3
 ```
 # Features
- * [Works on any type](#Custom-conversions)
+ * [Works on any type](#custom-conversions)
  * Easy to use
  * No exceptions
- * [Works with headers](#Headers)
+ * [Works with headers](#headers)
- * [Works with quotes, escapes and spacings](#Setup)
+ * [Works with quotes, escapes and spacings](#setup)
- * [Works with values containing new lines](#Multiline)
+ * [Works with values containing new lines](#multiline)
- * [Columns and rows can be ignored](#Special-types)
+ * [Columns and rows can be ignored](#special-types)
  * Works with any type of delimiter
  * Can return whole objects composed of converted values
- * [Descriptive error handling can be enabled](#Error-handling)
+ * [Descriptive error handling can be enabled](#error-handling)
- * [Restrictions can be added for each column](#Restrictions)
+ * [Restrictions can be added for each column](#restrictions)
- * [Works with `std::optional` and `std::variant`](#Special-types)
+ * [Works with `std::optional` and `std::variant`](#special-types)
  * Works with **`CRLF`** and **`LF`**
- * [Conversions can be chained if invalid](#Substitute-conversions)
+ * [Conversions can be chained if invalid](#substitute-conversions)
  * Fast
 
+# Single header
+
+The library can be used with a single header file **`ssp.hpp`**, but it sufferes a slight performance loss when converting floating point values since the **`fast_float`** library is not present within the file.
+
 # Installation
 
 ```shell
@@ -113,7 +117,7 @@ The header can be ignored using the **`ss::ignore_header`** [setup](#Setup) opti
 ```cpp
 ss::parser<ss::ignore_header> p{file_name};
 ```
-The fields with which the parser works with can be modified at any given time. The paser can also check if a field is present within the header by using the **`has_field`** method.
+The fields with which the parser works with can be modified at any given time. The praser can also check if a field is present within the header by using the **`field_exists`** method.
 ```cpp
     // ...
     ss::parser p{"students.csv", ","};
@@ -374,7 +378,7 @@ if(std::holds_alternative<float>(grade)) {
 ```
 ## Restrictions
 
-Custom **`restrictions`** can be used to narrow down the conversions of unwanted values. **`ss::ir`** (in range) and **`ss::ne`** (none empty) are one of those:
+Custom **`restrictions`** can be used to narrow down the conversions of unwanted values. **`ss::ir`** (in range) and **`ss::ne`** (none empty) are some of those:
 ```cpp
 // ss::ne makes sure that the name is not empty
 // ss::ir makes sure that the grade will be in range [0, 10]
@@ -468,7 +472,6 @@ The delimiter is " ", and the number of columns varies depending on which shape
 ```cpp
 ss::parser p{"shapes.txt", " "};
 if (!p.valid()) {
-    std::cout << p.error_msg() << std::endl;
     exit(EXIT_FAILURE);
 }
 
@@ -510,7 +513,7 @@ while (!p.eof()) {
 ```
 It is quite hard to make an error this way since most things will be checked at compile time.
 
-The **`try_next`** method works in a similar way as **`get_next`** but returns a **`composit`** which holds a **`tuple`** with an **`optional`** to the **`tuple`** returned by **`get_next`**. This **`composite`** has an **`or_else`** method (looks a bit like **`tl::expected`**) which is able to try additional conversions if the previous failed. **`or_else`** also returns a **`composite`**, but in its tuple is the **`optional`** to the **`tuple`** of the previous conversions and an **`optional`** to the **`tuple`** of the new conversion. (sounds more complicated than it is.
+The **`try_next`** method works in a similar way as **`get_next`** but returns a **`composite`** which holds a **`tuple`** with an **`optional`** to the **`tuple`** returned by **`get_next`**. This **`composite`** has an **`or_else`** method (looks a bit like **`tl::expected`**) which is able to try additional conversions if the previous failed. **`or_else`** also returns a **`composite`**, but in its tuple is the **`optional`** to the **`tuple`** of the previous conversions and an **`optional`** to the **`tuple`** of the new conversion. (sounds more complicated than it is.
 
 To fetch the **`tuple`** from the **`composite`** the **`values`** method is used. The value of the above used conversion would look something like this:
 ```cpp
@@ -628,6 +631,5 @@ revision = origin/master
 ```
 Then simply fetch the dependency and it is ready to be used:
 ```meson
-ssp_sub = subproject('ssp')
+ssp_dep = dependency('ssp')
-ssp_dep = ssp_sub.get_variable('ssp_dep')
 ```

include/ss/converter.hpp

@@ -102,7 +102,7 @@ class converter {
     constexpr static auto string_error = setup<Matchers...>::string_error;
     constexpr static auto default_delimiter = ",";
 
-    using error_type = ss::ternary_t<string_error, std::string, bool>;
+    using error_type = std::conditional_t<string_error, std::string, bool>;
 
 public:
     // parses line with given delimiter, returns a 'T' object created with
@@ -194,7 +194,7 @@ private:
     ////////////////
 
     const split_data& resplit(line_ptr_type new_line, ssize_t new_size,
-                              const std::string& delim = default_delimiter) {
+                              const std::string& delim) {
         return splitter_.resplit(new_line, new_size, delim);
     }
 

include/ss/extract.hpp

@@ -2,21 +2,27 @@
 
 #include "type_traits.hpp"
 #include <cstring>
-#include <fast_float/fast_float.h>
 #include <functional>
 #include <limits>
 #include <optional>
-#include <stdexcept>
 #include <string>
 #include <string_view>
 #include <variant>
 
+#ifndef SSP_DISABLE_FAST_FLOAT
+#include <fast_float/fast_float.h>
+#else
+#include <charconv>
+#endif
+
 namespace ss {
 
 ////////////////
 // number converters
 ////////////////
 
+#ifndef SSP_DISABLE_FAST_FLOAT
+
 template <typename T>
 std::enable_if_t<std::is_floating_point_v<T>, std::optional<T>> to_num(
     const char* const begin, const char* const end) {
@@ -29,6 +35,22 @@ std::enable_if_t<std::is_floating_point_v<T>, std::optional<T>> to_num(
     return ret;
 }
 
+#else
+
+template <typename T>
+std::enable_if_t<std::is_floating_point_v<T>, std::optional<T>> to_num(
+    const char* const begin, const char* const end) {
+    T ret;
+    auto [ptr, ec] = std::from_chars(begin, end, ret);
+
+    if (ec != std::errc() || ptr != end) {
+        return std::nullopt;
+    }
+    return ret;
+}
+
+#endif
+
 inline std::optional<short> from_char(char c) {
     if (c >= '0' && c <= '9') {
         return c - '0';

include/ss/parser.hpp

@@ -17,7 +17,7 @@ class parser {
     constexpr static auto string_error = setup<Matchers...>::string_error;
 
     using multiline = typename setup<Matchers...>::multiline;
-    using error_type = ss::ternary_t<string_error, std::string, bool>;
+    using error_type = std::conditional_t<string_error, std::string, bool>;
 
     constexpr static bool escaped_multiline_enabled =
         multiline::enabled && setup<Matchers...>::escape::enabled;
@@ -151,8 +151,8 @@ public:
     template <bool get_object, typename T, typename... Ts>
     struct iterable {
         struct iterator {
-            using value =
+            using value = std::conditional_t<get_object, T,
-                ss::ternary_t<get_object, T, no_void_validator_tup_t<T, Ts...>>;
+                                             no_void_validator_tup_t<T, Ts...>>;
 
             iterator() : parser_{nullptr} {
             }
@@ -623,7 +623,8 @@ private:
                         }
                     }
 
-                    next_line_converter_.resplit(next_line_buffer_, size);
+                    next_line_converter_.resplit(next_line_buffer_, size,
+                                                 delim_);
                 }
             }
 

include/ss/setup.hpp

@@ -111,8 +111,8 @@ struct get_matcher<Matcher, T, Ts...> {
     static_assert(count_v<is_matcher, T, Ts...> <= 1,
                   "the same matcher is cannot"
                   "be defined multiple times");
-    using type = ternary_t<is_matcher<T>::value, T,
+    using type = std::conditional_t<is_matcher<T>::value, T,
-                           typename get_matcher<Matcher, Ts...>::type>;
+                               typename get_matcher<Matcher, Ts...>::type>;
 };
 
 template <template <char...> class Matcher>
@@ -149,8 +149,8 @@ struct get_multiline;
 
 template <typename T, typename... Ts>
 struct get_multiline<T, Ts...> {
-    using type = ternary_t<is_instance_of_multiline<T>::value, T,
+    using type = std::conditional_t<is_instance_of_multiline<T>::value, T,
-                           typename get_multiline<Ts...>::type>;
+                               typename get_multiline<Ts...>::type>;
 };
 
 template <>
@@ -227,8 +227,10 @@ public:
     using quote = get_matcher_t<quote, Ts...>;
     using escape = get_matcher_t<escape, Ts...>;
 
-    using trim_left = ternary_t<trim_all::enabled, trim_all, trim_left_only>;
+    using trim_left =
-    using trim_right = ternary_t<trim_all::enabled, trim_all, trim_right_only>;
+        std::conditional_t<trim_all::enabled, trim_all, trim_left_only>;
+    using trim_right =
+        std::conditional_t<trim_all::enabled, trim_all, trim_right_only>;
 
     using multiline = get_multiline_t<Ts...>;
     constexpr static bool string_error = (count_string_error == 1);

include/ss/splitter.hpp

@@ -23,10 +23,10 @@ private:
     constexpr static auto string_error = setup<Ts...>::string_error;
     constexpr static auto is_const_line = !quote::enabled && !escape::enabled;
 
-    using error_type = ss::ternary_t<string_error, std::string, bool>;
+    using error_type = std::conditional_t<string_error, std::string, bool>;
 
 public:
-    using line_ptr_type = ternary_t<is_const_line, const char*, char*>;
+    using line_ptr_type = std::conditional_t<is_const_line, const char*, char*>;
 
     bool valid() const {
         if constexpr (string_error) {

include/ss/type_traits.hpp

@@ -357,26 +357,6 @@ struct is_instance_of<Template, Template<Ts...>> {
 template <template <typename...> class Template, typename... Ts>
 constexpr bool is_instance_of_v = is_instance_of<Template, Ts...>::value;
 
-////////////////
-// ternary
-////////////////
-
-template <bool B, typename T, typename U>
-struct ternary;
-
-template <typename T, typename U>
-struct ternary<true, T, U> {
-    using type = T;
-};
-
-template <typename T, typename U>
-struct ternary<false, T, U> {
-    using type = U;
-};
-
-template <bool B, typename T, typename U>
-using ternary_t = typename ternary<B, T, U>::type;
-
 ////////////////
 // tuple to struct
 ////////////////

meson.build

@@ -1,17 +1,24 @@
-project('ssp', 'cpp', 
+project(
+  'ssp', 
+  ['cpp'], 
   default_options : 
-  ['warning_level=3', 
+    ['warning_level=3', 
-    'cpp_std=c++17', 
+      'cpp_std=c++17', 
-    'buildtype=debugoptimized'])
+      'buildtype=debugoptimized',
+      'wrap_mode=forcefallback'],
+  version: '1.4.0',
+  meson_version:'>=0.54.0')
 
-fast_float_sub = subproject('fast_float')
+fast_float_dep = dependency('fast_float')
-fast_float_dep = fast_float_sub.get_variable('fast_float_dep')
 
 ssp_dep = declare_dependency(
   include_directories: include_directories('include'),
   dependencies: fast_float_dep
   )
 
+meson.override_dependency('ssp', ssp_dep)
+
 if not meson.is_subproject()
   subdir('test')
 endif
+

script/ci_install_deps.sh

@@ -5,7 +5,7 @@ BUILD_TYPE=Debug
 
 set -eux
 
-git clone https://github.com/onqtam/doctest -b 2.4.4 --depth 1
+git clone https://github.com/red0124/doctest -b master --depth 1
 
 cmake -S doctest -B doctest/build \
     -D CMAKE_BUILD_TYPE=${BUILD_TYPE} \

script/single_header_generator.py

@@ -0,0 +1,34 @@
+#!/bin/python3
+
+headers_dir = 'include/ss/'
+headers = ['type_traits.hpp',
+           'function_traits.hpp',
+           'restrictions.hpp',
+           'common.hpp',
+           'setup.hpp',
+           'splitter.hpp',
+           'extract.hpp',
+           'converter.hpp',
+           'parser.hpp']
+
+combined_file = []
+includes = []
+
+for header in headers:
+    with open(headers_dir + header) as f:
+        for line in f.read().splitlines():
+            if '#include "' in line or '#include <fast_float' in line:
+                continue
+
+            if '#include <' in line:
+                includes.append(line)
+                continue
+
+            if '#pragma once' not in line:
+                combined_file.append(line)
+
+includes = sorted(set(includes))
+
+print('\n'.join(includes))
+print('#define SSP_DISABLE_FAST_FLOAT')
+print('\n'.join(combined_file))

subprojects/doctest.wrap

@@ -1,3 +1,3 @@
 [wrap-git]
-url = https://github.com/onqtam/doctest
+url = https://github.com/red0124/doctest
-revision = 2.4.4
+revision = master

test/CMakeLists.txt

@@ -4,34 +4,38 @@ project(ssp_tests CXX)
 
 # ---- Dependencies ----
 
-set(
-    ssp_INCLUDE_WITHOUT_SYSTEM
-    YES
-    CACHE
-    INTERNAL
-    "Turn the warning guard off to have errors appear in test builds"
-)
-
 include(FetchContent)
-FetchContent_Declare(ssp SOURCE_DIR "${PROJECT_SOURCE_DIR}/..")
+fetchcontent_declare(ssp SOURCE_DIR "${PROJECT_SOURCE_DIR}/..")
-FetchContent_MakeAvailable(ssp)
+fetchcontent_makeavailable(ssp)
 
 if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
-  target_compile_options(ssp INTERFACE -Wall -Wextra)
+    target_compile_options(ssp INTERFACE -Wall -Wextra)
 endif()
 
-find_package(doctest 2.4.4 CONFIG REQUIRED)
+include(FetchContent)
-# for doctest_discover_tests
+fetchcontent_declare(
-include(doctest)
+    DOCTEST
+    GIT_REPOSITORY https://github.com/red0124/doctest
+    GIT_TAG origin/master
+    GIT_SHALLOW TRUE
+)
+
+fetchcontent_makeavailable(DOCTEST)
+set(DOCTEST "${FETCHCONTENT_BASE_DIR}/doctest-src")
 
 # ---- Test ----
 
 enable_testing()
 
 foreach(name IN ITEMS test_splitter test_parser test_converter test_extractions)
-  add_executable("${name}" "${name}.cpp")
+    add_executable("${name}" "${name}.cpp")
-  target_link_libraries("${name}" PRIVATE ssp::ssp fast_float doctest::doctest)
+    target_link_libraries(
-  target_compile_definitions("${name}" PRIVATE
+        "${name}"
-    DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN CMAKE_GITHUB_CI)
+        PRIVATE ssp::ssp fast_float doctest::doctest
-  doctest_discover_tests("${name}")
+    )
+    target_compile_definitions(
+        "${name}"
+        PRIVATE DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN CMAKE_GITHUB_CI
+    )
+    add_test(NAME "${name}" COMMAND "${name}")
 endforeach()

test/meson.build

@@ -4,10 +4,10 @@ test_sources = files([
       'test_converter.cpp',
       'test_parser.cpp',
       'test_extractions.cpp',
+      'test_extractions_without_fast_float.cpp',
       ])
 
-doctest_proj = subproject('doctest')
+doctest_dep = dependency('doctest')
-doctest_dep = doctest_proj.get_variable('doctest_dep')
 
 test_exe = executable(
   'test_ssp',

test/test_extractions.cpp

@@ -2,23 +2,6 @@
 #include <algorithm>
 #include <ss/extract.hpp>
 
-#define CHECK_FLOATING_CONVERSION(input, type)                                 \
-    {                                                                          \
-        auto eps = std::numeric_limits<type>::min();                           \
-        std::string s = #input;                                                \
-        auto t = ss::to_num<type>(s.c_str(), s.c_str() + s.size());            \
-        REQUIRE(t.has_value());                                                \
-        CHECK_LT(std::abs(t.value() - type(input)), eps);                      \
-    }                                                                          \
-    {                                                                          \
-        /* check negative too */                                               \
-        auto eps = std::numeric_limits<type>::min();                           \
-        auto s = std::string("-") + #input;                                    \
-        auto t = ss::to_num<type>(s.c_str(), s.c_str() + s.size());            \
-        REQUIRE(t.has_value());                                                \
-        CHECK_LT(std::abs(t.value() - type(-input)), eps);                     \
-    }
-
 TEST_CASE("testing extract functions for floating point values") {
     CHECK_FLOATING_CONVERSION(123.456, float);
     CHECK_FLOATING_CONVERSION(123.456, double);
@@ -70,13 +53,6 @@ TEST_CASE("extract test functions for decimal values") {
     CHECK_DECIMAL_CONVERSION(1234567891011, ull);
 }
 
-#define CHECK_INVALID_CONVERSION(input, type)                                  \
-    {                                                                          \
-        std::string s = input;                                                 \
-        auto t = ss::to_num<type>(s.c_str(), s.c_str() + s.size());            \
-        CHECK_FALSE(t.has_value());                                            \
-    }
-
 TEST_CASE("extract test functions for numbers with invalid inputs") {
     // negative unsigned value
     CHECK_INVALID_CONVERSION("-1234", ul);
@@ -200,15 +176,6 @@ TEST_CASE("extract test functions for std::optional") {
     }
 }
 
-#define REQUIRE_VARIANT(var, el, type)                                         \
-    {                                                                          \
-        auto ptr = std::get_if<type>(&var);                                    \
-        REQUIRE(ptr);                                                          \
-        REQUIRE_EQ(el, *ptr);                                                  \
-    }
-
-#define CHECK_NOT_VARIANT(var, type) CHECK(!std::holds_alternative<type>(var));
-
 TEST_CASE("extract test functions for std::variant") {
     {
         std::string s = "22";

test/test_extractions_without_fast_float.cpp

@@ -0,0 +1,132 @@
+#include "test_helpers.hpp"
+#include <algorithm>
+
+#define SSP_DISABLE_FAST_FLOAT
+#include <ss/extract.hpp>
+
+TEST_CASE(
+    "testing extract functions for floating point values without fast float") {
+    CHECK_FLOATING_CONVERSION(123.456, float);
+    CHECK_FLOATING_CONVERSION(123.456, double);
+
+    CHECK_FLOATING_CONVERSION(69, float);
+    CHECK_FLOATING_CONVERSION(69, double);
+
+    CHECK_FLOATING_CONVERSION(420., float);
+    CHECK_FLOATING_CONVERSION(420., double);
+
+    CHECK_FLOATING_CONVERSION(0.123, float);
+    CHECK_FLOATING_CONVERSION(0.123, double);
+
+    CHECK_FLOATING_CONVERSION(123e4, float);
+    CHECK_FLOATING_CONVERSION(123e4, double);
+}
+
+TEST_CASE("extract test functions for numbers with invalid inputs without fast "
+          "float") {
+    // floating pint for int
+    CHECK_INVALID_CONVERSION("123.4", int);
+
+    // random input for float
+    CHECK_INVALID_CONVERSION("xxx1", float);
+}
+
+TEST_CASE("extract test functions for std::variant without fast float") {
+    {
+        std::string s = "22";
+        {
+            std::variant<int, double, std::string> var;
+            REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
+            CHECK_NOT_VARIANT(var, double);
+            CHECK_NOT_VARIANT(var, std::string);
+            REQUIRE_VARIANT(var, 22, int);
+        }
+        {
+            std::variant<double, int, std::string> var;
+            REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
+            CHECK_NOT_VARIANT(var, int);
+            CHECK_NOT_VARIANT(var, std::string);
+            REQUIRE_VARIANT(var, 22, double);
+        }
+        {
+            std::variant<std::string, double, int> var;
+            REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
+            CHECK_NOT_VARIANT(var, int);
+            CHECK_NOT_VARIANT(var, double);
+            REQUIRE_VARIANT(var, "22", std::string);
+        }
+        {
+            std::variant<int> var;
+            REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
+            REQUIRE_VARIANT(var, 22, int);
+        }
+    }
+    {
+        std::string s = "22.2";
+        {
+            std::variant<int, double, std::string> var;
+            REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
+            CHECK_NOT_VARIANT(var, int);
+            CHECK_NOT_VARIANT(var, std::string);
+            REQUIRE_VARIANT(var, 22.2, double);
+        }
+        {
+            std::variant<double, int, std::string> var;
+            REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
+            CHECK_NOT_VARIANT(var, int);
+            CHECK_NOT_VARIANT(var, std::string);
+            REQUIRE_VARIANT(var, 22.2, double);
+        }
+        {
+            std::variant<std::string, double, int> var;
+            REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
+            CHECK_NOT_VARIANT(var, int);
+            CHECK_NOT_VARIANT(var, double);
+            REQUIRE_VARIANT(var, "22.2", std::string);
+        }
+    }
+    {
+        std::string s = "2.2.2";
+        {
+            std::variant<int, double, std::string> var;
+            REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
+            CHECK_NOT_VARIANT(var, int);
+            CHECK_NOT_VARIANT(var, double);
+            REQUIRE_VARIANT(var, "2.2.2", std::string);
+        }
+        {
+            std::variant<double, std::string, int> var;
+            REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
+            CHECK_NOT_VARIANT(var, int);
+            CHECK_NOT_VARIANT(var, double);
+            REQUIRE_VARIANT(var, "2.2.2", std::string);
+        }
+        {
+            std::variant<std::string, double, int> var;
+            REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
+            CHECK_NOT_VARIANT(var, int);
+            CHECK_NOT_VARIANT(var, double);
+            REQUIRE_VARIANT(var, "2.2.2", std::string);
+        }
+        {
+            std::variant<int, double> var;
+            REQUIRE_FALSE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
+
+            REQUIRE_VARIANT(var, int{}, int);
+            CHECK_NOT_VARIANT(var, double);
+        }
+        {
+            std::variant<double, int> var;
+            REQUIRE_FALSE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
+
+            REQUIRE_VARIANT(var, double{}, double);
+            CHECK_NOT_VARIANT(var, int);
+        }
+        {
+            std::variant<int> var;
+            REQUIRE_FALSE(ss::extract(s.c_str(), s.c_str() + s.size(), var));
+
+            REQUIRE_VARIANT(var, int{}, int);
+        }
+    }
+}

test/test_helpers.hpp

@@ -46,3 +46,36 @@ struct buffer {
 };
 
 [[maybe_unused]] inline buffer buff;
+
+#define CHECK_FLOATING_CONVERSION(input, type)                                 \
+    {                                                                          \
+        auto eps = std::numeric_limits<type>::min();                           \
+        std::string s = #input;                                                \
+        auto t = ss::to_num<type>(s.c_str(), s.c_str() + s.size());            \
+        REQUIRE(t.has_value());                                                \
+        CHECK_LT(std::abs(t.value() - type(input)), eps);                      \
+    }                                                                          \
+    {                                                                          \
+        /* check negative too */                                               \
+        auto eps = std::numeric_limits<type>::min();                           \
+        auto s = std::string("-") + #input;                                    \
+        auto t = ss::to_num<type>(s.c_str(), s.c_str() + s.size());            \
+        REQUIRE(t.has_value());                                                \
+        CHECK_LT(std::abs(t.value() - type(-input)), eps);                     \
+    }
+
+#define CHECK_INVALID_CONVERSION(input, type)                                  \
+    {                                                                          \
+        std::string s = input;                                                 \
+        auto t = ss::to_num<type>(s.c_str(), s.c_str() + s.size());            \
+        CHECK_FALSE(t.has_value());                                            \
+    }
+
+#define REQUIRE_VARIANT(var, el, type)                                         \
+    {                                                                          \
+        auto ptr = std::get_if<type>(&var);                                    \
+        REQUIRE(ptr);                                                          \
+        REQUIRE_EQ(el, *ptr);                                                  \
+    }
+
+#define CHECK_NOT_VARIANT(var, type) CHECK(!std::holds_alternative<type>(var));

test/test_parser.cpp

@@ -610,8 +610,6 @@ struct xyz {
 };
 
 TEST_CASE("parser test the moving of parsed values") {
-    size_t move_called_one_col;
-
     {
         unique_file_name f;
         {
@@ -621,8 +619,7 @@ TEST_CASE("parser test the moving of parsed values") {
 
         ss::parser p{f.name, ","};
         auto x = p.get_next<my_string>();
-        CHECK_LT(move_called, 3);
+        CHECK_LE(move_called, 1);
-        move_called_one_col = move_called;
         move_called = 0;
     }
 
@@ -636,21 +633,21 @@ TEST_CASE("parser test the moving of parsed values") {
 
         ss::parser p{f.name, ","};
         auto x = p.get_next<my_string, my_string, my_string>();
-        CHECK_LE(move_called, 3 * move_called_one_col);
+        CHECK_LE(move_called, 3);
         move_called = 0;
     }
 
     {
         ss::parser p{f.name, ","};
         auto x = p.get_object<xyz, my_string, my_string, my_string>();
-        CHECK_LE(move_called, 6 * move_called_one_col);
+        CHECK_LE(move_called, 6);
         move_called = 0;
     }
 
     {
         ss::parser p{f.name, ","};
         auto x = p.get_next<xyz>();
-        CHECK_LE(move_called, 6 * move_called_one_col);
+        CHECK_LE(move_called, 6);
         move_called = 0;
     }
 }

test/test_single_header.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+set -x
+set -e
+
+python3 script/single_header_generator.py > ssp.cpp
+
+echo 'int main(){ ss::parser p{""}; p.get_next<int, float>(); return 0; }' \
+    >> ssp.cpp
+
+g++ -std=c++17 ssp.cpp -o ssp.bin -Wall -Wextra
+./ssp.bin
+
+rm ssp.cpp ssp.bin