Merge pull request #23 from red0124/bugfix/single_header_include_update

Update ssp.hpp to handle issue fixed in the previous commit

.github/workflows/ubuntu-latest-clang.yml

@@ -23,7 +23,7 @@ jobs:
 
     strategy:
       matrix:
-        version: [12, 11, 10, 9, 8, 7]
+        version: [11, 10, 9, 8, 7]
 
     runs-on: ubuntu-latest
 

.gitignore

@@ -3,5 +3,8 @@ compile_commands.json
 .ccls-cache/*
 experiment/
 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
-    DESCRIPTION "Static split parser"
+    VERSION 1.4.0
+    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)
-if(ssp_INCLUDE_WITHOUT_SYSTEM)
-  set(ssp_warning_guard "")
+set(SSP_WARNING_GUARD SYSTEM)
+if(SSP_INCLUDE_WITHOUT_SYSTEM)
+    set(SSP_WARNING_GUARD "")
 endif()
 
 # ---- Dependencies ----
 
 include(FetchContent)
-FetchContent_Declare(
-  fast_float
-  GIT_REPOSITORY https://github.com/red0124/fast_float.git
-  GIT_TAG origin/meson
-  GIT_SHALLOW TRUE)
+fetchcontent_declare(
+    fast_float
+    GIT_REPOSITORY https://github.com/red0124/fast_float.git
+    GIT_TAG origin/meson
+    GIT_SHALLOW TRUE
+)
 
-FetchContent_MakeAvailable(fast_float)
-set(fast_float_source_dir "${FETCHCONTENT_BASE_DIR}/fast_float-src")
+fetchcontent_makeavailable(fast_float)
+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}/fast_float>"
+        "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>"
+        "$<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:GNU>,$<VERSION_LESS:$<CXX_COMPILER_VERSION>,9.1>>:stdc++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>"
 )
 
 # ---- Install ----
@@ -55,19 +56,21 @@ target_link_libraries(
 include(CMakePackageConfigHelpers)
 include(GNUInstallDirs)
 
-set(ssp_directory "ssp-${PROJECT_VERSION}")
-set(ssp_include_directory "${CMAKE_INSTALL_INCLUDEDIR}")
+set(SSP_DIRECTORY "ssp-${PROJECT_VERSION}")
+set(SSP_INCLUDE_DIRECTORY "${CMAKE_INSTALL_INCLUDEDIR}")
 
 install(
-    DIRECTORY "${PROJECT_SOURCE_DIR}/include/" "${fast_float_source_dir}/include/"
-    DESTINATION "${ssp_include_directory}"
+    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

@@ -34,14 +34,9 @@ Bill (Heath) Gates,65,3.3
 #include <ss/parser.hpp>
 
 int main() {
-    ss::parser p{"students.csv"};
-    if (!p.valid()) {
-        exit(EXIT_FAILURE);
-    }
-
-    while (!p.eof()) {
-        auto [name, age, grade] = p.get_next<std::string, int, double>();
+    ss::parser p{"students.csv", ","};
 
+    for(const auto& [name, age, grade] : p.iterate<std::string, int, float>()) {
         if (p.valid()) {
             std::cout << name << ' ' << age << ' ' << grade << std::endl;
         }
@@ -58,21 +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 quotes, escapes and spacings](#Setup)
- * [Works with values containing new lines](#Multiline)
- * [Columns and rows can be ignored](#Special-types)
+ * [Works with headers](#headers)
+ * [Works with quotes, escapes and spacings](#setup)
+ * [Works with values containing new lines](#multiline)
+ * [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)
- * [Restrictions can be added for each column](#Restrictions)
- * [Works with `std::optional` and `std::variant`](#Special-types)
- * Works with **CRLF** and **LF**
- * [Conversions can be chained if invalid](#Substitute-conversions)
+ * [Descriptive error handling can be enabled](#error-handling)
+ * [Restrictions can be added for each column](#restrictions)
+ * [Works with `std::optional` and `std::variant`](#special-types)
+ * Works with **`CRLF`** and **`LF`**
+ * [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
@@ -82,58 +82,129 @@ $ cmake --configure .
 $ sudo make install
 ```
 
-*Note, this will also install the fast_float library*   
-The library supports [CMake](#Cmake) and [meson](#Meson) build systems    
+*Note, this will also install the fast_float library*
+The library supports [CMake](#Cmake) and [meson](#Meson) build systems
 
 # Usage
 
-## Conversions
-The above example will be used to show some of the features of the library. As seen above, the **get_next** method returns a tuple of objects specified inside the template type list.
+## Headers
 
-If a conversion could not be applied, the method would return a tuple of default constructed objects, and the **valid** method would return **false**, for example if the third (grade) column in our csv could not be converted to a double the conversion would fail. 
-
-If **get_next** is called with a **tuple** as template parameter it would behave identically to passing the same tuple parameters to **get_next**:
+The parser can be told to use only certain columns by parsing the header. This can be done by using the **`use_fields`** method. It accepts any number of string-like arguments or even an **`std::vector<std::string>`** with the field names. If any of the fields are not found within the header or if any fields are defined multiple times it will result in an error.
+```shell
+$ cat students_with_header.csv
+Name,Age,Grade
+James Bailey,65,2.5
+Brian S. Wolfe,40,1.9
+Bill (Heath) Gates,65,3.3
+```
 ```cpp
-using student = std::tuple<std::string, int, double>;
+    // ...
+    ss::parser p{"students.csv", ","};
+    p.use_fields("Name", "Grade");
 
-// returns std::tuple<std::string, int, double>
+    for(const auto& [name, grade] : p.iterate<std::string, float>()) {
+        std::cout << name << ' ' << grade << std::endl;
+    }
+    // ...
+```
+```shell
+$ ./a.out
+James Bailey 2.5
+Brian S. Wolfe 1.9
+Bill (Heath) Gates 3.3
+```
+The header can be ignored using the **`ss::ignore_header`** [setup](#Setup) option or by calling the **`ignore_next`** metod after the parser has been constructed.
+```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 praser can also check if a field is present within the header by using the **`field_exists`** method.
+```cpp
+    // ...
+    ss::parser p{"students.csv", ","};
+    p.use_fields("Name", "Grade");
+
+    const auto& [name, grade] = p.get_next<std::string, float>();
+    std::cout << name << ' ' << grade << std::endl;
+
+    if (p.field_exists("Age")) {
+        p.use_fields("Grade", "Name", "Age");
+        for (const auto& [grade, name, age] :
+             p.iterate<float, std::string, int>()) {
+            std::cout << grade << ' ' << name << ' ' << age << std::endl;
+        }
+    }
+    // ...
+```
+```shell
+$ ./a.out
+James Bailey 2.5
+1.9 Brian S. Wolfe 40
+3.3 Bill (Heath) Gates 65
+```
+## Conversions
+An alternate loop to the example above would look like: 
+```cpp
+while(!p.eof()) {
+    auto [name, age, grade] = p.get_next<std::string, int, float>();
+    if (p.valid()) {
+        std::cout << name << ' ' << age << ' ' << grade << std::endl;
+    }
+}
+```
+
+The alternate example will be used to show some of the features of the library. The **`get_next`** method returns a tuple of objects specified inside the template type list.
+
+If a conversion could not be applied, the method would return a tuple of default constructed objects, and the **`valid`** method would return **`false`**, for example if the third (grade) column in our csv could not be converted to a float the conversion would fail.
+
+If **`get_next`** is called with a **`tuple`** as template parameter it would behave identically to passing the same tuple parameters to **`get_next`**:
+```cpp
+using student = std::tuple<std::string, int, float>;
+
+// returns std::tuple<std::string, int, float>
 auto [name, age, grade] = p.get_next<student>();
 ```
 *Note, it does not always return a student tuple since the returned tuples parameters may be altered as explained below (no void, no restrictions, ...)*
 
-Whole objects can be returned using the **get_object** function which takes the tuple, created in a similar way as **get_next** does it, and creates an object out of it:
+Whole objects can be returned using the **`get_object`** function which takes the tuple, created in a similar way as **`get_next`** does it, and creates an object out of it:
 ```cpp
 struct student {
     std::string name;
     int age;
-    double grade;
+    float grade;
 };
 ```
 ```cpp
 // returns student
-auto student = p.get_object<student, std::string, int, double>();
+auto student = p.get_object<student, std::string, int, float>();
 ```
-This works with any object if the constructor could be invoked using the template arguments given to **get_object**:
+This works with any object if the constructor could be invoked using the template arguments given to **`get_object`**:
 ```cpp
 // returns std::vector<std::string> containing 3 elements
 auto vec = p.get_object<std::vector<std::string>, std::string, std::string, 
                         std::string>();
 ```
-And finally, using something I personally like to do, a struct (class) with a **tied** method which returns a tuple of references to to the members of the struct.
+An iteration loop as in the first example which returns objects would look like:
+```cpp
+for(const auto& student : p.iterate_object<student, std::string, int, float>()) {
+// ...
+}
+```
+And finally, using something I personally like to do, a struct (class) with a **`tied`** method which returns a tuple of references to to the members of the struct.
 ```cpp
 struct student {
     std::string name;
     int age;
-    double grade;
+    float grade;
 
     auto tied() { return std::tie(name, age, grade); }
 };
 ```
-The method can be used to compare the object, serialize it, deserialize it, etc. Now **get_next** can accept such a struct and deduce the types to which to convert the csv.
+The method can be used to compare the object, serialize it, deserialize it, etc. Now **`get_next`** can accept such a struct and deduce the types to which to convert the csv.
 ```cpp
 // returns student
 auto s = p.get_next<student>();
 ```
+This works with the iteration loop too.
 *Note, the order in which the members of the tied method are returned must match the order of the elements in the csv*.
 
 ## Setup
@@ -152,11 +223,18 @@ using my_setup = ss::setup<ss::escape<'\\'>, ss::quote<'"'>>;
 // equivalent to p0 and p1
 ss::parser<my_setup> p2{file_name};
 ```
-Invalid setups will be met with **static_asserts**.
+Invalid setups will be met with **`static_asserts`**.
 *Note, each setup parameter defined comes with a slight performance loss, so use them only if needed.*
 
+### Empty lines
+Empty lines can be ignored by defining **`ss::ignore_empty`** within the setup parameters:
+```cpp
+ss::parser<ss::ignore_empty> p{file_name};
+```
+If this setup option is not set then reading an empty line will result in an error (unless only one column is present within the csv).
+
 ### Quoting
-Quoting can be enabled by defining **ss::quote** within the setup parameters. A single character can be defined as the quoting character, for example to use **"** as a quoting character:
+Quoting can be enabled by defining **`ss::quote`** within the setup parameters. A single character can be defined as the quoting character, for example to use **`"`** as a quoting character:
 ```cpp
 ss::parser<ss::quote<'"'>> p{file_name};
 ```
@@ -169,7 +247,7 @@ Unterminated quotes result in an error (if multiline is not enabled).
 "James Bailey,65,2.5 -> error
 ```
 ### Escaping
-Escaping can be enabled by defining **ss::escape** within the setup parameters. Multiple character can be defined as escaping characters.It simply removes any special meaning of the character behind the escaped character, anything can be escaped. For example to use ``\`` as an escaping character:
+Escaping can be enabled by defining **`ss::escape`** within the setup parameters. Multiple character can be defined as escaping characters.It simply removes any special meaning of the character behind the escaped character, anything can be escaped. For example to use ``\`` as an escaping character:
 ```cpp
 ss::parser<ss::escape<'\\'>> p{file_name};
 ```
@@ -186,7 +264,7 @@ Its usage has more impact when used with quoting or spacing:
 "James \"Bailey\"" -> 'James "Bailey"'
 ```
 ### Spacing
-Spacing can be enabled by defining **ss::trim** , **ss::trim_left**  or **ss::trim_right** within the setup parameters. Multiple character can be defined as spacing characters, for example to use ``' '`` as an spacing character **ss::trim<' '>** needs to be defined. It removes any space from both sides of the row. To trim only the right side **ss::trim_right** can be used, and intuitively **ss::trim_left** to trim only the left side. If **ss::trim** is enabled, those lines would have an equivalent output:
+Spacing can be enabled by defining **`ss::trim`** , **`ss::trim_left`**  or **`ss::trim_right`** within the setup parameters. Multiple character can be defined as spacing characters, for example to use ``' '`` as an spacing character **`ss::trim<' '>`** needs to be defined. It removes any space from both sides of the row. To trim only the right side **`ss::trim_right`** can be used, and intuitively **`ss::trim_left`** to trim only the left side. If **`ss::trim`** is enabled, those lines would have an equivalent output:
 ```
 James Bailey,65,2.5
   James Bailey  ,65,2.5
@@ -202,7 +280,7 @@ Escaping and quoting can be used to leave the space if needed.
 ```
 
 ### Multiline
-Multiline can be enabled by defining **ss::multilne** within the setup parameters. It enables the possibility to have the new line characters within rows. The new line character needs to be either escaped or within quotes so either **ss::escape** or **ss::quote** need to be enabled. There is a specific problem when using multiline, for example, if a row had an unterminated quote, the parser would assume it to be a new line within the row, so until another quote is found, it will treat it as one line which is fine usually, but it can cause the whole csv file to be treated as a single line by mistake. To prevent this **ss::multiline_restricted** can be used which accepts an unsigned number representing the maximum number of lines which can be allowed as a single multiline. Examples:
+Multiline can be enabled by defining **`ss::multilne`** within the setup parameters. It enables the possibility to have the new line characters within rows. The new line character needs to be either escaped or within quotes so either **`ss::escape`** or **`ss::quote`** need to be enabled. There is a specific problem when using multiline, for example, if a row had an unterminated quote, the parser would assume it to be a new line within the row, so until another quote is found, it will treat it as one line which is fine usually, but it can cause the whole csv file to be treated as a single line by mistake. To prevent this **`ss::multiline_restricted`** can be used which accepts an unsigned number representing the maximum number of lines which can be allowed as a single multiline. Examples:
 
 ```cpp
 ss::parser<ss::multiline, ss::quote<'\"'>, ss::escape<'\\'>> p{file_name};
@@ -229,7 +307,7 @@ ss::parser<ss::escape<'\\'>,
            ss::multiline_restricted<5>> p{file_name};
 
 while(!p.eof()) {
-    auto [name, age, grade] = p.get_next<std::string, int, double>();
+    auto [name, age, grade] = p.get_next<std::string, int, float>();
     if(!p.valid()) {
         continue;
     }
@@ -256,53 +334,59 @@ Gates 65 3.3'
 ```
 ## Special types
 
-Passing **void** makes the parser ignore a column. In the given example **void** could be given as the second template parameter to ignore the second (age) column in the csv, a tuple of only 2 parameters would be retuned:
+Passing **`void`** makes the parser ignore a column. In the given example **`void`** could be given as the second template parameter to ignore the second (age) column in the csv, a tuple of only 2 parameters would be retuned:
 ```cpp
-// returns std::tuple<std::string, double>
-auto [name, grade] = p.get_next<std::string, void, double>();
+// returns std::tuple<std::string, float>
+auto [name, grade] = p.get_next<std::string, void, float>();
 ```
 Works with different types of conversions too:
 ```cpp
-using student = std::tuple<std::string, void, double>;
+using student = std::tuple<std::string, void, float>;
 
-// returns std::tuple<std::string, double>
+// returns std::tuple<std::string, float>
 auto [name, grade] = p.get_next<student>();
 ```
-To ignore a whole row, **ignore_next** could be used, returns **false** if **eof**: 
+Values can also be converted to **`std::string_view`**. It is more efficient then converting values to **`std::string`** but one must be careful with the lifetime of it.
+```cpp
+// string_view name stays valid until the next line is read
+auto [name, age, grade] = p.get_next<std::string_view, int, float>();
+```
+
+To ignore a whole row, **`ignore_next`** could be used, returns **`false`** if **`eof`**:
 ```cpp
 bool parser::ignore_next();
 ```
-**std::optional** could be passed if we wanted the conversion to proceed in the case of a failure returning **std::nullopt** for the specified column: 
+**`std::optional`** could be passed if we wanted the conversion to proceed in the case of a failure returning **`std::nullopt`** for the specified column:
 
 ```cpp
-// returns std::tuple<std::string, int, std::optional<double>>
-auto [name, age, grade] = p.get_next<std::string, int, std::optional<double>();
+// returns std::tuple<std::string, int, std::optional<float>>
+auto [name, age, grade] = p.get_next<std::string, int, std::optional<float>();
 if(grade) {
     // do something with grade
 }
 ```
-Similar to **std::optional**, **std::variant** could be used to try other conversions if the previous failed _(Note, conversion to std::string will always pass)_:
+Similar to **`std::optional`**, **`std::variant`** could be used to try other conversions if the previous failed _(Note, conversion to std::string will always pass)_:
 ```cpp
-// returns std::tuple<std::string, int, std::variant<double, char>>
+// returns std::tuple<std::string, int, std::variant<float, char>>
 auto [name, age, grade] = 
-    p.get_next<std::string, int, std::variant<double, char>();
-if(std::holds_alternative<double>(grade)) {
-    // grade set as double
+    p.get_next<std::string, int, std::variant<float, char>();
+if(std::holds_alternative<float>(grade)) {
+    // grade set as float
 } else if(std::holds_alternative<char>(grade)) {
     // grade set as char
 }
 ```
 ## 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]
-// returns std::tuple<std::string, int, double>
+// returns std::tuple<std::string, int, float>
 auto [name, age, grade] = 
-    p.get_next<ss::ne<std::string>, int, ss::ir<double, 0, 10>>();
+    p.get_next<ss::ne<std::string>, int, ss::ir<float, 0, 10>>();
 ```
-If the restrictions are not met, the conversion will fail. Other predefined restrictions are **ss::ax** (all except), **ss::nx** (none except) and **ss::oor** (out of range), **ss::lt** (less than), ...(see *restrictions.hpp*):
+If the restrictions are not met, the conversion will fail. Other predefined restrictions are **`ss::ax`** (all except), **`ss::nx`** (none except) and **`ss::oor`** (out of range), **`ss::lt`** (less than), ...(see *restrictions.hpp*):
 ```cpp
 // all ints exept 10 and 20
 ss::ax<int, 10, 20>
@@ -311,7 +395,7 @@ ss::nx<int, 10, 20>
 // all values except the range [0, 10]
 ss::oor<int, 0, 10>
 ```
-To define a restriction, a class/struct needs to be made which has a **ss_valid** method which returns a **bool** and accepts one object. The type of the conversion will be the same as the type of the passed object within **ss_valid** and not the restriction itself. Optionally, an **error** method can be made to describe the invalid conversion.
+To define a restriction, a class/struct needs to be made which has a **`ss_valid`** method which returns a **`bool`** and accepts one object. The type of the conversion will be the same as the type of the passed object within **`ss_valid`** and not the restriction itself. Optionally, an **`error`** method can be made to describe the invalid conversion.
 ```cpp
 template <typename T>
 struct even {
@@ -332,7 +416,7 @@ auto [name, age] = p.get_next<std::string, even<int>, void>();
 ```
 ## Custom conversions
 
-Custom types can be used when converting values. A specialization of the **ss::extract** function needs to be made and you are good to go. A custom conversion for an enum would look like this: 
+Custom types can be used when converting values. A specialization of the **`ss::extract`** function needs to be made and you are good to go. A custom conversion for an enum would look like this:
 ```cpp
 enum class shape { circle, square, rectangle, triangle };
 
@@ -351,11 +435,11 @@ inline bool ss::extract(const char* begin, const char* end, shape& dst) {
     return false;
 }
 ```
-The shape enum will be used in an example below. The **inline** is there just to prevent multiple definition errors. The function returns **true** if the conversion was a success, and **false** otherwise. The function uses **const char*** begin and end for performance reasons. 
+The shape enum will be used in an example below. The **`inline`** is there just to prevent multiple definition errors. The function returns **`true`** if the conversion was a success, and **`false`** otherwise. The function uses **`const char*`** begin and end for performance reasons.
 
 ## Error handling
 
-Detailed error messages can be accessed via the **error_msg** method, and to enable them **ss::string_error** needs to be included in the setup. If **ss::string_error** is not defined, the **error_msg** method will not be defined either.
+Detailed error messages can be accessed via the **`error_msg`** method, and to enable them **`ss::string_error`** needs to be included in the setup. If **`ss::string_error`** is not defined, the **`error_msg`** method will not be defined either.
 
 ```cpp
 const std::string& parser::error_msg();
@@ -365,7 +449,7 @@ bool parser::eof();
 // ...
 ss::parser<ss::string_error> parser;
 ```
-An error can be detected using the **valid** method which would return **false** if the file could not be opened, or if the conversion could not be made (invalid types, invalid number of columns, ...). The **eof** method can be used to detect if the end of the file was reached.
+An error can be detected using the **`valid`** method which would return **`false`** if the file could not be opened, or if the conversion could not be made (invalid types, invalid number of columns, ...). The **`eof`** method can be used to detect if the end of the file was reached.
 
 ## Substitute conversions
 
@@ -388,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);
 }
 
@@ -430,9 +513,9 @@ 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:
+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
 std::tuple<
     std::optional<std::tuple<shape, double>>,
@@ -440,9 +523,9 @@ std::tuple<
     std::optional<std::tuple<shape, double, double, double>>
     >
 ```
-Similar to the way that **get_next** has a **get_object** alternative, **try_next** has a **try_object** alternative, and **or_else** has a **or_object** alternative. Also all rules applied to **get_next** also work with **try_next** , **or_else**, and all the other **composite** conversions.
+Similar to the way that **`get_next`** has a **`get_object`** alternative, **`try_next`** has a **`try_object`** alternative, and **`or_else`** has a **`or_object`** alternative. Also all rules applied to **`get_next`** also work with **`try_next`** , **`or_else`**, and all the other **`composite`** conversions.
 
-Each of those **composite** conversions can accept a lambda (or anything callable) as an argument and invoke it in case of a valid conversion. That lambda itself need not have any arguments, but if it does, it must either accept the whole **tuple**/object as one argument or all the elements of the tuple separately. If the lambda returns something that can be interpreted as **false** the conversion will fail, and the next conversion will try to apply. Rewriting the whole while loop using lambdas would look like this:
+Each of those **`composite`** conversions can accept a lambda (or anything callable) as an argument and invoke it in case of a valid conversion. That lambda itself need not have any arguments, but if it does, it must either accept the whole **`tuple`**/object as one argument or all the elements of the tuple separately. If the lambda returns something that can be interpreted as **`false`** the conversion will fail, and the next conversion will try to apply. Rewriting the whole while loop using lambdas would look like this:
 ```cpp
 // non negative double
 using udbl = ss::gte<double, 0>;
@@ -466,7 +549,7 @@ p.try_next<ss::nx<shape, shape::circle, shape::square>, udbl>(
             }
         });
 ```
-It is a bit less readable, but it removes the need to check which conversion was invoked. The **composite** also has an **on_error** method which accepts a lambda which will be invoked if no previous conversions were successful. The lambda can take no arguments or just one argument, an **std::string**, in which the error message is stored if **string_error** is enabled: 
+It is a bit less readable, but it removes the need to check which conversion was invoked. The **`composite`** also has an **`on_error`** method which accepts a lambda which will be invoked if no previous conversions were successful. The lambda can take no arguments or just one argument, an **`std::string`**, in which the error message is stored if **`string_error`** is enabled:
 ```cpp
 p.try_next<int>()
     .on_error([](const std::string& e) { /* int conversion failed */ })
@@ -481,9 +564,9 @@ First of all, *type_traits.hpp* and *function_traits.hpp* contain many handy tra
 
 ## The converter
 
-**ss::parser** is used to manipulate on files. It has a builtin file reader, but the conversions themselves are done using the **ss::converter**.
+**`ss::parser`** is used to manipulate on files. It has a builtin file reader, but the conversions themselves are done using the **`ss::converter`**.
 
-To convert a string the **convert** method can be used. It accepts a c-string as input and a delimiter, as **std::string**, and retruns a **tuple** of objects in the same way **get_next** does it for the parser. A whole object can be returned too using the **convert_object** method, again in an identical way **get_object** doest it for the parser.  
+To convert a string the **`convert`** method can be used. It accepts a c-string as input and a delimiter, as **`std::string`**, and retruns a **`tuple`** of objects in the same way **`get_next`** does it for the parser. A whole object can be returned too using the **`convert_object`** method, again in an identical way **`get_object`** doest it for the parser.
 ```cpp
 ss::converter c;
 
@@ -500,7 +583,7 @@ if (c.valid()) {
 All setup parameters, special types and restrictions work on the converter too.  
 Error handling is also identical to error handling of the parser.
 
-The converter has also the ability to just split the line, ~~tho it does not change it (kinda statically), hence the name of the library~~ and depending if either quoting or escaping are enabled it may change the line, rather than creating a copy, for performance reasons (the name of the library does not apply anymore, I may change it). It returns an **std::vector** of pairs of pointers, begin and end, each pair representing a split segment (column) of the whole string. The vector can then be used in a overloaded **convert** method. This allows the reuse of the same line without splitting it on every conversion. 
+The converter has also the ability to just split the line, ~~tho it does not change it (kinda statically), hence the name of the library~~ and depending if either quoting or escaping are enabled it may change the line, rather than creating a copy, for performance reasons (the name of the library does not apply anymore, I may change it). It returns an **`std::vector`** of **`std::pair`**s of pointers, begin and end, each pair representing a split segment (column) of the whole string. The vector can then be used in a overloaded **`convert`** method. This allows the reuse of the same line without splitting it on every conversion.
 ```cpp
 ss::converter c;
 auto split_line = c.split("circle 10", " ");
@@ -513,7 +596,7 @@ std::string s;
 std::cin >> s;
 int num = c.convert<int>(s.c_str());
 ```
-The same setup parameters also apply for the converter, tho multiline has not impact on it. Since escaping and quoting potentially modify the content of the given line, a converter which has those setup parameters defined does not have the same convert method, **the input line cannot be const**.
+The same setup parameters also apply for the converter, tho multiline has not impact on it. Since escaping and quoting potentially modify the content of the given line, a converter which has those setup parameters defined does not have the same convert method, **`the input line cannot be const`**.
 
 # Using as a project dependency
 
@@ -548,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 = ssp_sub.get_variable('ssp_dep')
+ssp_dep = dependency('ssp')
 ```

include/ss/common.hpp

@@ -1,4 +1,7 @@
 #pragma once
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
 #include <vector>
 
 namespace ss {
@@ -21,7 +24,6 @@ inline ssize_t get_line(char** lineptr, size_t* n, FILE* stream) {
     return getline(lineptr, n, stream);
 }
 #else
-#include <cstdint>
 using ssize_t = int64_t;
 inline ssize_t get_line(char** lineptr, size_t* n, FILE* stream) {
     size_t pos;

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);
     }
 
@@ -244,7 +244,6 @@ private:
         }
     }
 
-
     void set_error_multiline_limit_reached() {
         if constexpr (string_error) {
             error_.clear();
@@ -274,7 +273,7 @@ private:
         }
     }
 
-    void set_error_number_of_colums(size_t expected_pos, size_t pos) {
+    void set_error_number_of_columns(size_t expected_pos, size_t pos) {
         if constexpr (string_error) {
             error_.clear();
             error_.append("invalid number of columns, expected: ")
@@ -286,6 +285,43 @@ private:
         }
     }
 
+    void set_error_incompatible_mapping(size_t argument_size,
+                                        size_t mapping_size) {
+        if constexpr (string_error) {
+            error_.clear();
+            error_
+                .append(
+                    "number of arguments does not match mapping, expected: ")
+                .append(std::to_string(mapping_size))
+                .append(", got: ")
+                .append(std::to_string(argument_size));
+        } else {
+            error_ = true;
+        }
+    }
+
+    void set_error_invalid_mapping() {
+        if constexpr (string_error) {
+            error_.clear();
+            error_.append("received empty mapping");
+        } else {
+            error_ = true;
+        }
+    }
+
+    void set_error_mapping_out_of_range(size_t maximum_index,
+                                        size_t number_of_columnts) {
+        if constexpr (string_error) {
+            error_.clear();
+            error_.append("maximum index: ")
+                .append(std::to_string(maximum_index))
+                .append(", greater then number of columns: ")
+                .append(std::to_string(number_of_columnts));
+        } else {
+            error_ = true;
+        }
+    }
+
     ////////////////
     // convert implementation
     ////////////////
@@ -293,6 +329,7 @@ private:
     template <typename... Ts>
     no_void_validator_tup_t<Ts...> convert_impl(const split_data& elems) {
         clear_error();
+        using return_type = no_void_validator_tup_t<Ts...>;
 
         if (!splitter_.valid()) {
             set_error_unterminated_quote();
@@ -300,10 +337,22 @@ private:
             return ret;
         }
 
-        if (sizeof...(Ts) != elems.size()) {
-            set_error_number_of_colums(sizeof...(Ts), elems.size());
-            no_void_validator_tup_t<Ts...> ret{};
-            return ret;
+        if (!columns_mapped()) {
+            if (sizeof...(Ts) != elems.size()) {
+                set_error_number_of_columns(sizeof...(Ts), elems.size());
+                return return_type{};
+            }
+        } else {
+            if (sizeof...(Ts) != column_mappings_.size()) {
+                set_error_incompatible_mapping(sizeof...(Ts),
+                                               column_mappings_.size());
+                return return_type{};
+            }
+
+            if (elems.size() != number_of_columns_) {
+                set_error_number_of_columns(number_of_columns_, elems.size());
+                return return_type{};
+            }
         }
 
         return extract_tuple<Ts...>(elems);
@@ -316,6 +365,43 @@ private:
         return convert_impl<Ts...>(elems);
     }
 
+    ////////////////
+    // column mapping
+    ////////////////
+
+    bool columns_mapped() const {
+        return column_mappings_.size() != 0;
+    }
+
+    size_t column_position(size_t tuple_position) const {
+        if (!columns_mapped()) {
+            return tuple_position;
+        }
+        return column_mappings_[tuple_position];
+    }
+
+    void set_column_mapping(std::vector<size_t> positions,
+                            size_t number_of_columns) {
+        if (positions.empty()) {
+            set_error_invalid_mapping();
+            return;
+        }
+
+        auto max_index = *std::max_element(positions.begin(), positions.end());
+        if (max_index >= number_of_columns) {
+            set_error_mapping_out_of_range(max_index, number_of_columns);
+            return;
+        }
+
+        column_mappings_ = positions;
+        number_of_columns_ = number_of_columns;
+    }
+
+    void clear_column_positions() {
+        column_mappings_.clear();
+        number_of_columns_ = 0;
+    }
+
     ////////////////
     // conversion
     ////////////////
@@ -359,10 +445,10 @@ private:
 
         if constexpr (not_void) {
             if constexpr (one_element) {
-                extract_one<elem_t>(tup, elems[ArgN], ArgN);
+                extract_one<elem_t>(tup, elems[column_position(ArgN)], ArgN);
             } else {
                 auto& el = std::get<TupN>(tup);
-                extract_one<elem_t>(el, elems[ArgN], ArgN);
+                extract_one<elem_t>(el, elems[column_position(ArgN)], ArgN);
             }
         }
 
@@ -390,6 +476,9 @@ private:
 
     template <typename...>
     friend class parser;
+
+    std::vector<size_t> column_mappings_;
+    size_t number_of_columns_;
 };
 
 } /* ss */

include/ss/extract.hpp

@@ -2,20 +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) {
@@ -28,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';
@@ -318,7 +341,14 @@ inline bool extract(const char* begin, const char* end, char& value) {
 
 template <>
 inline bool extract(const char* begin, const char* end, std::string& value) {
-    value = std::string(begin, end);
+    value = std::string{begin, end};
+    return true;
+}
+
+template <>
+inline bool extract(const char* begin, const char* end,
+                    std::string_view& value) {
+    value = std::string_view{begin, static_cast<size_t>(end - begin)};
     return true;
 }
 

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;
@@ -25,12 +25,21 @@ class parser {
     constexpr static bool quoted_multiline_enabled =
         multiline::enabled && setup<Matchers...>::quote::enabled;
 
+    constexpr static bool ignore_header = setup<Matchers...>::ignore_header;
+
+    constexpr static bool ignore_empty = setup<Matchers...>::ignore_empty;
+
 public:
     parser(const std::string& file_name,
            const std::string& delim = ss::default_delimiter)
         : file_name_{file_name}, reader_{file_name_, delim} {
         if (reader_.file_) {
             read_line();
+            if constexpr (ignore_header) {
+                ignore_next();
+            } else {
+                header_ = reader_.get_next_row();
+            }
         } else {
             set_error_file_not_open();
             eof_ = true;
@@ -57,15 +66,23 @@ public:
         return error_;
     }
 
-    bool eof() const { return eof_; }
+    bool eof() const {
+        return eof_;
+    }
 
-    bool ignore_next() { return reader_.read_next(); }
+    bool ignore_next() {
+        return reader_.read_next();
+    }
 
     template <typename T, typename... Ts>
     T get_object() {
         return to_object<T>(get_next<Ts...>());
     }
 
+    size_t line() const {
+        return valid() ? reader_.line_number_ - 1 : 0;
+    }
+
     template <typename T, typename... Ts>
     no_void_validator_tup_t<T, Ts...> get_next() {
         reader_.update();
@@ -85,6 +102,128 @@ public:
         return value;
     }
 
+    bool field_exists(const std::string& field) {
+        return header_index(field).has_value();
+    }
+
+    template <typename... Ts>
+    void use_fields(const Ts&... fields_args) {
+        if constexpr (ignore_header) {
+            set_error_header_ignored();
+            return;
+        }
+
+        if (!valid()) {
+            return;
+        }
+
+        auto fields = std::vector<std::string>{fields_args...};
+        std::vector<size_t> column_mappings;
+
+        for (const auto& field : fields) {
+            if (std::count(fields.begin(), fields.end(), field) != 1) {
+                set_error_field_used_multiple_times(field);
+                return;
+            }
+
+            auto index = header_index(field);
+
+            if (!index) {
+                set_error_invalid_field(field);
+                return;
+            }
+
+            column_mappings.push_back(*index);
+        }
+
+        reader_.converter_.set_column_mapping(column_mappings, header_.size());
+        reader_.next_line_converter_.set_column_mapping(column_mappings,
+                                                        header_.size());
+        if (line() == 0) {
+            ignore_next();
+        }
+    }
+
+    ////////////////
+    // iterator
+    ////////////////
+
+    template <bool get_object, typename T, typename... Ts>
+    struct iterable {
+        struct iterator {
+            using value = std::conditional_t<get_object, T,
+                                             no_void_validator_tup_t<T, Ts...>>;
+
+            iterator() : parser_{nullptr} {
+            }
+            iterator(parser<Matchers...>* parser) : parser_{parser} {
+            }
+
+            value& operator*() {
+                return value_;
+            }
+            value* operator->() {
+                return &value_;
+            }
+
+            iterator& operator++() {
+                if (parser_->eof()) {
+                    parser_ = nullptr;
+                } else {
+                    if constexpr (get_object) {
+                        value_ =
+                            std::move(parser_->template get_object<T, Ts...>());
+                    } else {
+                        value_ =
+                            std::move(parser_->template get_next<T, Ts...>());
+                    }
+                }
+                return *this;
+            }
+
+            iterator& operator++(int) {
+                return ++*this;
+            }
+
+            friend bool operator==(const iterator& lhs, const iterator& rhs) {
+                return (lhs.parser_ == nullptr && rhs.parser_ == nullptr) ||
+                       (lhs.parser_ == rhs.parser_ &&
+                        &lhs.value_ == &rhs.value_);
+            }
+
+            friend bool operator!=(const iterator& lhs, const iterator& rhs) {
+                return !(lhs == rhs);
+            }
+
+        private:
+            value value_;
+            parser<Matchers...>* parser_;
+        };
+
+        iterable(parser<Matchers...>* parser) : parser_{parser} {
+        }
+
+        iterator begin() {
+            return ++iterator{parser_};
+        }
+        iterator end() {
+            return iterator{};
+        }
+
+    private:
+        parser<Matchers...>* parser_;
+    };
+
+    template <typename... Ts>
+    auto iterate() {
+        return iterable<false, Ts...>{this};
+    }
+
+    template <typename... Ts>
+    auto iterate_object() {
+        return iterable<true, Ts...>{this};
+    }
+
     ////////////////
     // composite conversion
     ////////////////
@@ -92,7 +231,8 @@ public:
     class composite {
     public:
         composite(std::tuple<Ts...>&& values, parser& parser)
-            : values_{std::move(values)}, parser_{parser} {}
+            : values_{std::move(values)}, parser_{parser} {
+        }
 
         // tries to convert the same line with a different output type
         // only if the previous conversion was not successful,
@@ -118,7 +258,9 @@ public:
             return composite_with(std::move(value));
         }
 
-        std::tuple<Ts...> values() { return values_; }
+        std::tuple<Ts...> values() {
+            return values_;
+        }
 
         template <typename Fun>
         auto on_error(Fun&& fun) {
@@ -253,6 +395,20 @@ private:
         return {valid() ? std::move(value) : std::nullopt, *this};
     }
 
+    ////////////////
+    // header
+    ////////////////
+
+    std::optional<size_t> header_index(const std::string& field) {
+        auto it = std::find(header_.begin(), header_.end(), field);
+
+        if (it == header_.end()) {
+            return std::nullopt;
+        }
+
+        return std::distance(header_.begin(), it);
+    }
+
     ////////////////
     // error
     ////////////////
@@ -304,15 +460,50 @@ private:
         }
     }
 
+    void set_error_header_ignored() {
+        if constexpr (string_error) {
+            error_.append(file_name_)
+                .append(": \"")
+                .append("the header row is ignored within the setup, it cannot "
+                        "be used")
+                .append("\"");
+        } else {
+            error_ = true;
+        }
+    }
+
+    void set_error_invalid_field(const std::string& field) {
+        if constexpr (string_error) {
+            error_.append(file_name_)
+                .append(": header does not contain given field: ")
+                .append(field);
+        } else {
+            error_ = true;
+        }
+    }
+
+    void set_error_field_used_multiple_times(const std::string& field) {
+        if constexpr (string_error) {
+            error_.append(file_name_)
+                .append(": given field used multiple times: ")
+                .append(field);
+        } else {
+            error_ = true;
+        }
+    }
+
     ////////////////
     // line reading
     ////////////////
 
-    void read_line() { eof_ = !reader_.read_next(); }
+    void read_line() {
+        eof_ = !reader_.read_next();
+    }
 
     struct reader {
         reader(const std::string& file_name_, const std::string& delim)
-            : delim_{delim}, file_{fopen(file_name_.c_str(), "rb")} {}
+            : delim_{delim}, file_{fopen(file_name_.c_str(), "rb")} {
+        }
 
         reader(reader&& other)
             : buffer_{other.buffer_},
@@ -320,7 +511,7 @@ private:
               helper_buffer_{other.helper_buffer_}, converter_{std::move(
                                                         other.converter_)},
               next_line_converter_{std::move(other.next_line_converter_)},
-              size_{other.size_}, next_line_size_{other.size_},
+              size_{other.size_}, next_line_size_{other.next_line_size_},
               helper_size_{other.helper_size_}, delim_{std::move(other.delim_)},
               file_{other.file_}, crlf_{other.crlf_}, line_number_{
                                                           other.line_number_} {
@@ -369,16 +560,27 @@ private:
         reader& operator=(const reader& other) = delete;
 
         bool read_next() {
-            ++line_number_;
-            memset(next_line_buffer_, '\0', next_line_size_);
-            ssize_t ssize =
-                get_line(&next_line_buffer_, &next_line_size_, file_);
 
-            if (ssize == -1) {
-                return false;
+            ssize_t ssize;
+            size_t size = 0;
+            while (size == 0) {
+                ++line_number_;
+                if (next_line_size_ > 0) {
+                    next_line_buffer_[0] = '\0';
+                }
+                ssize = get_line(&next_line_buffer_, &next_line_size_, file_);
+
+                if (ssize == -1) {
+                    return false;
+                }
+
+                size = remove_eol(next_line_buffer_, ssize);
+
+                if constexpr (!ignore_empty) {
+                    break;
+                }
             }
 
-            size_t size = remove_eol(next_line_buffer_, ssize);
             size_t limit = 0;
 
             if constexpr (escaped_multiline_enabled) {
@@ -421,7 +623,8 @@ private:
                         }
                     }
 
-                    next_line_converter_.resplit(next_line_buffer_, size);
+                    next_line_converter_.resplit(next_line_buffer_, size,
+                                                 delim_);
                 }
             }
 
@@ -511,6 +714,15 @@ private:
             return true;
         }
 
+        std::vector<std::string> get_next_row() const {
+            std::vector<std::string> next_row;
+            auto& next_row_raw = next_line_converter_.splitter_.split_data_;
+            for (const auto& [begin, end] : next_row_raw) {
+                next_row.emplace_back(begin, end);
+            }
+            return next_row;
+        }
+
         ////////////////
         // members
         ////////////////
@@ -539,6 +751,7 @@ private:
     std::string file_name_;
     error_type error_{};
     reader reader_;
+    std::vector<std::string> header_;
     bool eof_{false};
 };
 

include/ss/setup.hpp

@@ -109,10 +109,10 @@ struct get_matcher<Matcher, T, Ts...> {
     struct is_matcher : is_instance_of_matcher<U, Matcher> {};
 
     static_assert(count_v<is_matcher, T, Ts...> <= 1,
-                  "the same matcher is cannot"
+                  "the same matcher cannot"
                   "be defined multiple times");
-    using type = ternary_t<is_matcher<T>::value, T,
-                           typename get_matcher<Matcher, Ts...>::type>;
+    using type = std::conditional_t<is_matcher<T>::value, T,
+                                    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,
-                           typename get_multiline<Ts...>::type>;
+    using type = std::conditional_t<is_instance_of_multiline<T>::value, T,
+                                    typename get_multiline<Ts...>::type>;
 };
 
 template <>
@@ -167,6 +167,18 @@ using get_multiline_t = typename get_multiline<Ts...>::type;
 
 class string_error;
 
+////////////////
+// ignore_header
+////////////////
+
+class ignore_header;
+
+////////////////
+// ignore_empty
+////////////////
+
+class ignore_empty;
+
 ////////////////
 // setup implementation
 ////////////////
@@ -185,13 +197,27 @@ private:
     template <typename T>
     struct is_string_error : std::is_same<T, string_error> {};
 
+    template <typename T>
+    struct is_ignore_header : std::is_same<T, ignore_header> {};
+
+    template <typename T>
+    struct is_ignore_empty : std::is_same<T, ignore_empty> {};
+
     constexpr static auto count_matcher = count_v<is_matcher, Ts...>;
+
     constexpr static auto count_multiline =
         count_v<is_instance_of_multiline, Ts...>;
+
     constexpr static auto count_string_error = count_v<is_string_error, Ts...>;
 
+    constexpr static auto count_ignore_header =
+        count_v<is_ignore_header, Ts...>;
+
+    constexpr static auto count_ignore_empty = count_v<is_ignore_empty, Ts...>;
+
     constexpr static auto number_of_valid_setup_types =
-        count_matcher + count_multiline + count_string_error;
+        count_matcher + count_multiline + count_string_error +
+        count_ignore_header + count_ignore_empty;
 
     using trim_left_only = get_matcher_t<trim_left, Ts...>;
     using trim_right_only = get_matcher_t<trim_right, Ts...>;
@@ -201,11 +227,15 @@ 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_right = ternary_t<trim_all::enabled, trim_all, trim_right_only>;
+    using trim_left =
+        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);
+    constexpr static bool ignore_header = (count_ignore_header == 1);
+    constexpr static bool ignore_empty = (count_ignore_empty == 1);
 
 private:
 #define ASSERT_MSG "cannot have the same match character in multiple matchers"

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
 ////////////////
@@ -388,7 +368,7 @@ T to_object_impl(std::index_sequence<Is...>, U&& data) {
 
 template <class T, class U>
 T to_object(U&& data) {
-    using NoRefU = std::remove_reference_t<U>;
+    using NoRefU = std::decay_t<U>;
     if constexpr (is_instance_of_v<std::tuple, NoRefU>) {
         return to_object_impl<
             T>(std::make_index_sequence<std::tuple_size<NoRefU>{}>{},

meson.build

@@ -1,17 +1,24 @@
-project('ssp', 'cpp', 
+project(
+  'ssp', 
+  ['cpp'], 
   default_options : 
-  ['warning_level=3', 
-    'cpp_std=c++17', 
-    'buildtype=debugoptimized'])
+    ['warning_level=3', 
+      'cpp_std=c++17', 
+      'buildtype=debugoptimized',
+      'wrap_mode=forcefallback'],
+  version: '1.4.0',
+  meson_version:'>=0.54.0')
 
-fast_float_sub = subproject('fast_float')
-fast_float_dep = fast_float_sub.get_variable('fast_float_dep')
+fast_float_dep = dependency('fast_float')
 
 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
-revision = 2.4.4
+url = https://github.com/red0124/doctest
+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_MakeAvailable(ssp)
+fetchcontent_declare(ssp SOURCE_DIR "${PROJECT_SOURCE_DIR}/..")
+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)
-# for doctest_discover_tests
-include(doctest)
+include(FetchContent)
+fetchcontent_declare(
+    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")
-  target_link_libraries("${name}" PRIVATE ssp::ssp fast_float doctest::doctest)
-  target_compile_definitions("${name}" PRIVATE
-    DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN CMAKE_GITHUB_CI)
-  doctest_discover_tests("${name}")
+    add_executable("${name}" "${name}.cpp")
+    target_link_libraries(
+        "${name}"
+        PRIVATE ssp::ssp fast_float doctest::doctest
+    )
+    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 = doctest_proj.get_variable('doctest_dep')
+doctest_dep = dependency('doctest')
 
 test_exe = executable(
   'test_ssp',

test/test_converter.cpp

@@ -107,6 +107,13 @@ TEST_CASE("converter test valid conversions") {
         REQUIRE(std::holds_alternative<double>(std::get<0>(tup)));
         CHECK_EQ(tup, std::make_tuple(std::variant<int, double>{5.5}, 6.6));
     }
+    {
+        auto tup = c.convert<void, std::string_view, double,
+                             std::string_view>("junk;s1;6.6;s2", ";");
+        REQUIRE(c.valid());
+        CHECK_EQ(tup, std::make_tuple(std::string_view{"s1"}, 6.6,
+                                      std::string_view{"s2"}));
+    }
 }
 
 TEST_CASE("converter test invalid conversions") {

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);
@@ -146,7 +122,7 @@ TEST_CASE("extract test functions for boolean values") {
         CHECK_EQ(v, b);
     }
 
-    for (const std::string& s : {"2", "tru", "truee", "xxx", ""}) {
+    for (const std::string s : {"2", "tru", "truee", "xxx", ""}) {
         bool v;
         CHECK_FALSE(ss::extract(s.c_str(), s.c_str() + s.size(), v));
     }
@@ -160,7 +136,7 @@ TEST_CASE("extract test functions for char values") {
         CHECK_EQ(v, c);
     }
 
-    for (const std::string& s : {"aa", "xxx", ""}) {
+    for (const std::string s : {"aa", "xxx", ""}) {
         char v;
         CHECK_FALSE(ss::extract(s.c_str(), s.c_str() + s.size(), v));
     }
@@ -187,28 +163,19 @@ TEST_CASE("extract test functions for std::optional") {
         CHECK_EQ(*v, c);
     }
 
-    for (const std::string& s : {"aa", "xxx", ""}) {
+    for (const std::string s : {"aa", "xxx", ""}) {
         std::optional<int> v;
         REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), v));
         CHECK_FALSE(v.has_value());
     }
 
-    for (const std::string& s : {"aa", "xxx", ""}) {
+    for (const std::string s : {"aa", "xxx", ""}) {
         std::optional<char> v;
         REQUIRE(ss::extract(s.c_str(), s.c_str() + s.size(), v));
         CHECK_FALSE(v.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_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

@@ -49,11 +49,16 @@ void update_if_crlf(std::string& s) {
 
 struct X {
     constexpr static auto delim = ",";
+    constexpr static auto make_empty = "_EMPTY_";
     int i;
     double d;
     std::string s;
 
     std::string to_string() const {
+        if (s == make_empty) {
+            return "";
+        }
+
         return std::to_string(i)
             .append(delim)
             .append(std::to_string(d))
@@ -73,7 +78,8 @@ std::enable_if_t<ss::has_m_tied_t<T>, bool> operator==(const T& lhs,
 
 template <typename T>
 static void make_and_write(const std::string& file_name,
-                           const std::vector<T>& data) {
+                           const std::vector<T>& data,
+                           const std::vector<std::string>& header = {}) {
     std::ofstream out{file_name};
 
 #ifdef _WIN32
@@ -82,6 +88,17 @@ static void make_and_write(const std::string& file_name,
     std::vector<const char*> new_lines = {"\n", "\r\n"};
 #endif
 
+    for (const auto& i : header) {
+        if (&i != &header.front()) {
+            out << T::delim;
+        }
+        out << i;
+    }
+
+    if (!header.empty()) {
+        out << new_lines.front();
+    }
+
     for (size_t i = 0; i < data.size(); ++i) {
         out << data[i].to_string() << new_lines[i % new_lines.size()];
     }
@@ -98,40 +115,85 @@ TEST_CASE("parser test various cases") {
         ss::parser<ss::string_error> p{f.name, ","};
         ss::parser p0{std::move(p)};
         p = std::move(p0);
-
         std::vector<X> i;
 
+        ss::parser<ss::string_error> p2{f.name, ","};
+        std::vector<X> i2;
+
         while (!p.eof()) {
             auto a = p.get_next<int, double, std::string>();
             i.emplace_back(ss::to_object<X>(a));
         }
 
+        for (const auto& a : p2.iterate<int, double, std::string>()) {
+            i2.emplace_back(ss::to_object<X>(a));
+        }
+
         CHECK_EQ(i, data);
+        CHECK_EQ(i2, data);
     }
 
     {
         ss::parser p{f.name, ","};
         std::vector<X> i;
+
+        ss::parser p2{f.name, ","};
+        std::vector<X> i2;
+
+        ss::parser p3{f.name, ","};
+        std::vector<X> i3;
+
         std::vector<X> expected = {std::begin(data) + 1, std::end(data)};
+        using tup = std::tuple<int, double, std::string>;
 
         p.ignore_next();
         while (!p.eof()) {
-            using tup = std::tuple<int, double, std::string>;
             auto a = p.get_next<tup>();
             i.emplace_back(ss::to_object<X>(a));
         }
 
+        p2.ignore_next();
+        for (const auto& a : p2.iterate<tup>()) {
+            i2.emplace_back(ss::to_object<X>(a));
+        }
+
+        p3.ignore_next();
+        for (auto it = p3.iterate<tup>().begin(); it != p3.iterate<tup>().end();
+             ++it) {
+            i3.emplace_back(ss::to_object<X>(*it));
+        }
+
         CHECK_EQ(i, expected);
+        CHECK_EQ(i2, expected);
+        CHECK_EQ(i3, expected);
     }
 
     {
         ss::parser p{f.name, ","};
         std::vector<X> i;
+        ss::parser p2{f.name, ","};
+        std::vector<X> i2;
 
         while (!p.eof()) {
             i.push_back(p.get_object<X, int, double, std::string>());
         }
 
+        for (auto&& a : p2.iterate_object<X, int, double, std::string>()) {
+            i2.push_back(std::move(a));
+        }
+
+        CHECK_EQ(i, data);
+        CHECK_EQ(i2, data);
+    }
+
+    {
+        ss::parser p{f.name, ","};
+        std::vector<X> i;
+
+        for (auto&& a : p.iterate_object<X, int, double, std::string>()) {
+            i.push_back(std::move(a));
+        }
+
         CHECK_EQ(i, data);
     }
 
@@ -139,11 +201,32 @@ TEST_CASE("parser test various cases") {
         ss::parser p{f.name, ","};
         std::vector<X> i;
 
+        ss::parser p2{f.name, ","};
+        std::vector<X> i2;
+
+        using tup = std::tuple<int, double, std::string>;
         while (!p.eof()) {
-            using tup = std::tuple<int, double, std::string>;
             i.push_back(p.get_object<X, tup>());
         }
 
+        for (auto it = p2.iterate_object<X, tup>().begin();
+             it != p2.iterate_object<X, tup>().end(); it++) {
+            i2.push_back({it->i, it->d, it->s});
+        }
+
+        CHECK_EQ(i, data);
+        CHECK_EQ(i2, data);
+    }
+
+    {
+        ss::parser p{f.name, ","};
+        std::vector<X> i;
+
+        using tup = std::tuple<int, double, std::string>;
+        for (auto&& a : p.iterate_object<X, tup>()) {
+            i.push_back(std::move(a));
+        }
+
         CHECK_EQ(i, data);
     }
 
@@ -158,11 +241,25 @@ TEST_CASE("parser test various cases") {
         CHECK_EQ(i, data);
     }
 
+    {
+        ss::parser p{f.name, ","};
+        std::vector<X> i;
+
+        for (auto&& a : p.iterate<X>()) {
+            i.push_back(std::move(a));
+        }
+
+        CHECK_EQ(i, data);
+    }
+
     {
         constexpr int excluded = 3;
         ss::parser p{f.name, ","};
         std::vector<X> i;
 
+        ss::parser p2{f.name, ","};
+        std::vector<X> i2;
+
         while (!p.eof()) {
             auto a =
                 p.get_object<X, ss::ax<int, excluded>, double, std::string>();
@@ -171,6 +268,13 @@ TEST_CASE("parser test various cases") {
             }
         }
 
+        for (auto&& a : p2.iterate_object<X, ss::ax<int, excluded>, double,
+                                          std::string>()) {
+            if (p2.valid()) {
+                i2.push_back(std::move(a));
+            }
+        }
+
         std::vector<X> expected;
         for (auto& x : data) {
             if (x.i != excluded) {
@@ -181,34 +285,57 @@ TEST_CASE("parser test various cases") {
         std::copy_if(data.begin(), data.end(), expected.begin(),
                      [](const X& x) { return x.i != excluded; });
         CHECK_EQ(i, expected);
+        CHECK_EQ(i2, expected);
     }
 
     {
         ss::parser p{f.name, ","};
         std::vector<X> i;
 
+        ss::parser p2{f.name, ","};
+        std::vector<X> i2;
+
         while (!p.eof()) {
             auto a = p.get_object<X, ss::nx<int, 3>, double, std::string>();
             if (p.valid()) {
                 i.push_back(a);
             }
         }
+
+        for (auto&& a :
+             p2.iterate_object<X, ss::nx<int, 3>, double, std::string>()) {
+            if (p2.valid()) {
+                i2.push_back(std::move(a));
+            }
+        }
+
         std::vector<X> expected = {{3, 4, "y"}};
         CHECK_EQ(i, expected);
+        CHECK_EQ(i2, expected);
     }
 
     {
         unique_file_name empty_f;
         std::vector<X> empty_data = {};
+
         make_and_write(empty_f.name, empty_data);
 
         ss::parser p{empty_f.name, ","};
         std::vector<X> i;
 
+        ss::parser p2{empty_f.name, ","};
+        std::vector<X> i2;
+
         while (!p.eof()) {
             i.push_back(p.get_next<X>());
         }
+
+        for (auto&& a : p2.iterate<X>()) {
+            i2.push_back(std::move(a));
+        }
+
         CHECK(i.empty());
+        CHECK(i2.empty());
     }
 }
 
@@ -483,8 +610,6 @@ struct xyz {
 };
 
 TEST_CASE("parser test the moving of parsed values") {
-    size_t move_called_one_col;
-
     {
         unique_file_name f;
         {
@@ -494,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);
-        move_called_one_col = move_called;
+        CHECK_LE(move_called, 1);
         move_called = 0;
     }
 
@@ -509,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;
     }
 }
@@ -734,3 +858,280 @@ TEST_CASE("parser test multiline restricted") {
     }
     CHECK_EQ(i, data);
 }
+
+template <typename T, typename Tuple>
+struct has_type;
+
+template <typename T, typename... Us>
+struct has_type<T, std::tuple<Us...>>
+    : std::disjunction<std::is_same<T, Us>...> {};
+
+void checkSize(size_t size1, size_t size2) {
+    CHECK_EQ(size1, size2);
+}
+
+template <typename... Ts>
+void testFields(const std::string file_name, const std::vector<X>& data,
+                const std::vector<std::string>& fields) {
+    using CaseType = std::tuple<Ts...>;
+
+    ss::parser p{file_name, ","};
+    CHECK_FALSE(p.field_exists("Unknown"));
+    p.use_fields(fields);
+    std::vector<CaseType> i;
+
+    for (const auto& a : p.iterate<CaseType>()) {
+        i.push_back(a);
+    }
+
+    checkSize(i.size(), data.size());
+    for (size_t j = 0; j < i.size(); ++j) {
+        if constexpr (has_type<int, CaseType>::value) {
+            CHECK_EQ(std::get<int>(i[j]), data[j].i);
+        }
+        if constexpr (has_type<double, CaseType>::value) {
+            CHECK_EQ(std::get<double>(i[j]), data[j].d);
+        }
+        if constexpr (has_type<std::string, CaseType>::value) {
+            CHECK_EQ(std::get<std::string>(i[j]), data[j].s);
+        }
+    }
+}
+
+TEST_CASE("parser test various cases with header") {
+    unique_file_name f;
+    constexpr static auto Int = "Int";
+    constexpr static auto Dbl = "Double";
+    constexpr static auto Str = "String";
+    using str = std::string;
+
+    std::vector<std::string> header{Int, Dbl, Str};
+
+    std::vector<X> data = {{1, 2, "x"}, {3, 4, "y"},  {5, 6, "z"},
+                           {7, 8, "u"}, {9, 10, "v"}, {11, 12, "w"}};
+
+    make_and_write(f.name, data, header);
+    const auto& o = f.name;
+    const auto& d = data;
+
+    {
+        ss::parser<ss::string_error> p{f.name, ","};
+        std::vector<X> i;
+
+        for (const auto& a : p.iterate<int, double, std::string>()) {
+            i.emplace_back(ss::to_object<X>(a));
+        }
+
+        CHECK_NE(i, data);
+    }
+
+    {
+        ss::parser<ss::string_error> p{f.name, ","};
+        std::vector<X> i;
+
+        p.ignore_next();
+        for (const auto& a : p.iterate<int, double, std::string>()) {
+            i.emplace_back(ss::to_object<X>(a));
+        }
+
+        CHECK_EQ(i, data);
+    }
+
+    {
+        ss::parser<ss::ignore_header> p{f.name, ","};
+        std::vector<X> i;
+
+        for (const auto& a : p.iterate<int, double, std::string>()) {
+            i.emplace_back(ss::to_object<X>(a));
+        }
+
+        CHECK_EQ(i, data);
+    }
+
+    {
+        ss::parser<ss::ignore_header, ss::string_error> p{f.name, ","};
+        p.use_fields(Int, Dbl, Str);
+        CHECK_FALSE(p.valid());
+    }
+
+    {
+        ss::parser<ss::ignore_header, ss::string_error> p{f.name, ","};
+        CHECK_FALSE(p.field_exists("Unknown"));
+
+        p.use_fields(Int, "Unknown");
+        CHECK_FALSE(p.valid());
+    }
+
+    {
+        ss::parser<ss::ignore_header, ss::string_error> p{f.name, ","};
+        p.use_fields(Int, Int);
+        CHECK_FALSE(p.valid());
+    }
+
+    {
+        ss::parser<ss::string_error> p{f.name, ","};
+        p.use_fields(Int, Dbl);
+
+        {
+            auto [int_, double_] = p.get_next<int, double>();
+            CHECK_EQ(int_, data[0].i);
+            CHECK_EQ(double_, data[0].d);
+        }
+
+        p.use_fields(Dbl, Int);
+
+        {
+            auto [double_, int_] = p.get_next<double, int>();
+            CHECK_EQ(int_, data[1].i);
+            CHECK_EQ(double_, data[1].d);
+        }
+
+        p.use_fields(Str);
+
+        {
+            auto string_ = p.get_next<std::string>();
+            CHECK_EQ(string_, data[2].s);
+        }
+
+        p.use_fields(Str, Int, Dbl);
+
+        {
+            auto [string_, int_, double_] =
+                p.get_next<std::string, int, double>();
+            CHECK_EQ(double_, data[3].d);
+            CHECK_EQ(int_, data[3].i);
+            CHECK_EQ(string_, data[3].s);
+        }
+    }
+
+    /*  python used to generate permutations
+        import itertools
+
+        header = {'str': 'Str',
+                 'double': 'Dbl',
+                 'int': 'Int'}
+
+        keys = ['str', 'int', 'double']
+
+        for r in range (1, 3):
+            combinations = list(itertools.permutations(keys, r = r))
+
+            for combination in combinations:
+                template_params = []
+                arg_params = []
+                for type in combination:
+                    template_params.append(type)
+                    arg_params.append(header[type])
+                call = 'testFields<' + ', '.join(template_params) + \
+                    '>(o, d, {' + ', '.join(arg_params) + '});'
+                print(call)
+        */
+
+    testFields<str>(o, d, {Str});
+    testFields<int>(o, d, {Int});
+    testFields<double>(o, d, {Dbl});
+    testFields<str, int>(o, d, {Str, Int});
+    testFields<str, double>(o, d, {Str, Dbl});
+    testFields<int, str>(o, d, {Int, Str});
+    testFields<int, double>(o, d, {Int, Dbl});
+    testFields<double, str>(o, d, {Dbl, Str});
+    testFields<double, int>(o, d, {Dbl, Int});
+    testFields<str, int, double>(o, d, {Str, Int, Dbl});
+    testFields<str, double, int>(o, d, {Str, Dbl, Int});
+    testFields<int, str, double>(o, d, {Int, Str, Dbl});
+    testFields<int, double, str>(o, d, {Int, Dbl, Str});
+    testFields<double, str, int>(o, d, {Dbl, Str, Int});
+    testFields<double, int, str>(o, d, {Dbl, Int, Str});
+}
+
+void testIgnoreEmpty(const std::vector<X>& data) {
+    unique_file_name f;
+    make_and_write(f.name, data);
+
+    std::vector<X> expected;
+    for (const auto& d : data) {
+        if (d.s != X::make_empty) {
+            expected.push_back(d);
+        }
+    }
+
+    {
+        ss::parser<ss::string_error, ss::ignore_empty> p{f.name, ","};
+
+        std::vector<X> i;
+        for (const auto& a : p.iterate<X>()) {
+            i.push_back(a);
+        }
+
+        CHECK_EQ(i, expected);
+    }
+
+    {
+        ss::parser<ss::string_error> p{f.name, ","};
+        std::vector<X> i;
+        size_t n = 0;
+        for (const auto& a : p.iterate<X>()) {
+            if (data.at(n).s == X::make_empty) {
+                CHECK_FALSE(p.valid());
+            }
+            i.push_back(a);
+            ++n;
+        }
+
+        if (data != expected) {
+            CHECK_NE(i, expected);
+        }
+    }
+}
+
+TEST_CASE("parser test various cases with empty lines") {
+    testIgnoreEmpty({{1, 2, "x"}, {3, 4, "y"}, {9, 10, "v"}, {11, 12, "w"}});
+
+    testIgnoreEmpty(
+        {{1, 2, X::make_empty}, {3, 4, "y"}, {9, 10, "v"}, {11, 12, "w"}});
+
+    testIgnoreEmpty(
+        {{1, 2, "x"}, {3, 4, "y"}, {9, 10, "v"}, {11, 12, X::make_empty}});
+
+    testIgnoreEmpty(
+        {{1, 2, "x"}, {5, 6, X::make_empty}, {9, 10, "v"}, {11, 12, "w"}});
+
+    testIgnoreEmpty({{1, 2, X::make_empty},
+                     {5, 6, X::make_empty},
+                     {9, 10, "v"},
+                     {11, 12, "w"}});
+
+    testIgnoreEmpty({{1, 2, X::make_empty},
+                     {3, 4, "y"},
+                     {9, 10, "v"},
+                     {11, 12, X::make_empty}});
+
+    testIgnoreEmpty({{1, 2, "x"},
+                     {3, 4, "y"},
+                     {9, 10, X::make_empty},
+                     {11, 12, X::make_empty}});
+
+    testIgnoreEmpty({{1, 2, X::make_empty},
+                     {3, 4, "y"},
+                     {9, 10, X::make_empty},
+                     {11, 12, X::make_empty}});
+
+    testIgnoreEmpty({{1, 2, X::make_empty},
+                     {3, 4, X::make_empty},
+                     {9, 10, X::make_empty},
+                     {11, 12, X::make_empty}});
+
+    testIgnoreEmpty({{1, 2, "x"},
+                     {3, 4, X::make_empty},
+                     {9, 10, X::make_empty},
+                     {11, 12, X::make_empty}});
+
+    testIgnoreEmpty({{1, 2, X::make_empty},
+                     {3, 4, X::make_empty},
+                     {9, 10, X::make_empty},
+                     {11, 12, "w"}});
+
+    testIgnoreEmpty({{11, 12, X::make_empty}});
+
+    testIgnoreEmpty({});
+}

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