Add extended tests with no new line at eof

Bugfix/header usage on empty file

.github/workflows/coverage.yml

@@ -0,0 +1,74 @@
+name: coverage-ci
+
+on:
+  workflow_dispatch:
+
+  push:
+    branches:
+      - master
+      - feature/**
+      - improvement/**
+      - bugfix/**
+
+  pull_request:
+    branches:
+      - master
+      - feature/**
+      - improvement/**
+      - bugfix/**
+
+jobs:
+  test_coverage:
+    if: >-
+      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
+      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
+
+    runs-on: ubuntu-latest
+
+    name: "Coverage"
+
+    container:
+      image: gcc:latest
+      options: -v /usr/local:/host_usr_local
+
+    steps:
+      - uses: actions/checkout@v1
+
+      - uses: friendlyanon/fetch-core-count@v1
+        id: cores
+
+      - name: CMake
+        run: echo "/host_usr_local/bin" >> $GITHUB_PATH
+
+      - name: Install dependencies
+        run: script/ci_install_deps.sh
+
+      - name: Install test coverage tools
+        run: |
+          apt update
+          apt install -y gcovr
+
+      - name: Install lcov2.0
+        run: script/ci_install_lcov.sh
+
+      - name: Configure
+        run: cmake -S test -B build -D CMAKE_BUILD_TYPE=Debug -D CMAKE_CXX_FLAGS="-Wall -fprofile-arcs -ftest-coverage --coverage -fno-elide-constructors -fno-default-inline"
+
+      - name: Build
+        run: cmake --build build -j ${{steps.cores.outputs.count}}
+
+      - name: Run
+        working-directory: build
+        run: ctest --output-on-failure
+
+      - name: Generate coverage report
+        run: |
+          lcov -d . -c -o out.info --rc branch_coverage=1 --no-external --filter branch --filter line --ignore-errors mismatch
+          lcov -e out.info '*include/ss*hpp' -o filtered.info
+
+      - name: Invoke coveralls
+        uses: coverallsapp/github-action@v2
+        with:
+          github-token: ${{secrets.GITHUB_TOKEN}}
+          file: filtered.info
+          format: lcov

.github/workflows/single-header.yml

@@ -0,0 +1,51 @@
+name: single-header-ci
+
+on:
+  workflow_dispatch:
+
+  push:
+    branches:
+      - master
+      - feature/**
+      - improvement/**
+      - bugfix/**
+
+  pull_request:
+    branches:
+      - master
+      - feature/**
+      - improvement/**
+      - bugfix/**
+
+jobs:
+  single_header_tests:
+    if: >-
+      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
+      ! contains(toJSON(github.event.commits.*.message), '[skip github]')
+
+    runs-on: ubuntu-latest
+
+    name: "Single Header Test"
+
+    container:
+      image: gcc:latest
+      options: -v /usr/local:/host_usr_local
+
+    steps:
+      - uses: actions/checkout@v1
+
+      - uses: friendlyanon/fetch-core-count@v1
+        id: cores
+
+      - name: Install dependencies
+        run: |
+          apt-get update
+          apt-get install -y git
+
+      - name: Single header update check
+        run: |
+          script/single_header_generator.py > tmp.hpp
+          diff ssp.hpp tmp.hpp
+
+      - name: Single header compile check
+        run: ./test/test_single_header.sh

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

@@ -1,6 +1,8 @@
 name: ubuntu-latest-clang-ci
 
 on:
+  workflow_dispatch:
+
   push:
     branches:
       - master
@@ -23,20 +25,22 @@ jobs:
 
     strategy:
       matrix:
-        version: [11, 10, 9, 8, 7]
+        # cmake clang12 is not able to compile a simple test program.
+        # /usr/bin/ld: cannot find -lunwind
+        version: ['latest', '15', '14', '13', '11', '10', '9', '8', '7']
+        type: [Release, Debug]
 
     runs-on: ubuntu-latest
 
-    name: Clang ${{ matrix.version }}
+    name: "Clang ${{matrix.version}}: ${{matrix.type}}"
 
     container:
-      image: teeks99/clang-ubuntu:${{ matrix.version }}
-
+      image: silkeh/clang:${{matrix.version}}
       options: -v /usr/local:/host_usr_local
 
     env:
-      CC: clang-${{ matrix.version }}
-      CXX: clang++-${{ matrix.version }}
+      CC: clang
+      CXX: clang++
       CXXFLAGS: -stdlib=libc++
 
     steps:
@@ -55,11 +59,11 @@ jobs:
           script/ci_install_deps.sh
 
       - name: Configure
-        run: cmake -S test -B build -D CMAKE_BUILD_TYPE=Debug
+        run: cmake -S test -B build -DCMAKE_BUILD_TYPE=${{matrix.type}}
 
       - name: Build
-        run: cmake --build build -j ${{ steps.cores.outputs.count }}
+        run: cmake --build build -j ${{steps.cores.outputs.count}}
 
       - name: Run
         working-directory: build
-        run: ctest --output-on-failure -j ${{ steps.cores.outputs.count }}
+        run: ctest --output-on-failure

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

@@ -1,6 +1,8 @@
 name: ubuntu-latest-gcc-ci
 
 on:
+  workflow_dispatch:
+
   push:
     branches:
       - master
@@ -23,15 +25,15 @@ jobs:
 
     strategy:
       matrix:
-        version: [10, 9, 8]
+        version: ['latest', '12', '11', '10', '9', '8']
+        type: [Release, Debug]
 
     runs-on: ubuntu-latest
 
-    name: GCC ${{ matrix.version }}
+    name: "GCC ${{matrix.version}}: ${{matrix.type}}"
 
     container:
-      image: gcc:${{ matrix.version }}
-
+      image: gcc:${{matrix.version}}
       options: -v /usr/local:/host_usr_local
 
     steps:
@@ -47,11 +49,11 @@ jobs:
         run: script/ci_install_deps.sh
 
       - name: Configure
-        run: cmake -S test -B build -D CMAKE_BUILD_TYPE=Debug
+        run: cmake -S test -B build -D CMAKE_BUILD_TYPE=${{matrix.type}}
 
       - name: Build
-        run: cmake --build build -j ${{ steps.cores.outputs.count }}
+        run: cmake --build build -j ${{steps.cores.outputs.count}}
 
       - name: Run
         working-directory: build
-        run: ctest --output-on-failure -j ${{ steps.cores.outputs.count }}
+        run: ctest --output-on-failure

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

@@ -1,6 +1,8 @@
 name: ubuntu-latest-icc-ci
 
 on:
+  workflow_dispatch:
+
   push:
     branches:
       - master
@@ -17,7 +19,7 @@ on:
 
 env:
   LINUX_BASEKIT_URL: https://registrationcenter-download.intel.com/akdlm/irc_nas/17431/l_BaseKit_p_2021.1.0.2659_offline.sh
-  LINUX_HPCKIT_URL: 
+  LINUX_HPCKIT_URL:
     https://registrationcenter-download.intel.com/akdlm/irc_nas/17427/l_HPCKit_p_2021.1.0.2684_offline.sh
 
 jobs:
@@ -27,6 +29,7 @@ jobs:
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
 
     runs-on: ubuntu-latest
+
     defaults:
       run:
         shell: bash
@@ -36,38 +39,39 @@ jobs:
       options: -v /usr/local:/host_usr_local
 
     steps:
-    - uses: actions/checkout@v2
+      - uses: actions/checkout@v2
 
-    - name: cache install
-      id: cache-install
-      uses: actions/cache@v2
-      with:
-        path: |
-          /opt/intel/oneapi/compiler
-        key: >-
-          install-${{ env.LINUX_HPCKIT_URL }}-
-          ${{ env.LINUX_CPP_COMPONENTS_WEB }}-
-          compiler-${{ hashFiles('**/scripts/cache_exclude_linux.sh') }}
+      - name: cache install
+        id: cache-install
+        uses: actions/cache@v2
+        with:
+          path: |
+            /opt/intel/oneapi/compiler
+          key: >-
+            install-${{env.LINUX_HPCKIT_URL}}-
+            ${{env.LINUX_CPP_COMPONENTS_WEB}}-
+            compiler-${{hashFiles('**/scripts/cache_exclude_linux.sh')}}
 
-    - name: Install icc
-      run: script/ci_install_icc.sh $LINUX_HPCKIT_URL $LINUX_CPP_COMPONENTS_WEB
+      - name: Install icc
+        run: >-
+          script/ci_install_icc.sh $LINUX_HPCKIT_URL $LINUX_CPP_COMPONENTS_WEB
 
-    - name: CMake
-      run: echo "/host_usr_local/bin" >> $GITHUB_PATH
+      - name: CMake
+        run: echo "/host_usr_local/bin" >> $GITHUB_PATH
 
-    - name: Install dependencies
-      run: script/ci_install_deps.sh
+      - name: Install dependencies
+        run: script/ci_install_deps.sh
 
-    - name: Configure
-      run: >-
-        source script/ci_setup_icc.sh &&
-        cmake -S test -B build -D CMAKE_BUILD_TYPE=Debug
+      - name: Configure
+        run: >-
+          source script/ci_setup_icc.sh &&
+          cmake -S test -B build -D CMAKE_BUILD_TYPE=Debug
 
-    - name: Build
-      run: >-
-        source script/ci_setup_icc.sh &&
-        cmake --build build -j ${{ steps.cores.outputs.count }}
+      - name: Build
+        run: >-
+          source script/ci_setup_icc.sh &&
+          cmake --build build -j ${{steps.cores.outputs.count}}
 
-    - name: Run
-      working-directory: build
-      run: ctest --output-on-failure -j ${{ steps.cores.outputs.count }}
+      - name: Run
+        working-directory: build
+        run: ctest --output-on-failure

.github/workflows/win-msvc.yml

@@ -1,6 +1,8 @@
 name: win-msvc-ci
 
 on:
+  workflow_dispatch:
+
   push:
     branches:
       - master
@@ -25,8 +27,6 @@ jobs:
       run:
         shell: bash
 
-    runs-on: ${{ matrix.config.os }}
-
     strategy:
       fail-fast: false
       matrix:
@@ -40,7 +40,9 @@ jobs:
         build: [Debug, Release]
         platform: [Win32, x64]
 
-    name: "${{matrix.config.vs}}:${{matrix.platform}}:${{matrix.build}}"
+    runs-on: ${{matrix.config.os}}
+
+    name: "${{matrix.config.vs}}: ${{matrix.platform}}: ${{matrix.build}}"
 
     steps:
       - name: checkout
@@ -60,4 +62,4 @@ jobs:
       - name: Run
         working-directory: build
         run: >-
-          ctest -C Debug --output-on-failure -j ${{steps.cores.outputs.count}}
+          ctest -C Debug --output-on-failure

.github/workflows/win-msys2-clang.yml

@@ -1,6 +1,8 @@
 name: win-msys2-clang-ci
 
 on:
+  workflow_dispatch:
+
   push:
     branches:
       - master
@@ -21,57 +23,54 @@ jobs:
       ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
 
-    name: ${{ matrix.msystem }}
-    runs-on: windows-latest
     defaults:
       run:
         shell: msys2 {0}
+
     strategy:
       fail-fast: false
+
       matrix:
-        include:
+        os: [windows-2019, windows-latest]
+        type: [Release, Debug]
+        config:
           - msystem: "MINGW64"
             install: >-
-              git mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja 
+              git mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja
               mingw-w64-x86_64-clang
-            type: Release
+
           - msystem: "MINGW32"
             install: >-
-              git mingw-w64-i686-cmake mingw-w64-i686-ninja 
+              git mingw-w64-i686-cmake mingw-w64-i686-ninja
               mingw-w64-i686-clang
-            type: Release
-          - msystem: "MINGW64"
-            install: >- 
-              git mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja 
-              mingw-w64-x86_64-clang
-            type: Debug
-          - msystem: "MINGW32"
-            install: >-
-              git mingw-w64-i686-cmake mingw-w64-i686-ninja 
-              mingw-w64-i686-clang
-            type: Debug
+
+    runs-on: ${{matrix.os}}
+
+    name: "${{matrix.config.msystem}}: ${{matrix.os}}: ${{matrix.type}}"
+
     env:
       CMAKE_GENERATOR: Ninja
 
     steps:
       - uses: actions/checkout@v2
+
       - uses: msys2/setup-msys2@v2
         with:
           update: true
-          msystem: ${{ matrix.msystem }}
-          install: ${{ matrix.install }}
+          msystem: ${{matrix.config.msystem}}
+          install: ${{matrix.config.install}}
 
       - name: Install dependencies
         run: script/ci_install_deps.sh
 
       - name: Configure
-        run: >- 
-          cmake -DCMAKE_CXX_COMPILER=clang++ -S test -B build 
-          -DCMAKE_BUILD_TYPE=Debug
+        run: >-
+          cmake -DCMAKE_CXX_COMPILER=clang++ -S test -B build
+          -DCMAKE_BUILD_TYPE=${{matrix.type}}
 
       - name: Build
-        run: cmake --build build -j ${{ steps.cores.outputs.count }}
+        run: cmake --build build -j ${{steps.cores.outputs.count}}
 
       - name: Run
         working-directory: build
-        run: ctest --output-on-failure -j ${{ steps.cores.outputs.count }}
+        run: ctest --output-on-failure

.github/workflows/win-msys2-gcc.yml

@@ -1,6 +1,8 @@
 name: win-msys2-gcc-ci
 
 on:
+  workflow_dispatch:
+
   push:
     branches:
       - master
@@ -21,55 +23,52 @@ jobs:
       ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
       ! contains(toJSON(github.event.commits.*.message), '[skip github]')
 
-    name: ${{ matrix.msystem }}
-    runs-on: windows-latest
     defaults:
       run:
         shell: msys2 {0}
+
     strategy:
       fail-fast: false
+
       matrix:
-        include:
+        os: [windows-2019, windows-latest]
+        type: [Release, Debug]
+        config:
           - msystem: "MINGW64"
             install: >-
-              git mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja 
+              git mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja
               mingw-w64-x86_64-gcc
-            type: Release
-          - msystem: "MINGW32"
-            install: >- 
-              git mingw-w64-i686-cmake mingw-w64-i686-ninja 
-              mingw-w64-i686-gcc
-            type: Release
-          - msystem: "MINGW64"
-            install: >- 
-              git mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja 
-              mingw-w64-x86_64-gcc
-            type: Debug
+
           - msystem: "MINGW32"
             install: >-
-              git mingw-w64-i686-cmake mingw-w64-i686-ninja 
+              git mingw-w64-i686-cmake mingw-w64-i686-ninja
               mingw-w64-i686-gcc
-            type: Debug
+
+    runs-on: ${{matrix.os}}
+
+    name: "${{matrix.config.msystem}}: ${{matrix.os}}: ${{matrix.type}}"
+
     env:
       CMAKE_GENERATOR: Ninja
 
     steps:
       - uses: actions/checkout@v2
+
       - uses: msys2/setup-msys2@v2
         with:
           update: true
-          msystem: ${{ matrix.msystem }}
-          install: ${{ matrix.install }}
+          msystem: ${{matrix.config.msystem}}
+          install: ${{matrix.config.install}}
 
       - name: Install dependencies
         run: script/ci_install_deps.sh
 
       - name: Configure
-        run: cmake -S test -B build -D CMAKE_BUILD_TYPE=Debug
+        run: cmake -S test -B build -D CMAKE_BUILD_TYPE=${{matrix.type}}
 
       - name: Build
-        run: cmake --build build -j ${{ steps.cores.outputs.count }}
+        run: cmake --build build -j ${{steps.cores.outputs.count}}
 
       - name: Run
         working-directory: build
-        run: ctest --output-on-failure -j ${{ steps.cores.outputs.count }}
+        run: ctest --output-on-failure

.gitignore

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

CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.14)
 
 project(
     ssp
-    VERSION 1.5.0
+    VERSION 1.6.2
     DESCRIPTION "csv parser"
     HOMEPAGE_URL "https://github.com/red0124/ssp"
     LANGUAGES CXX

README.md

@@ -8,12 +8,14 @@
 ```
 
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![coverage](https://coveralls.io/repos/github/red0124/ssp/badge.svg?branch=master)](https://coveralls.io/github/red0124/ssp?branch=master)
+[![single-header](https://github.com/red0124/ssp/workflows/single-header-ci/badge.svg)](https://github.com/red0124/ssp/actions/workflows/single-header.yml)
 [![ubuntu-latest-gcc](https://github.com/red0124/ssp/workflows/ubuntu-latest-gcc-ci/badge.svg)](https://github.com/red0124/ssp/actions/workflows/ubuntu-latest-gcc.yml)
 [![ubuntu-latest-clang](https://github.com/red0124/ssp/workflows/ubuntu-latest-clang-ci/badge.svg)](https://github.com/red0124/ssp/actions/workflows/ubuntu-latest-clang.yml)
 [![ubuntu-latest-icc](https://github.com/red0124/ssp/workflows/ubuntu-latest-icc-ci/badge.svg)](https://github.com/red0124/ssp/actions/workflows/ubuntu-latest-icc.yml)
 [![windows-msys2-gcc](https://github.com/red0124/ssp/workflows/win-msys2-gcc-ci/badge.svg)](https://github.com/red0124/ssp/actions/workflows/win-msys2-gcc.yml)
 [![windows-msys2-clang](https://github.com/red0124/ssp/workflows/win-msys2-clang-ci/badge.svg)](https://github.com/red0124/ssp/actions/workflows/win-msys2-clang.yml)
-[![win-msvc-ci](https://github.com/red0124/ssp/workflows/win-msvc-ci/badge.svg)](https://github.com/red0124/ssp/actions/workflows/win-msvc.yml)
+[![windows-msvc](https://github.com/red0124/ssp/workflows/win-msvc-ci/badge.svg)](https://github.com/red0124/ssp/actions/workflows/win-msvc.yml)
 
 A header only "csv" parser which is fast and versatile with modern C++ api. Requires compiler with C++17 support. [Can also be used to convert strings to specific types.](#the-converter)
 

include/ss/common.hpp

@@ -12,6 +12,7 @@ using string_range = std::pair<const char*, const char*>;
 using split_data = std::vector<string_range>;
 
 constexpr inline auto default_delimiter = ",";
+constexpr inline auto get_line_initial_buffer_size = 128;
 
 template <bool StringError>
 inline void assert_string_error_defined() {
@@ -26,12 +27,13 @@ inline void assert_throw_on_error_not_defined() {
 }
 
 #if __unix__
-inline ssize_t get_line(char** lineptr, size_t* n, FILE* stream) {
+inline ssize_t get_line_file(char** lineptr, size_t* n, FILE* stream) {
     return getline(lineptr, n, stream);
 }
 #else
+
 using ssize_t = int64_t;
-inline ssize_t get_line(char** lineptr, size_t* n, FILE* stream) {
+inline ssize_t get_line_file(char** lineptr, size_t* n, FILE* stream) {
     size_t pos;
     int c;
 
@@ -46,7 +48,7 @@ inline ssize_t get_line(char** lineptr, size_t* n, FILE* stream) {
     }
 
     if (*lineptr == nullptr) {
-        *lineptr = static_cast<char*>(malloc(128));
+        *lineptr = static_cast<char*>(malloc(get_line_initial_buffer_size));
         if (*lineptr == nullptr) {
             return -1;
         }
@@ -57,8 +59,8 @@ inline ssize_t get_line(char** lineptr, size_t* n, FILE* stream) {
     while (c != EOF) {
         if (pos + 1 >= *n) {
             size_t new_size = *n + (*n >> 2);
-            if (new_size < 128) {
-                new_size = 128;
+            if (new_size < get_line_initial_buffer_size) {
+                new_size = get_line_initial_buffer_size;
             }
             char* new_ptr = static_cast<char*>(
                 realloc(static_cast<void*>(*lineptr), new_size));

include/ss/converter.hpp

@@ -379,7 +379,6 @@ private:
         return extract_tuple<Ts...>(elems);
     }
 
-    // do not know how to specialize by return type :(
     template <typename... Ts>
     no_void_validator_tup_t<std::tuple<Ts...>> convert_impl(
         const split_data& elems, const std::tuple<Ts...>*) {

include/ss/extract.hpp

@@ -1,13 +1,13 @@
 #pragma once
 
 #include "type_traits.hpp"
+#include <charconv>
 #include <cstring>
 #include <functional>
 #include <optional>
 #include <string>
 #include <string_view>
 #include <variant>
-#include <charconv>
 
 #ifndef SSP_DISABLE_FAST_FLOAT
 #include <fast_float/fast_float.h>
@@ -16,7 +16,6 @@
 #include <cstdlib>
 #endif
 
-// TODO try from_chars for integer conversions
 namespace ss {
 
 ////////////////
@@ -42,17 +41,24 @@ std::enable_if_t<std::is_floating_point_v<T>, std::optional<T>> to_num(
 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) {
+    static_assert(!std::is_same_v<T, long double>,
+                  "Conversion to long double is disabled");
+
     constexpr static auto buff_max = 64;
-    char buff[buff_max];
+    char short_buff[buff_max];
     size_t string_range = std::distance(begin, end);
+    std::string long_buff;
 
+    char* buff;
     if (string_range > buff_max) {
-        return std::nullopt;
+        long_buff = std::string{begin, end};
+        buff = long_buff.data();
+    } else {
+        buff = short_buff;
+        buff[string_range] = '\0';
+        std::copy_n(begin, string_range, buff);
     }
 
-    std::copy_n(begin, string_range, buff);
-    buff[string_range] = '\0';
-
     T ret;
     char* parse_end = nullptr;
 
@@ -60,8 +66,6 @@ std::enable_if_t<std::is_floating_point_v<T>, std::optional<T>> to_num(
         ret = std::strtof(buff, &parse_end);
     } else if constexpr (std::is_same_v<T, double>) {
         ret = std::strtod(buff, &parse_end);
-    } else if constexpr (std::is_same_v<T, long double>) {
-        ret = std::strtold(buff, &parse_end);
     }
 
     if (parse_end != buff + string_range) {

include/ss/parser.hpp

@@ -1,11 +1,11 @@
 #pragma once
 
-// TODO add single header tests
 #include "common.hpp"
 #include "converter.hpp"
 #include "exception.hpp"
 #include "extract.hpp"
 #include "restrictions.hpp"
+#include <cerrno>
 #include <cstdlib>
 #include <cstring>
 #include <optional>
@@ -49,6 +49,23 @@ public:
         }
     }
 
+    parser(const char* const csv_data_buffer, size_t csv_data_size,
+           const std::string& delim = ss::default_delimiter)
+        : file_name_{"buffer line"},
+          reader_{csv_data_buffer, csv_data_size, delim} {
+        if (csv_data_buffer) {
+            read_line();
+            if constexpr (ignore_header) {
+                ignore_next();
+            } else {
+                raw_header_ = reader_.get_buffer();
+            }
+        } else {
+            handle_error_null_buffer();
+            eof_ = true;
+        }
+    }
+
     parser(parser&& other) = default;
     parser& operator=(parser&& other) = default;
 
@@ -156,7 +173,7 @@ public:
             return;
         }
 
-        if (header_.empty()) {
+        if (header_.empty() && !eof()) {
             split_header_data();
         }
 
@@ -352,20 +369,22 @@ public:
 
         template <typename U, typename... Us, typename Fun = none>
         void try_convert_and_invoke(std::optional<U>& value, Fun&& fun) {
-            if (!parser_.valid()) {
-                auto tuple_output = try_same<Us...>();
-                if (!parser_.valid()) {
-                    return;
-                }
-
-                if constexpr (!std::is_same_v<U, decltype(tuple_output)>) {
-                    value = to_object<U>(std::move(tuple_output));
-                } else {
-                    value = std::move(tuple_output);
-                }
-
-                parser_.try_invoke(*value, std::forward<Fun>(fun));
+            if (parser_.valid()) {
+                return;
             }
+
+            auto tuple_output = try_same<Us...>();
+            if (!parser_.valid()) {
+                return;
+            }
+
+            if constexpr (!std::is_same_v<U, decltype(tuple_output)>) {
+                value = to_object<U>(std::move(tuple_output));
+            } else {
+                value = std::move(tuple_output);
+            }
+
+            parser_.try_invoke(*value, std::forward<Fun>(fun));
         }
 
         template <typename U, typename... Us>
@@ -513,6 +532,19 @@ private:
         }
     }
 
+    void handle_error_null_buffer() {
+        constexpr static auto error_msg = " received null data buffer";
+
+        if constexpr (string_error) {
+            error_.clear();
+            error_.append(file_name_).append(error_msg);
+        } else if constexpr (throw_on_error) {
+            throw ss::exception{file_name_ + error_msg};
+        } else {
+            error_ = true;
+        }
+    }
+
     void handle_error_file_not_open() {
         constexpr static auto error_msg = " could not be opened";
 
@@ -642,18 +674,27 @@ private:
             : delim_{delim}, file_{fopen(file_name_.c_str(), "rb")} {
         }
 
+        reader(const char* const buffer, size_t csv_data_size,
+               const std::string& delim)
+            : delim_{delim}, csv_data_buffer_{buffer},
+              csv_data_size_{csv_data_size} {
+        }
+
         reader(reader&& other)
             : buffer_{other.buffer_},
               next_line_buffer_{other.next_line_buffer_},
-              helper_buffer_{other.helper_buffer_}, converter_{std::move(
-                                                        other.converter_)},
+              helper_buffer_{other.helper_buffer_},
+              converter_{std::move(other.converter_)},
               next_line_converter_{std::move(other.next_line_converter_)},
               buffer_size_{other.buffer_size_},
               next_line_buffer_size_{other.next_line_buffer_size_},
-              helper_size_{other.helper_size_}, delim_{std::move(other.delim_)},
-              file_{other.file_}, crlf_{other.crlf_},
-              line_number_{other.line_number_}, next_line_size_{
-                                                    other.next_line_size_} {
+              helper_buffer_size{other.helper_buffer_size},
+              delim_{std::move(other.delim_)}, file_{other.file_},
+              csv_data_buffer_{other.csv_data_buffer_},
+              csv_data_size_{other.csv_data_size_},
+              curr_char_{other.curr_char_}, crlf_{other.crlf_},
+              line_number_{other.line_number_},
+              next_line_size_{other.next_line_size_} {
             other.buffer_ = nullptr;
             other.next_line_buffer_ = nullptr;
             other.helper_buffer_ = nullptr;
@@ -669,9 +710,12 @@ private:
                 next_line_converter_ = std::move(other.next_line_converter_);
                 buffer_size_ = other.buffer_size_;
                 next_line_buffer_size_ = other.next_line_buffer_size_;
-                helper_size_ = other.helper_size_;
+                helper_buffer_size = other.helper_buffer_size;
                 delim_ = std::move(other.delim_);
                 file_ = other.file_;
+                csv_data_buffer_ = other.csv_data_buffer_;
+                csv_data_size_ = other.csv_data_size_;
+                curr_char_ = other.curr_char_;
                 crlf_ = other.crlf_;
                 line_number_ = other.line_number_;
                 next_line_size_ = other.next_line_size_;
@@ -699,6 +743,53 @@ private:
         reader(const reader& other) = delete;
         reader& operator=(const reader& other) = delete;
 
+        ssize_t get_line_buffer(char** lineptr, size_t* n,
+                                const char* const buffer, size_t csv_data_size,
+                                size_t& curr_char) {
+            size_t pos;
+            int c;
+
+            if (curr_char >= csv_data_size) {
+                return -1;
+            }
+            c = buffer[curr_char++];
+
+            if (*lineptr == nullptr) {
+                *lineptr =
+                    static_cast<char*>(malloc(get_line_initial_buffer_size));
+                if (*lineptr == nullptr) {
+                    return -1;
+                }
+                *n = 128;
+            }
+
+            pos = 0;
+            while (curr_char <= csv_data_size) {
+                if (pos + 1 >= *n) {
+                    size_t new_size = *n + (*n >> 2);
+                    if (new_size < get_line_initial_buffer_size) {
+                        new_size = get_line_initial_buffer_size;
+                    }
+                    char* new_ptr = static_cast<char*>(
+                        realloc(static_cast<void*>(*lineptr), new_size));
+                    if (new_ptr == nullptr) {
+                        return -1;
+                    }
+                    *n = new_size;
+                    *lineptr = new_ptr;
+                }
+
+                (*lineptr)[pos++] = c;
+                if (c == '\n') {
+                    break;
+                }
+                c = buffer[curr_char++];
+            }
+
+            (*lineptr)[pos] = '\0';
+            return pos;
+        }
+
         // read next line each time in order to set eof_
         bool read_next() {
             next_line_converter_.clear_error();
@@ -709,10 +800,21 @@ private:
                 if (next_line_buffer_size_ > 0) {
                     next_line_buffer_[0] = '\0';
                 }
-                ssize = get_line(&next_line_buffer_, &next_line_buffer_size_,
-                                 file_);
+
+                if (file_) {
+                    ssize = get_line_file(&next_line_buffer_,
+                                          &next_line_buffer_size_, file_);
+                } else {
+                    ssize = get_line_buffer(&next_line_buffer_,
+                                            &next_line_buffer_size_,
+                                            csv_data_buffer_, csv_data_size_,
+                                            curr_char_);
+                }
 
                 if (ssize == -1) {
+                    if (errno == ENOMEM) {
+                        throw std::bad_alloc{};
+                    }
                     return false;
                 }
 
@@ -822,6 +924,10 @@ private:
         }
 
         size_t remove_eol(char*& buffer, size_t ssize) {
+            if (buffer[ssize - 1] != '\n') {
+                return ssize;
+            }
+
             size_t size = ssize - 1;
             if (ssize >= 2 && buffer[ssize - 2] == '\r') {
                 crlf_ = true;
@@ -835,12 +941,12 @@ private:
         }
 
         void realloc_concat(char*& first, size_t& first_size,
-                            const char* const second, size_t second_size) {
-            // TODO make buffer_size an argument
-            next_line_buffer_size_ = first_size + second_size + 3;
+                            size_t& buffer_size, const char* const second,
+                            size_t second_size) {
+            buffer_size = first_size + second_size + 3;
             auto new_first = static_cast<char*>(
-                realloc(static_cast<void*>(first), next_line_buffer_size_));
-            if (!first) {
+                realloc(static_cast<void*>(first), buffer_size));
+            if (!new_first) {
                 throw std::bad_alloc{};
             }
 
@@ -852,15 +958,25 @@ private:
         bool append_next_line_to_buffer(char*& buffer, size_t& size) {
             undo_remove_eol(buffer, size);
 
-            ssize_t next_ssize =
-                get_line(&helper_buffer_, &helper_size_, file_);
+            ssize_t next_ssize;
+            if (file_) {
+                next_ssize =
+                    get_line_file(&helper_buffer_, &helper_buffer_size, file_);
+            } else {
+                next_ssize =
+                    get_line_buffer(&helper_buffer_, &helper_buffer_size,
+                                    csv_data_buffer_, csv_data_size_,
+                                    curr_char_);
+            }
+
             if (next_ssize == -1) {
                 return false;
             }
 
             ++line_number_;
             size_t next_size = remove_eol(helper_buffer_, next_ssize);
-            realloc_concat(buffer, size, helper_buffer_, next_size);
+            realloc_concat(buffer, size, next_line_buffer_size_, helper_buffer_,
+                           next_size);
             return true;
         }
 
@@ -880,11 +996,15 @@ private:
 
         size_t buffer_size_{0};
         size_t next_line_buffer_size_{0};
-        size_t helper_size_{0};
+        size_t helper_buffer_size{0};
 
         std::string delim_;
         FILE* file_{nullptr};
 
+        const char* csv_data_buffer_{nullptr};
+        size_t csv_data_size_{0};
+        size_t curr_char_{0};
+
         bool crlf_{false};
         size_t line_number_{0};
 

include/ss/setup.hpp

@@ -109,7 +109,7 @@ 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 cannot"
+                  "the same matcher cannot "
                   "be defined multiple times");
     using type = std::conditional_t<is_matcher<T>::value, T,
                                     typename get_matcher<Matcher, Ts...>::type>;

meson.build

@@ -6,7 +6,7 @@ project(
       'cpp_std=c++17', 
       'buildtype=debugoptimized',
       'wrap_mode=forcefallback'],
-  version: '1.5.0',
+  version: '1.6.2',
   meson_version:'>=0.54.0')
 
 fast_float_dep = dependency('fast_float')

script/ci_install_lcov.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env sh
+
+echo yes | cpan DateTime Capture::Tiny
+
+wget -qO- https://github.com/linux-test-project/lcov/releases/download/v2.0/lcov-2.0.tar.gz | tar xvz
+(cd lcov-2.0 && make install)

ssp.hpp

@@ -1,12 +1,13 @@
 #include <algorithm>
 #include <array>
+#include <cerrno>
+#include <charconv>
 #include <cstdint>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <exception>
 #include <functional>
-#include <limits>
 #include <memory>
 #include <optional>
 #include <string>
@@ -625,6 +626,7 @@ using string_range = std::pair<const char*, const char*>;
 using split_data = std::vector<string_range>;
 
 constexpr inline auto default_delimiter = ",";
+constexpr inline auto get_line_initial_buffer_size = 128;
 
 template <bool StringError>
 inline void assert_string_error_defined() {
@@ -639,12 +641,13 @@ inline void assert_throw_on_error_not_defined() {
 }
 
 #if __unix__
-inline ssize_t get_line(char** lineptr, size_t* n, FILE* stream) {
+inline ssize_t get_line_file(char** lineptr, size_t* n, FILE* stream) {
     return getline(lineptr, n, stream);
 }
 #else
+
 using ssize_t = int64_t;
-inline ssize_t get_line(char** lineptr, size_t* n, FILE* stream) {
+inline ssize_t get_line_file(char** lineptr, size_t* n, FILE* stream) {
     size_t pos;
     int c;
 
@@ -659,7 +662,7 @@ inline ssize_t get_line(char** lineptr, size_t* n, FILE* stream) {
     }
 
     if (*lineptr == nullptr) {
-        *lineptr = static_cast<char*>(malloc(128));
+        *lineptr = static_cast<char*>(malloc(get_line_initial_buffer_size));
         if (*lineptr == nullptr) {
             return -1;
         }
@@ -670,8 +673,8 @@ inline ssize_t get_line(char** lineptr, size_t* n, FILE* stream) {
     while (c != EOF) {
         if (pos + 1 >= *n) {
             size_t new_size = *n + (*n >> 2);
-            if (new_size < 128) {
-                new_size = 128;
+            if (new_size < get_line_initial_buffer_size) {
+                new_size = get_line_initial_buffer_size;
             }
             char* new_ptr = static_cast<char*>(
                 realloc(static_cast<void*>(*lineptr), new_size));
@@ -803,7 +806,7 @@ 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 cannot"
+                  "the same matcher cannot "
                   "be defined multiple times");
     using type = std::conditional_t<is_matcher<T>::value, T,
                                     typename get_matcher<Matcher, Ts...>::type>;
@@ -1465,7 +1468,6 @@ public:
 #else
 #endif
 
-// TODO try from_chars for integer conversions
 namespace ss {
 
 ////////////////
@@ -1491,17 +1493,24 @@ std::enable_if_t<std::is_floating_point_v<T>, std::optional<T>> to_num(
 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) {
+    static_assert(!std::is_same_v<T, long double>,
+                  "Conversion to long double is disabled");
+
     constexpr static auto buff_max = 64;
-    char buff[buff_max];
+    char short_buff[buff_max];
     size_t string_range = std::distance(begin, end);
+    std::string long_buff;
 
+    char* buff;
     if (string_range > buff_max) {
-        return std::nullopt;
+        long_buff = std::string{begin, end};
+        buff = long_buff.data();
+    } else {
+        buff = short_buff;
+        buff[string_range] = '\0';
+        std::copy_n(begin, string_range, buff);
     }
 
-    std::copy_n(begin, string_range, buff);
-    buff[string_range] = '\0';
-
     T ret;
     char* parse_end = nullptr;
 
@@ -1509,8 +1518,6 @@ std::enable_if_t<std::is_floating_point_v<T>, std::optional<T>> to_num(
         ret = std::strtof(buff, &parse_end);
     } else if constexpr (std::is_same_v<T, double>) {
         ret = std::strtod(buff, &parse_end);
-    } else if constexpr (std::is_same_v<T, long double>) {
-        ret = std::strtold(buff, &parse_end);
     }
 
     if (parse_end != buff + string_range) {
@@ -1522,195 +1529,16 @@ std::enable_if_t<std::is_floating_point_v<T>, std::optional<T>> to_num(
 
 #endif
 
-inline std::optional<short> from_char(char c) {
-    if (c >= '0' && c <= '9') {
-        return c - '0';
-    }
-    return std::nullopt;
-}
-
-#if defined(__clang__) && defined(__MINGW32__) && !defined(__MINGW64__)
-#define MINGW32_CLANG
-#endif
-
-// mingw32 clang does not support some of the builtin functions
-#if (defined(__clang__) || defined(__GNUC__) || defined(__GUNG__)) &&          \
-    !defined(MINGW32_CLANG)
-////////////////
-// mul overflow detection
-////////////////
-template <typename T>
-bool mul_overflow(T& result, T operand) {
-    return __builtin_mul_overflow(result, operand, &result);
-}
-
-template <>
-inline bool mul_overflow(int& result, int operand) {
-    return __builtin_smul_overflow(result, operand, &result);
-}
-
-template <>
-inline bool mul_overflow(long& result, long operand) {
-    return __builtin_smull_overflow(result, operand, &result);
-}
-
-template <>
-inline bool mul_overflow(long long& result, long long operand) {
-    return __builtin_smulll_overflow(result, operand, &result);
-}
-
-template <>
-inline bool mul_overflow(unsigned int& result, unsigned int operand) {
-    return __builtin_umul_overflow(result, operand, &result);
-}
-
-template <>
-inline bool mul_overflow(unsigned long& result, unsigned long operand) {
-    return __builtin_umull_overflow(result, operand, &result);
-}
-
-template <>
-inline bool mul_overflow(unsigned long long& result,
-                         unsigned long long operand) {
-    return __builtin_umulll_overflow(result, operand, &result);
-}
-
-////////////////
-// addition overflow detection
-////////////////
-
-template <typename T>
-inline bool add_overflow(T& result, T operand) {
-    return __builtin_add_overflow(result, operand, &result);
-}
-
-template <>
-inline bool add_overflow(int& result, int operand) {
-    return __builtin_sadd_overflow(result, operand, &result);
-}
-
-template <>
-inline bool add_overflow(long& result, long operand) {
-    return __builtin_saddl_overflow(result, operand, &result);
-}
-
-template <>
-inline bool add_overflow(long long& result, long long operand) {
-    return __builtin_saddll_overflow(result, operand, &result);
-}
-
-template <>
-inline bool add_overflow(unsigned int& result, unsigned int operand) {
-    return __builtin_uadd_overflow(result, operand, &result);
-}
-
-template <>
-inline bool add_overflow(unsigned long& result, unsigned long operand) {
-    return __builtin_uaddl_overflow(result, operand, &result);
-}
-
-template <>
-inline bool add_overflow(unsigned long long& result,
-                         unsigned long long operand) {
-    return __builtin_uaddll_overflow(result, operand, &result);
-}
-
-////////////////
-// substraction overflow detection
-////////////////
-template <typename T>
-inline bool sub_overflow(T& result, T operand) {
-    return __builtin_sub_overflow(result, operand, &result);
-}
-
-template <>
-inline bool sub_overflow(int& result, int operand) {
-    return __builtin_ssub_overflow(result, operand, &result);
-}
-
-template <>
-inline bool sub_overflow(long& result, long operand) {
-    return __builtin_ssubl_overflow(result, operand, &result);
-}
-
-template <>
-inline bool sub_overflow(long long& result, long long operand) {
-    return __builtin_ssubll_overflow(result, operand, &result);
-}
-
-// Note: sub_overflow function should be unreachable for unsigned values
-template <>
-inline bool sub_overflow(unsigned int& result, unsigned int operand) {
-    return __builtin_usub_overflow(result, operand, &result);
-}
-
-template <>
-inline bool sub_overflow(unsigned long& result, unsigned long operand) {
-    return __builtin_usubl_overflow(result, operand, &result);
-}
-
-template <>
-inline bool sub_overflow(unsigned long long& result,
-                         unsigned long long operand) {
-    return __builtin_usubll_overflow(result, operand, &result);
-}
-
-template <typename T, typename F>
-bool shift_and_add_overflow(T& value, T digit, F add_last_digit_overflow) {
-    if (mul_overflow<T>(value, 10) || add_last_digit_overflow(value, digit)) {
-        return true;
-    }
-    return false;
-}
-#else
-
-template <typename T, typename U>
-bool shift_and_add_overflow(T& value, T digit, U is_negative) {
-    digit = (is_negative) ? -digit : digit;
-    T old_value = value;
-    value = 10 * value + digit;
-
-    T expected_old_value = (value - digit) / 10;
-    if (old_value != expected_old_value) {
-        return true;
-    }
-    return false;
-}
-
-#endif
-
 template <typename T>
 std::enable_if_t<std::is_integral_v<T>, std::optional<T>> to_num(
-    const char* begin, const char* end) {
-    if (begin == end) {
+    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;
     }
-    bool is_negative = false;
-    if constexpr (std::is_signed_v<T>) {
-        is_negative = *begin == '-';
-        if (is_negative) {
-            ++begin;
-        }
-    }
-
-#if (defined(__clang__) || defined(__GNUC__) || defined(__GUNG__)) &&          \
-    !defined(MINGW32_CLANG)
-    auto add_last_digit_overflow =
-        (is_negative) ? sub_overflow<T> : add_overflow<T>;
-#else
-    auto add_last_digit_overflow = is_negative;
-#endif
-
-    T value = 0;
-    for (auto i = begin; i != end; ++i) {
-        if (auto digit = from_char(*i);
-            !digit || shift_and_add_overflow<T>(value, digit.value(),
-                                                add_last_digit_overflow)) {
-            return std::nullopt;
-        }
-    }
-
-    return value;
+    return ret;
 }
 
 ////////////////
@@ -2196,7 +2024,6 @@ private:
         return extract_tuple<Ts...>(elems);
     }
 
-    // do not know how to specialize by return type :(
     template <typename... Ts>
     no_void_validator_tup_t<std::tuple<Ts...>> convert_impl(
         const split_data& elems, const std::tuple<Ts...>*) {
@@ -2312,7 +2139,6 @@ private:
 
 } /* ss */
 
-// TODO add single header tests
 
 namespace ss {
 
@@ -2351,6 +2177,23 @@ public:
         }
     }
 
+    parser(const char* const csv_data_buffer, size_t csv_data_size,
+           const std::string& delim = ss::default_delimiter)
+        : file_name_{"buffer line"},
+          reader_{csv_data_buffer, csv_data_size, delim} {
+        if (csv_data_buffer) {
+            read_line();
+            if constexpr (ignore_header) {
+                ignore_next();
+            } else {
+                raw_header_ = reader_.get_buffer();
+            }
+        } else {
+            handle_error_null_buffer();
+            eof_ = true;
+        }
+    }
+
     parser(parser&& other) = default;
     parser& operator=(parser&& other) = default;
 
@@ -2458,7 +2301,7 @@ public:
             return;
         }
 
-        if (header_.empty()) {
+        if (header_.empty() && !eof()) {
             split_header_data();
         }
 
@@ -2654,20 +2497,22 @@ public:
 
         template <typename U, typename... Us, typename Fun = none>
         void try_convert_and_invoke(std::optional<U>& value, Fun&& fun) {
-            if (!parser_.valid()) {
-                auto tuple_output = try_same<Us...>();
-                if (!parser_.valid()) {
-                    return;
-                }
-
-                if constexpr (!std::is_same_v<U, decltype(tuple_output)>) {
-                    value = to_object<U>(std::move(tuple_output));
-                } else {
-                    value = std::move(tuple_output);
-                }
-
-                parser_.try_invoke(*value, std::forward<Fun>(fun));
+            if (parser_.valid()) {
+                return;
             }
+
+            auto tuple_output = try_same<Us...>();
+            if (!parser_.valid()) {
+                return;
+            }
+
+            if constexpr (!std::is_same_v<U, decltype(tuple_output)>) {
+                value = to_object<U>(std::move(tuple_output));
+            } else {
+                value = std::move(tuple_output);
+            }
+
+            parser_.try_invoke(*value, std::forward<Fun>(fun));
         }
 
         template <typename U, typename... Us>
@@ -2815,6 +2660,19 @@ private:
         }
     }
 
+    void handle_error_null_buffer() {
+        constexpr static auto error_msg = " received null data buffer";
+
+        if constexpr (string_error) {
+            error_.clear();
+            error_.append(file_name_).append(error_msg);
+        } else if constexpr (throw_on_error) {
+            throw ss::exception{file_name_ + error_msg};
+        } else {
+            error_ = true;
+        }
+    }
+
     void handle_error_file_not_open() {
         constexpr static auto error_msg = " could not be opened";
 
@@ -2944,18 +2802,27 @@ private:
             : delim_{delim}, file_{fopen(file_name_.c_str(), "rb")} {
         }
 
+        reader(const char* const buffer, size_t csv_data_size,
+               const std::string& delim)
+            : delim_{delim}, csv_data_buffer_{buffer},
+              csv_data_size_{csv_data_size} {
+        }
+
         reader(reader&& other)
             : buffer_{other.buffer_},
               next_line_buffer_{other.next_line_buffer_},
-              helper_buffer_{other.helper_buffer_}, converter_{std::move(
-                                                        other.converter_)},
+              helper_buffer_{other.helper_buffer_},
+              converter_{std::move(other.converter_)},
               next_line_converter_{std::move(other.next_line_converter_)},
               buffer_size_{other.buffer_size_},
               next_line_buffer_size_{other.next_line_buffer_size_},
-              helper_size_{other.helper_size_}, delim_{std::move(other.delim_)},
-              file_{other.file_}, crlf_{other.crlf_},
-              line_number_{other.line_number_}, next_line_size_{
-                                                    other.next_line_size_} {
+              helper_buffer_size{other.helper_buffer_size},
+              delim_{std::move(other.delim_)}, file_{other.file_},
+              csv_data_buffer_{other.csv_data_buffer_},
+              csv_data_size_{other.csv_data_size_},
+              curr_char_{other.curr_char_}, crlf_{other.crlf_},
+              line_number_{other.line_number_},
+              next_line_size_{other.next_line_size_} {
             other.buffer_ = nullptr;
             other.next_line_buffer_ = nullptr;
             other.helper_buffer_ = nullptr;
@@ -2971,9 +2838,12 @@ private:
                 next_line_converter_ = std::move(other.next_line_converter_);
                 buffer_size_ = other.buffer_size_;
                 next_line_buffer_size_ = other.next_line_buffer_size_;
-                helper_size_ = other.helper_size_;
+                helper_buffer_size = other.helper_buffer_size;
                 delim_ = std::move(other.delim_);
                 file_ = other.file_;
+                csv_data_buffer_ = other.csv_data_buffer_;
+                csv_data_size_ = other.csv_data_size_;
+                curr_char_ = other.curr_char_;
                 crlf_ = other.crlf_;
                 line_number_ = other.line_number_;
                 next_line_size_ = other.next_line_size_;
@@ -3001,6 +2871,53 @@ private:
         reader(const reader& other) = delete;
         reader& operator=(const reader& other) = delete;
 
+        ssize_t get_line_buffer(char** lineptr, size_t* n,
+                                const char* const buffer, size_t csv_data_size,
+                                size_t& curr_char) {
+            size_t pos;
+            int c;
+
+            if (curr_char >= csv_data_size) {
+                return -1;
+            }
+            c = buffer[curr_char++];
+
+            if (*lineptr == nullptr) {
+                *lineptr =
+                    static_cast<char*>(malloc(get_line_initial_buffer_size));
+                if (*lineptr == nullptr) {
+                    return -1;
+                }
+                *n = 128;
+            }
+
+            pos = 0;
+            while (curr_char <= csv_data_size) {
+                if (pos + 1 >= *n) {
+                    size_t new_size = *n + (*n >> 2);
+                    if (new_size < get_line_initial_buffer_size) {
+                        new_size = get_line_initial_buffer_size;
+                    }
+                    char* new_ptr = static_cast<char*>(
+                        realloc(static_cast<void*>(*lineptr), new_size));
+                    if (new_ptr == nullptr) {
+                        return -1;
+                    }
+                    *n = new_size;
+                    *lineptr = new_ptr;
+                }
+
+                (*lineptr)[pos++] = c;
+                if (c == '\n') {
+                    break;
+                }
+                c = buffer[curr_char++];
+            }
+
+            (*lineptr)[pos] = '\0';
+            return pos;
+        }
+
         // read next line each time in order to set eof_
         bool read_next() {
             next_line_converter_.clear_error();
@@ -3011,10 +2928,21 @@ private:
                 if (next_line_buffer_size_ > 0) {
                     next_line_buffer_[0] = '\0';
                 }
-                ssize = get_line(&next_line_buffer_, &next_line_buffer_size_,
-                                 file_);
+
+                if (file_) {
+                    ssize = get_line_file(&next_line_buffer_,
+                                          &next_line_buffer_size_, file_);
+                } else {
+                    ssize = get_line_buffer(&next_line_buffer_,
+                                            &next_line_buffer_size_,
+                                            csv_data_buffer_, csv_data_size_,
+                                            curr_char_);
+                }
 
                 if (ssize == -1) {
+                    if (errno == ENOMEM) {
+                        throw std::bad_alloc{};
+                    }
                     return false;
                 }
 
@@ -3124,6 +3052,10 @@ private:
         }
 
         size_t remove_eol(char*& buffer, size_t ssize) {
+            if (buffer[ssize - 1] != '\n') {
+                return ssize;
+            }
+
             size_t size = ssize - 1;
             if (ssize >= 2 && buffer[ssize - 2] == '\r') {
                 crlf_ = true;
@@ -3137,12 +3069,12 @@ private:
         }
 
         void realloc_concat(char*& first, size_t& first_size,
-                            const char* const second, size_t second_size) {
-            // TODO make buffer_size an argument
-            next_line_buffer_size_ = first_size + second_size + 3;
+                            size_t& buffer_size, const char* const second,
+                            size_t second_size) {
+            buffer_size = first_size + second_size + 3;
             auto new_first = static_cast<char*>(
-                realloc(static_cast<void*>(first), next_line_buffer_size_));
-            if (!first) {
+                realloc(static_cast<void*>(first), buffer_size));
+            if (!new_first) {
                 throw std::bad_alloc{};
             }
 
@@ -3154,15 +3086,25 @@ private:
         bool append_next_line_to_buffer(char*& buffer, size_t& size) {
             undo_remove_eol(buffer, size);
 
-            ssize_t next_ssize =
-                get_line(&helper_buffer_, &helper_size_, file_);
+            ssize_t next_ssize;
+            if (file_) {
+                next_ssize =
+                    get_line_file(&helper_buffer_, &helper_buffer_size, file_);
+            } else {
+                next_ssize =
+                    get_line_buffer(&helper_buffer_, &helper_buffer_size,
+                                    csv_data_buffer_, csv_data_size_,
+                                    curr_char_);
+            }
+
             if (next_ssize == -1) {
                 return false;
             }
 
             ++line_number_;
             size_t next_size = remove_eol(helper_buffer_, next_ssize);
-            realloc_concat(buffer, size, helper_buffer_, next_size);
+            realloc_concat(buffer, size, next_line_buffer_size_, helper_buffer_,
+                           next_size);
             return true;
         }
 
@@ -3182,11 +3124,15 @@ private:
 
         size_t buffer_size_{0};
         size_t next_line_buffer_size_{0};
-        size_t helper_size_{0};
+        size_t helper_buffer_size{0};
 
         std::string delim_;
         FILE* file_{nullptr};
 
+        const char* csv_data_buffer_{nullptr};
+        size_t csv_data_size_{0};
+        size_t curr_char_{0};
+
         bool crlf_{false};
         size_t line_number_{0};
 

test/CMakeLists.txt

@@ -32,9 +32,11 @@ set(DOCTEST "${FETCHCONTENT_BASE_DIR}/doctest-src")
 
 enable_testing()
 
-foreach(name IN ITEMS test_splitter test_parser test_converter test_extractions
-                      test_parser2_1 test_parser2_2 test_parser2_3
-                      test_parser2_4 test_extractions_without_fast_float)
+foreach(name IN ITEMS test_splitter test_parser1_1 test_parser1_2
+                      test_parser1_3 test_parser1_4 test_converter
+                      test_extractions test_parser2_1 test_parser2_2
+                      test_parser2_3 test_parser2_4 test_parser2_5
+                      test_parser2_6 test_extractions_without_fast_float)
     add_executable("${name}" "${name}.cpp")
     target_link_libraries("${name}" PRIVATE ssp::ssp fast_float
                                             doctest::doctest)

test/meson.build

@@ -2,7 +2,10 @@ doctest_dep = dependency('doctest')
 add_project_arguments('-DDOCTEST_CONFIG_IMPLEMENT_WITH_MAIN', language: 'cpp')
 
 tests = [
-  'parser',
+  'parser1_1',
+  'parser1_2',
+  'parser1_3',
+  'parser1_4',
   'splitter',
   'converter',
   'extractions',
@@ -10,6 +13,8 @@ tests = [
   'parser2_2',
   'parser2_3',
   'parser2_4',
+  'parser2_5',
+  'parser2_6',
   'extractions_without_fast_float',
 ]
 

test/test_extractions.cpp

@@ -275,3 +275,20 @@ TEST_CASE("extract test functions for std::variant") {
         }
     }
 }
+
+TEST_CASE("extract test with long number string") {
+    {
+        std::string string_num =
+            std::string(20, '1') + "." + std::string(20, '2');
+
+        CHECK_FLOATING_CONVERSION_LONG_NUMBER(string_num, float, stof);
+        CHECK_FLOATING_CONVERSION_LONG_NUMBER(string_num, double, stod);
+    }
+
+    {
+        std::string string_num =
+            std::string(50, '1') + "." + std::string(50, '2');
+
+        CHECK_FLOATING_CONVERSION_LONG_NUMBER(string_num, double, stod);
+    }
+}

test/test_extractions_without_fast_float.cpp

@@ -9,11 +9,11 @@ TEST_CASE(
     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(59, float);
+    CHECK_FLOATING_CONVERSION(59, double);
 
-    CHECK_FLOATING_CONVERSION(420., float);
-    CHECK_FLOATING_CONVERSION(420., double);
+    CHECK_FLOATING_CONVERSION(4210., float);
+    CHECK_FLOATING_CONVERSION(4210., double);
 
     CHECK_FLOATING_CONVERSION(0.123, float);
     CHECK_FLOATING_CONVERSION(0.123, double);
@@ -130,3 +130,20 @@ TEST_CASE("extract test functions for std::variant without fast float") {
         }
     }
 }
+
+TEST_CASE("extract test with long number string without fast float") {
+    {
+        std::string string_num =
+            std::string(20, '1') + "." + std::string(20, '2');
+
+        CHECK_FLOATING_CONVERSION_LONG_NUMBER(string_num, float, stof);
+        CHECK_FLOATING_CONVERSION_LONG_NUMBER(string_num, double, stod);
+    }
+
+    {
+        std::string string_num =
+            std::string(50, '1') + "." + std::string(50, '2');
+
+        CHECK_FLOATING_CONVERSION_LONG_NUMBER(string_num, double, stod);
+    }
+}

test/test_helpers.hpp

@@ -1,10 +1,12 @@
 #pragma once
 #include <ctime>
+#include <filesystem>
 #include <iomanip>
 #include <sstream>
 #include <string>
 #include <vector>
-#include <filesystem>
+#include <algorithm>
+#include <fstream>
 
 #ifdef CMAKE_GITHUB_CI
 #include <doctest/doctest.h>
@@ -12,6 +14,11 @@
 #include <doctest.h>
 #endif
 
+namespace ss {
+template <typename... Ts>
+class parser;
+} /* ss */
+
 namespace {
 struct buffer {
     std::string data_;
@@ -34,7 +41,8 @@ struct buffer {
 
 [[maybe_unused]] inline buffer buff;
 
-std::string time_now_rand() {
+[[maybe_unused]] std::string time_now_rand() {
+    srand(time(nullptr));
     std::stringstream ss;
     auto t = std::time(nullptr);
     auto tm = *std::localtime(&t);
@@ -46,11 +54,13 @@ std::string time_now_rand() {
 struct unique_file_name {
     static inline int i = 0;
 
-    const std::string name;
+    std::string name;
 
-    unique_file_name(const std::string& test)
-        : name{"random_" + test + "_" + std::to_string(i++) + "_" +
-               time_now_rand() + "_file.csv"} {
+    unique_file_name(const std::string& test) {
+        do {
+            name = "random_" + test + "_" + std::to_string(i++) + "_" +
+                   time_now_rand() + "_file.csv";
+        } while (std::filesystem::exists(name));
     }
 
     ~unique_file_name() {
@@ -75,6 +85,18 @@ struct unique_file_name {
         CHECK_LT(std::abs(t.value() - type(-input)), eps);                     \
     }
 
+#define CHECK_FLOATING_CONVERSION_LONG_NUMBER(STRING_NUMBER, TYPE, CONVERTER)  \
+    {                                                                          \
+        auto begin = STRING_NUMBER.c_str();                                    \
+        auto end = begin + STRING_NUMBER.size();                               \
+                                                                               \
+        auto number = ss::to_num<TYPE>(begin, end);                            \
+        REQUIRE(number.has_value());                                           \
+                                                                               \
+        auto expected_number = CONVERTER(STRING_NUMBER);                       \
+        CHECK_EQ(number.value(), expected_number);                             \
+    }
+
 #define CHECK_INVALID_CONVERSION(input, type)                                  \
     {                                                                          \
         std::string s = input;                                                 \
@@ -100,8 +122,8 @@ struct unique_file_name {
     }
 
 template <typename T>
-std::vector<std::vector<T>> vector_combinations(const std::vector<T>& v,
-                                                size_t n) {
+[[maybe_unused]] std::vector<std::vector<T>> vector_combinations(
+    const std::vector<T>& v, size_t n) {
     std::vector<std::vector<T>> ret;
     if (n <= 1) {
         for (const auto& i : v) {
@@ -114,9 +136,59 @@ std::vector<std::vector<T>> vector_combinations(const std::vector<T>& v,
     for (const auto& i : v) {
         for (auto j : inner_combinations) {
             j.insert(j.begin(), i);
-            ret.push_back(move(j));
+            ret.push_back(std::move(j));
         }
     }
     return ret;
 }
+
+[[maybe_unused]] std::string make_buffer(const std::string& file_name) {
+    std::ifstream in{file_name, std::ios::binary};
+    std::string tmp;
+    std::string out;
+
+    auto copy_if_whitespaces = [&] {
+        std::string matches = "\n\r\t ";
+        while (std::any_of(matches.begin(), matches.end(),
+                           [&](auto c) { return in.peek() == c; })) {
+            if (in.peek() == '\r') {
+                out += "\r\n";
+                in.ignore(2);
+            } else {
+                out += std::string{static_cast<char>(in.peek())};
+                in.ignore(1);
+            }
+        }
+    };
+
+    out.reserve(sizeof(out) + 1);
+
+    copy_if_whitespaces();
+    while (in >> tmp) {
+        out += tmp;
+        copy_if_whitespaces();
+    }
+    return out;
+}
+
+template <bool buffer_mode, typename... Ts>
+[[maybe_unused]] std::tuple<ss::parser<Ts...>, std::string> make_parser(
+    const std::string& file_name, const std::string& delim = "") {
+    if (buffer_mode) {
+        auto buffer = make_buffer(file_name);
+        if (delim.empty()) {
+            return {ss::parser<Ts...>{buffer.data(), buffer.size()},
+                    std::move(buffer)};
+        } else {
+            return {ss::parser<Ts...>{buffer.data(), buffer.size(), delim},
+                    std::move(buffer)};
+        }
+    } else {
+        if (delim.empty()) {
+            return {ss::parser<Ts...>{file_name}, std::string{}};
+        } else {
+            return {ss::parser<Ts...>{file_name, delim}, std::string{}};
+        }
+    }
+}
 } /* namespace */

test/test_parser1.hpp

@@ -0,0 +1,112 @@
+#pragma once
+
+#include "test_helpers.hpp"
+#include <algorithm>
+#include <filesystem>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <ss/parser.hpp>
+#include <sstream>
+#include <unordered_map>
+#include <unordered_set>
+
+namespace {
+[[maybe_unused]] void replace_all(std::string& s, const std::string& from,
+                                  const std::string& to) {
+    if (from.empty()) return;
+    size_t start_pos = 0;
+    while ((start_pos = s.find(from, start_pos)) != std::string::npos) {
+        s.replace(start_pos, from.length(), to);
+        start_pos += to.length();
+    }
+}
+
+template <typename... Ts>
+void expect_error_on_command(ss::parser<Ts...>& p,
+                             const std::function<void()> command) {
+    if (ss::setup<Ts...>::throw_on_error) {
+        try {
+            command();
+        } catch (const std::exception& e) {
+            CHECK_FALSE(std::string{e.what()}.empty());
+        }
+    } else {
+        command();
+        CHECK(!p.valid());
+        if constexpr (ss::setup<Ts...>::string_error) {
+            CHECK_FALSE(p.error_msg().empty());
+        }
+    }
+}
+
+[[maybe_unused]] void update_if_crlf(std::string& s) {
+#ifdef _WIN32
+    replace_all(s, "\r\n", "\n");
+#else
+    (void)(s);
+#endif
+}
+
+struct X {
+    constexpr static auto delim = ",";
+    constexpr static auto empty = "_EMPTY_";
+    int i;
+    double d;
+    std::string s;
+
+    std::string to_string() const {
+        if (s == empty) {
+            return "";
+        }
+
+        return std::to_string(i)
+            .append(delim)
+            .append(std::to_string(d))
+            .append(delim)
+            .append(s);
+    }
+    auto tied() const {
+        return std::tie(i, d, s);
+    }
+};
+
+template <typename T>
+std::enable_if_t<ss::has_m_tied_t<T>, bool> operator==(const T& lhs,
+                                                       const T& rhs) {
+    return lhs.tied() == rhs.tied();
+}
+
+template <typename T>
+static void make_and_write(const std::string& file_name,
+                           const std::vector<T>& data,
+                           const std::vector<std::string>& header = {},
+                           bool new_line_eof = true) {
+    std::ofstream out{file_name};
+
+#ifdef _WIN32
+    std::vector<const char*> new_lines = {"\n"};
+#else
+    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();
+        if (new_line_eof || i + 1 < data.size()) {
+            out << new_lines[i % new_lines.size()];
+        }
+    }
+}
+
+} /* namespace */

test/test_parser1_1.cpp

@@ -0,0 +1,582 @@
+#include "test_parser1.hpp"
+
+TEST_CASE("test file not found") {
+    unique_file_name f{"test_parser"};
+
+    {
+        ss::parser p{f.name, ","};
+        CHECK_FALSE(p.valid());
+    }
+
+    {
+        ss::parser<ss::string_error> p{f.name, ","};
+        CHECK_FALSE(p.valid());
+    }
+
+    try {
+        ss::parser<ss::throw_on_error> p{f.name, ","};
+        FAIL("Expected exception...");
+    } catch (const std::exception& e) {
+        CHECK_FALSE(std::string{e.what()}.empty());
+    }
+}
+
+TEST_CASE("test null buffer") {
+    {
+        ss::parser p{nullptr, 10, ","};
+        CHECK_FALSE(p.valid());
+    }
+
+    {
+        ss::parser<ss::string_error> p{nullptr, 10, ","};
+        CHECK_FALSE(p.valid());
+    }
+
+    try {
+        ss::parser<ss::throw_on_error> p{nullptr, 10, ","};
+        FAIL("Expected exception...");
+    } catch (const std::exception& e) {
+        CHECK_FALSE(std::string{e.what()}.empty());
+    }
+}
+
+template <bool buffer_mode, typename... Ts>
+void test_various_cases() {
+    unique_file_name f{"test_parser"};
+    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);
+    auto csv_data_buffer = make_buffer(f.name);
+    {
+        auto [p, _] = make_parser<buffer_mode, Ts...>(f.name, ",");
+        ss::parser p0{std::move(p)};
+        p = std::move(p0);
+        std::vector<X> i;
+
+        auto [p2, __] = make_parser<buffer_mode, Ts...>(f.name, ",");
+        std::vector<X> i2;
+
+        auto move_rotate = [&p = p, &p0 = p0] {
+            auto p1 = std::move(p);
+            p0 = std::move(p1);
+            p = std::move(p0);
+        };
+
+        while (!p.eof()) {
+            move_rotate();
+            auto a = p.template get_next<int, double, std::string>();
+            i.emplace_back(ss::to_object<X>(a));
+        }
+
+        for (const auto& a : p2.template iterate<int, double, std::string>()) {
+            i2.emplace_back(ss::to_object<X>(a));
+        }
+
+        CHECK_EQ(i, data);
+        CHECK_EQ(i2, data);
+    }
+
+    {
+        auto [p, _] = make_parser<buffer_mode, Ts...>(f.name, ",");
+        std::vector<X> i;
+
+        auto [p2, __] = make_parser<buffer_mode, Ts...>(f.name, ",");
+        std::vector<X> i2;
+
+        auto [p3, ___] = make_parser<buffer_mode, Ts...>(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()) {
+            auto a = p.template get_next<tup>();
+            i.emplace_back(ss::to_object<X>(a));
+        }
+
+        p2.ignore_next();
+        for (const auto& a : p2.template iterate<tup>()) {
+            i2.emplace_back(ss::to_object<X>(a));
+        }
+
+        p3.ignore_next();
+        for (auto it = p3.template iterate<tup>().begin();
+             it != p3.template iterate<tup>().end(); ++it) {
+            i3.emplace_back(ss::to_object<X>(*it));
+        }
+
+        CHECK_EQ(i, expected);
+        CHECK_EQ(i2, expected);
+        CHECK_EQ(i3, expected);
+    }
+
+    {
+        auto [p, _] = make_parser<buffer_mode, Ts...>(f.name, ",");
+        std::vector<X> i;
+        auto [p2, __] = make_parser<buffer_mode, Ts...>(f.name, ",");
+        std::vector<X> i2;
+
+        while (!p.eof()) {
+            i.push_back(p.template get_object<X, int, double, std::string>());
+        }
+
+        for (auto&& a :
+             p2.template iterate_object<X, int, double, std::string>()) {
+            i2.push_back(std::move(a));
+        }
+
+        CHECK_EQ(i, data);
+        CHECK_EQ(i2, data);
+    }
+
+    {
+        auto [p, _] = make_parser<buffer_mode, Ts...>(f.name, ",");
+        std::vector<X> i;
+
+        for (auto&& a :
+             p.template iterate_object<X, int, double, std::string>()) {
+            i.push_back(std::move(a));
+        }
+
+        CHECK_EQ(i, data);
+    }
+
+    {
+        auto [p, _] = make_parser<buffer_mode, Ts...>(f.name, ",");
+        std::vector<X> i;
+
+        auto [p2, __] = make_parser<buffer_mode, Ts...>(f.name, ",");
+        std::vector<X> i2;
+
+        using tup = std::tuple<int, double, std::string>;
+        while (!p.eof()) {
+            i.push_back(p.template get_object<X, tup>());
+        }
+
+        for (auto it = p2.template iterate_object<X, tup>().begin();
+             it != p2.template iterate_object<X, tup>().end(); it++) {
+            i2.push_back({it->i, it->d, it->s});
+        }
+
+        CHECK_EQ(i, data);
+        CHECK_EQ(i2, data);
+    }
+
+    {
+        auto [p, _] = make_parser<buffer_mode, Ts...>(f.name, ",");
+        std::vector<X> i;
+
+        using tup = std::tuple<int, double, std::string>;
+        for (auto&& a : p.template iterate_object<X, tup>()) {
+            i.push_back(std::move(a));
+        }
+
+        CHECK_EQ(i, data);
+    }
+
+    {
+        auto [p, _] = make_parser<buffer_mode, Ts...>(f.name, ",");
+        std::vector<X> i;
+
+        while (!p.eof()) {
+            i.push_back(p.template get_next<X>());
+        }
+
+        CHECK_EQ(i, data);
+    }
+
+    {
+        auto [p, _] = make_parser<buffer_mode, Ts...>(f.name, ",");
+        std::vector<X> i;
+
+        for (auto&& a : p.template iterate<X>()) {
+            i.push_back(std::move(a));
+        }
+
+        CHECK_EQ(i, data);
+    }
+
+    {
+        constexpr int excluded = 3;
+        auto [p, _] = make_parser<buffer_mode, Ts...>(f.name, ",");
+        std::vector<X> i;
+
+        auto [p2, __] = make_parser<buffer_mode, Ts...>(f.name, ",");
+        std::vector<X> i2;
+
+        while (!p.eof()) {
+            try {
+                auto a = p.template get_object<X, ss::ax<int, excluded>, double,
+                                               std::string>();
+                if (p.valid()) {
+                    i.push_back(a);
+                }
+            } catch (...) {
+                // ignore
+            };
+        }
+
+        if (!ss::setup<Ts...>::throw_on_error) {
+            for (auto&& a : p2.template 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) {
+                expected.push_back(x);
+            }
+        }
+
+        std::copy_if(data.begin(), data.end(), expected.begin(),
+                     [&](const X& x) { return x.i != excluded; });
+        CHECK_EQ(i, expected);
+
+        if (!ss::setup<Ts...>::throw_on_error) {
+            CHECK_EQ(i2, expected);
+        }
+    }
+
+    {
+        auto [p, _] = make_parser<buffer_mode, Ts...>(f.name, ",");
+        std::vector<X> i;
+
+        auto [p2, __] = make_parser<buffer_mode, Ts...>(f.name, ",");
+        std::vector<X> i2;
+
+        while (!p.eof()) {
+            try {
+                auto a = p.template get_object<X, ss::nx<int, 3>, double,
+                                               std::string>();
+                if (p.valid()) {
+                    i.push_back(a);
+                }
+            } catch (...) {
+                // ignore
+            }
+        }
+
+        if (!ss::setup<Ts...>::throw_on_error) {
+            for (auto&& a : p2.template 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);
+        if (!ss::setup<Ts...>::throw_on_error) {
+            CHECK_EQ(i2, expected);
+        }
+    }
+
+    {
+        unique_file_name empty_f{"test_parser"};
+        std::vector<X> empty_data = {};
+
+        make_and_write(empty_f.name, empty_data);
+
+        auto [p, _] = make_parser<buffer_mode, Ts...>(empty_f.name, ",");
+        std::vector<X> i;
+
+        auto [p2, __] = make_parser<buffer_mode, Ts...>(empty_f.name, ",");
+        std::vector<X> i2;
+
+        while (!p.eof()) {
+            i.push_back(p.template get_next<X>());
+        }
+
+        for (auto&& a : p2.template iterate<X>()) {
+            i2.push_back(std::move(a));
+        }
+
+        CHECK(i.empty());
+        CHECK(i2.empty());
+    }
+}
+
+TEST_CASE("parser test various cases") {
+    test_various_cases<false>();
+    test_various_cases<false, ss::string_error>();
+    test_various_cases<false, ss::throw_on_error>();
+    test_various_cases<true>();
+    test_various_cases<true, ss::string_error>();
+    test_various_cases<true, ss::throw_on_error>();
+}
+
+using test_tuple = std::tuple<double, char, double>;
+struct test_struct {
+    int i;
+    double d;
+    char c;
+    auto tied() {
+        return std::tie(i, d, c);
+    }
+};
+
+static inline void expect_test_struct(const test_struct&) {
+}
+
+template <bool buffer_mode, typename... Ts>
+void test_composite_conversion() {
+    unique_file_name f{"test_parser"};
+    {
+        std::ofstream out{f.name};
+        for (auto& i :
+             {"10,a,11.1", "10,20,11.1", "junk", "10,11.1", "1,11.1,a", "junk",
+              "10,junk", "11,junk", "10,11.1,c", "10,20", "10,22.2,f"}) {
+            out << i << std::endl;
+        }
+    }
+
+    auto [p, _] = make_parser<buffer_mode, Ts...>(f.name, ",");
+    auto fail = [] { FAIL(""); };
+    auto expect_error = [](auto error) { CHECK(!error.empty()); };
+    auto ignore_error = [] {};
+
+    REQUIRE(p.valid());
+    REQUIRE_FALSE(p.eof());
+
+    {
+        constexpr static auto expectedData = std::tuple{10, 'a', 11.1};
+
+        auto [d1, d2, d3, d4] =
+            p.template try_next<int, int, double>(fail)
+                .template or_else<test_struct>(fail)
+                .template or_else<int, char, double>(
+                    [&](auto&& data) { CHECK_EQ(data, expectedData); })
+                .on_error(fail)
+                .template or_else<test_tuple>(fail)
+                .values();
+
+        REQUIRE(p.valid());
+        REQUIRE_FALSE(d1);
+        REQUIRE_FALSE(d2);
+        REQUIRE(d3);
+        REQUIRE_FALSE(d4);
+        CHECK_EQ(*d3, expectedData);
+    }
+
+    {
+        REQUIRE(!p.eof());
+        constexpr static auto expectedData = std::tuple{10, 20, 11.1};
+
+        auto [d1, d2, d3, d4] =
+            p.template try_next<int, int, double>(
+                 [&](auto& i1, auto i2, double d) {
+                     CHECK_EQ(std::tie(i1, i2, d), expectedData);
+                 })
+                .on_error(fail)
+                .template or_object<test_struct, int, double, char>(fail)
+                .on_error(fail)
+                .template or_else<test_tuple>(fail)
+                .on_error(fail)
+                .template or_else<int, char, double>(fail)
+                .values();
+
+        REQUIRE(p.valid());
+        REQUIRE(d1);
+        REQUIRE_FALSE(d2);
+        REQUIRE_FALSE(d3);
+        REQUIRE_FALSE(d4);
+        CHECK_EQ(*d1, expectedData);
+    }
+
+    {
+        REQUIRE(!p.eof());
+
+        auto [d1, d2, d3, d4, d5] =
+            p.template try_object<test_struct, int, double, char>(fail)
+                .on_error(expect_error)
+                .template or_else<int, char, char>(fail)
+                .template or_else<test_struct>(fail)
+                .template or_else<test_tuple>(fail)
+                .template or_else<int, char, double>(fail)
+                .values();
+
+        REQUIRE_FALSE(p.valid());
+        REQUIRE_FALSE(d1);
+        REQUIRE_FALSE(d2);
+        REQUIRE_FALSE(d3);
+        REQUIRE_FALSE(d4);
+        REQUIRE_FALSE(d5);
+    }
+
+    {
+        REQUIRE(!p.eof());
+
+        auto [d1, d2] =
+            p.template try_next<int, double>([](auto& i, auto& d) {
+                 REQUIRE_EQ(std::tie(i, d), std::tuple{10, 11.1});
+             })
+                .template or_else<int, double>([](auto&, auto&) { FAIL(""); })
+                .values();
+
+        REQUIRE(p.valid());
+        REQUIRE(d1);
+        REQUIRE_FALSE(d2);
+    }
+
+    {
+        REQUIRE(!p.eof());
+
+        auto [d1, d2] =
+            p.template try_next<int, double>([](auto&, auto&) { FAIL(""); })
+                .template or_else<test_struct>(expect_test_struct)
+                .values();
+
+        REQUIRE(p.valid());
+        REQUIRE_FALSE(d1);
+        REQUIRE(d2);
+        CHECK_EQ(d2->tied(), std::tuple{1, 11.1, 'a'});
+    }
+
+    {
+        REQUIRE(!p.eof());
+
+        auto [d1, d2, d3, d4, d5] =
+            p.template try_next<int, int, double>(fail)
+                .template or_object<test_struct, int, double, char>()
+                .template or_else<test_struct>(expect_test_struct)
+                .template or_else<test_tuple>(fail)
+                .template or_else<std::tuple<int, double>>(fail)
+                .on_error(ignore_error)
+                .on_error(expect_error)
+                .values();
+
+        REQUIRE_FALSE(p.valid());
+        REQUIRE_FALSE(d1);
+        REQUIRE_FALSE(d2);
+        REQUIRE_FALSE(d3);
+        REQUIRE_FALSE(d4);
+        REQUIRE_FALSE(d5);
+    }
+
+    {
+        REQUIRE(!p.eof());
+
+        auto [d1, d2] =
+            p.template try_next<int, std::optional<int>>()
+                .on_error(ignore_error)
+                .on_error(fail)
+                .template or_else<std::tuple<int, std::string>>(fail)
+                .on_error(ignore_error)
+                .on_error(fail)
+                .on_error(ignore_error)
+                .values();
+
+        REQUIRE(p.valid());
+        REQUIRE(d1);
+        REQUIRE_FALSE(d2);
+        CHECK_EQ(*d1, std::tuple{10, std::nullopt});
+    }
+
+    {
+        REQUIRE_FALSE(p.eof());
+
+        auto [d1, d2] =
+            p.template try_next<int, std::variant<int, std::string>>()
+                .on_error(fail)
+                .template or_else<std::tuple<int, std::string>>(fail)
+                .on_error(fail)
+                .values();
+
+        REQUIRE(p.valid());
+        REQUIRE(d1);
+        REQUIRE_FALSE(d2);
+        CHECK_EQ(*d1, std::tuple{11, std::variant<int, std::string>{"junk"}});
+    }
+
+    {
+        REQUIRE(!p.eof());
+
+        auto [d1, d2] = p.template try_object<test_struct, int, double, char>()
+                            .template or_else<int>(fail)
+                            .values();
+        REQUIRE(p.valid());
+        REQUIRE(d1);
+        REQUIRE_FALSE(d2);
+        CHECK_EQ(d1->tied(), std::tuple{10, 11.1, 'c'});
+    }
+
+    {
+        REQUIRE_FALSE(p.eof());
+
+        auto [d1, d2, d3, d4] =
+            p.template try_next<int, int>([] { return false; })
+                .template or_else<int, double>([](auto&) { return false; })
+                .template or_else<int, int>()
+                .template or_else<int, int>(fail)
+                .values();
+
+        REQUIRE(p.valid());
+        REQUIRE_FALSE(d1);
+        REQUIRE_FALSE(d2);
+        REQUIRE(d3);
+        REQUIRE_FALSE(d4);
+        CHECK_EQ(d3.value(), std::tuple{10, 20});
+    }
+
+    {
+        REQUIRE(!p.eof());
+
+        auto [d1, d2, d3, d4] =
+            p.template try_object<test_struct, int, double, char>(
+                 [] { return false; })
+                .template or_else<int, double>([](auto&) { return false; })
+                .template or_object<test_struct, int, double, char>()
+                .template or_else<int, int>(fail)
+                .values();
+
+        REQUIRE(p.valid());
+        REQUIRE_FALSE(d1);
+        REQUIRE_FALSE(d2);
+        REQUIRE(d3);
+        REQUIRE_FALSE(d4);
+        CHECK_EQ(d3->tied(), std::tuple{10, 22.2, 'f'});
+    }
+
+    CHECK(p.eof());
+}
+
+// various scenarios
+TEST_CASE("parser test composite conversion") {
+    test_composite_conversion<false, ss::string_error>();
+    test_composite_conversion<true, ss::string_error>();
+}
+
+template <bool buffer_mode>
+void test_no_new_line_at_eof_impl(const std::vector<X>& data) {
+    unique_file_name f{"test_parser"};
+    make_and_write(f.name, data, {}, false);
+
+    auto [p, _] = make_parser<buffer_mode>(f.name);
+    std::vector<X> parsed_data;
+
+    for (const auto& el : p.template iterate<X>()) {
+        parsed_data.push_back(el);
+    }
+
+    CHECK_EQ(data, parsed_data);
+}
+
+template <bool buffer_mode>
+void test_no_new_line_at_eof() {
+    test_no_new_line_at_eof_impl<buffer_mode>({});
+    test_no_new_line_at_eof_impl<buffer_mode>({{1, 2, "X"}});
+    test_no_new_line_at_eof_impl<buffer_mode>({{1, 2, "X"}, {3, 4, "YY"}});
+    test_no_new_line_at_eof_impl<buffer_mode>(
+        {{1, 2, "X"}, {3, 4, "YY"}, {5, 6, "ZZZ"}, {7, 8, "UUU"}});
+}
+
+TEST_CASE("test no new line at end of data") {
+    test_no_new_line_at_eof<false>();
+    test_no_new_line_at_eof<true>();
+}

test/test_parser1_2.cpp

@@ -0,0 +1,309 @@
+#include "test_parser1.hpp"
+
+struct my_string {
+    char* data{nullptr};
+
+    my_string() = default;
+
+    ~my_string() {
+        delete[] data;
+    }
+
+    // make sure no object is copied
+    my_string(const my_string&) = delete;
+    my_string& operator=(const my_string&) = delete;
+
+    my_string(my_string&& other) : data{other.data} {
+        other.data = nullptr;
+    }
+
+    my_string& operator=(my_string&& other) {
+        data = other.data;
+        return *this;
+    }
+};
+
+template <>
+inline bool ss::extract(const char* begin, const char* end, my_string& s) {
+    size_t size = end - begin;
+    s.data = new char[size + 1];
+    strncpy(s.data, begin, size);
+    s.data[size] = '\0';
+    return true;
+}
+
+struct xyz {
+    my_string x;
+    my_string y;
+    my_string z;
+    auto tied() {
+        return std::tie(x, y, z);
+    }
+};
+
+template <bool buffer_mode, typename... Ts>
+void test_moving_of_parsed_composite_values() {
+    // to compile is enough
+    return;
+    auto [p, _] = make_parser<buffer_mode, Ts...>("", "");
+    p.template try_next<my_string, my_string, my_string>()
+        .template or_else<my_string, my_string, my_string, my_string>(
+            [](auto&&) {})
+        .template or_else<my_string>([](auto&) {})
+        .template or_else<xyz>([](auto&&) {})
+        .template or_object<xyz, my_string, my_string, my_string>([](auto&&) {})
+        .template or_else<std::tuple<my_string, my_string, my_string>>(
+            [](auto&, auto&, auto&) {});
+}
+
+TEST_CASE("parser test the moving of parsed composite values") {
+    test_moving_of_parsed_composite_values<false>();
+    test_moving_of_parsed_composite_values<false, ss::string_error>();
+    test_moving_of_parsed_composite_values<true>();
+    test_moving_of_parsed_composite_values<true, ss::string_error>();
+}
+
+TEST_CASE("parser test error mode") {
+    unique_file_name f{"test_parser"};
+    {
+        std::ofstream out{f.name};
+        out << "junk" << std::endl;
+        out << "junk" << std::endl;
+    }
+
+    {
+        auto [p, _] = make_parser<false, ss::string_error>(f.name, ",");
+
+        REQUIRE_FALSE(p.eof());
+        p.get_next<int>();
+        CHECK_FALSE(p.valid());
+        CHECK_FALSE(p.error_msg().empty());
+    }
+
+    {
+        auto [p, _] = make_parser<true, ss::string_error>(f.name, ",");
+
+        REQUIRE_FALSE(p.eof());
+        p.get_next<int>();
+        CHECK_FALSE(p.valid());
+        CHECK_FALSE(p.error_msg().empty());
+    }
+}
+
+TEST_CASE("parser throw on error mode") {
+    unique_file_name f{"test_parser"};
+    {
+        std::ofstream out{f.name};
+        out << "junk" << std::endl;
+        out << "junk" << std::endl;
+    }
+
+    {
+        auto [p, _] = make_parser<false, ss::throw_on_error>(f.name, ",");
+
+        REQUIRE_FALSE(p.eof());
+        try {
+            p.get_next<int>();
+            FAIL("Expected exception...");
+        } catch (const std::exception& e) {
+            CHECK_FALSE(std::string{e.what()}.empty());
+        }
+    }
+
+    {
+        auto [p, _] = make_parser<true, ss::throw_on_error>(f.name, ",");
+
+        REQUIRE_FALSE(p.eof());
+        try {
+            p.get_next<int>();
+            FAIL("Expected exception...");
+        } catch (const std::exception& e) {
+            CHECK_FALSE(std::string{e.what()}.empty());
+        }
+    }
+}
+
+static inline std::string no_quote(const std::string& s) {
+    if (!s.empty() && s[0] == '"') {
+        return {std::next(begin(s)), std::prev(end(s))};
+    }
+    return s;
+}
+
+template <bool buffer_mode, typename... Ts>
+void test_quote_multiline() {
+    unique_file_name f{"test_parser"};
+    std::vector<X> data = {{1, 2, "\"x\r\nx\nx\""},
+                           {3, 4, "\"y\ny\r\ny\""},
+                           {5, 6, "\"z\nz\""},
+                           {7, 8, "\"u\"\"\""},
+                           {9, 10, "v"},
+                           {11, 12, "\"w\n\""}};
+    for (auto& [_, __, s] : data) {
+        update_if_crlf(s);
+    }
+
+    make_and_write(f.name, data);
+    for (auto& [_, __, s] : data) {
+        s = no_quote(s);
+        if (s[0] == 'u') {
+            s = "u\"";
+        }
+    }
+
+    auto [p, _] =
+        make_parser<buffer_mode, ss::multiline, ss::quote<'"'>, Ts...>(f.name,
+                                                                       ",");
+
+    std::vector<X> i;
+
+    while (!p.eof()) {
+        auto a = p.template get_next<int, double, std::string>();
+        i.emplace_back(ss::to_object<X>(a));
+    }
+
+    for (auto& [_, __, s] : i) {
+        update_if_crlf(s);
+    }
+    CHECK_EQ(i, data);
+
+    auto [p_no_multiline, __] =
+        make_parser<buffer_mode, ss::quote<'"'>, Ts...>(f.name, ",");
+    while (!p.eof()) {
+        auto command = [&p_no_multiline = p_no_multiline] {
+            p_no_multiline.template get_next<int, double, std::string>();
+        };
+        expect_error_on_command(p_no_multiline, command);
+    }
+}
+
+TEST_CASE("parser test csv on multiple lines with quotes") {
+    test_quote_multiline<false>();
+    test_quote_multiline<false, ss::string_error>();
+    test_quote_multiline<false, ss::throw_on_error>();
+    test_quote_multiline<true>();
+    test_quote_multiline<true, ss::string_error>();
+    test_quote_multiline<true, ss::throw_on_error>();
+}
+
+static inline std::string no_escape(std::string& s) {
+    s.erase(std::remove(begin(s), end(s), '\\'), end(s));
+    return s;
+}
+
+template <bool buffer_mode, typename... Ts>
+void test_escape_multiline() {
+    unique_file_name f{"test_parser"};
+    std::vector<X> data = {{1, 2, "x\\\nx\\\r\nx"},
+                           {5, 6, "z\\\nz\\\nz"},
+                           {7, 8, "u"},
+                           {3, 4, "y\\\ny\\\ny"},
+                           {9, 10, "v\\\\"},
+                           {11, 12, "w\\\n"}};
+    for (auto& [_, __, s] : data) {
+        update_if_crlf(s);
+    }
+
+    make_and_write(f.name, data);
+    for (auto& [_, __, s] : data) {
+        s = no_escape(s);
+        if (s == "v") {
+            s = "v\\";
+        }
+    }
+
+    auto [p, _] =
+        make_parser<buffer_mode, ss::multiline, ss::escape<'\\'>, Ts...>(f.name,
+                                                                         ",");
+    std::vector<X> i;
+
+    while (!p.eof()) {
+        auto a = p.template get_next<int, double, std::string>();
+        i.emplace_back(ss::to_object<X>(a));
+    }
+
+    for (auto& [_, __, s] : i) {
+        update_if_crlf(s);
+    }
+    CHECK_EQ(i, data);
+
+    auto [p_no_multiline, __] =
+        make_parser<buffer_mode, ss::escape<'\\'>, Ts...>(f.name, ",");
+    while (!p.eof()) {
+        auto command = [&p_no_multiline = p_no_multiline] {
+            auto a =
+                p_no_multiline.template get_next<int, double, std::string>();
+        };
+        expect_error_on_command(p_no_multiline, command);
+    }
+}
+
+TEST_CASE("parser test csv on multiple lines with escapes") {
+    test_escape_multiline<false>();
+    test_escape_multiline<false, ss::string_error>();
+    test_escape_multiline<false, ss::throw_on_error>();
+    test_escape_multiline<true>();
+    test_escape_multiline<true, ss::string_error>();
+    test_escape_multiline<true, ss::throw_on_error>();
+}
+
+template <bool buffer_mode, typename... Ts>
+void test_quote_escape_multiline() {
+    unique_file_name f{"test_parser"};
+    {
+        std::ofstream out{f.name};
+        out << "1,2,\"just\\\n\nstrings\"" << std::endl;
+#ifndef _WIN32
+        out << "3,4,\"just\r\nsome\\\r\n\n\\\nstrings\"" << std::endl;
+        out << "5,6,\"just\\\n\\\r\n\r\n\nstrings" << std::endl;
+#else
+        out << "3,4,\"just\nsome\\\n\n\\\nstrings\"" << std::endl;
+        out << "5,6,\"just\\\n\\\n\n\nstrings" << std::endl;
+#endif
+        out << "7,8,\"just strings\"" << std::endl;
+        out << "9,10,just strings" << std::endl;
+    }
+    size_t bad_lines = 1;
+    auto num_errors = 0;
+
+    auto [p, _] = make_parser<buffer_mode, ss::multiline, ss::escape<'\\'>,
+                              ss::quote<'"'>, Ts...>(f.name);
+    std::vector<X> i;
+
+    while (!p.eof()) {
+        try {
+            auto a = p.template get_next<int, double, std::string>();
+            if (p.valid()) {
+                i.emplace_back(ss::to_object<X>(a));
+            } else {
+                ++num_errors;
+            }
+        } catch (const std::exception& e) {
+            ++num_errors;
+        }
+    }
+
+    CHECK(bad_lines == num_errors);
+
+    std::vector<X> data = {{1, 2, "just\n\nstrings"},
+#ifndef _WIN32
+                           {3, 4, "just\r\nsome\r\n\n\nstrings"},
+#else
+                           {3, 4, "just\nsome\n\n\nstrings"},
+#endif
+                           {9, 10, "just strings"}};
+
+    for (auto& [_, __, s] : i) {
+        update_if_crlf(s);
+    }
+    CHECK_EQ(i, data);
+}
+
+TEST_CASE("parser test csv on multiple lines with quotes and escapes") {
+    test_quote_escape_multiline<false>();
+    test_quote_escape_multiline<false, ss::string_error>();
+    test_quote_escape_multiline<false, ss::throw_on_error>();
+    test_quote_escape_multiline<true>();
+    test_quote_escape_multiline<true, ss::string_error>();
+    test_quote_escape_multiline<true, ss::throw_on_error>();
+}

test/test_parser1_3.cpp

@@ -0,0 +1,330 @@
+#include "test_parser1.hpp"
+
+template <bool buffer_mode, typename... Ts>
+void test_multiline_restricted() {
+    unique_file_name f{"test_parser"};
+    {
+        std::ofstream out{f.name};
+        out << "1,2,\"just\n\nstrings\"" << std::endl;
+#ifndef _WIN32
+        out << "3,4,\"ju\n\r\n\nnk\"" << std::endl;
+        out << "5,6,just\\\n\\\r\nstrings" << std::endl;
+#else
+        out << "3,4,\"ju\n\n\nnk\"" << std::endl;
+        out << "5,6,just\\\n\\\nstrings" << std::endl;
+#endif
+        out << "7,8,ju\\\n\\\n\\\nnk" << std::endl;
+        out << "9,10,\"just\\\n\nstrings\"" << std::endl;
+        out << "11,12,\"ju\\\n|\n\n\n\n\nk\"" << std::endl;
+        out << "13,14,\"ju\\\n\\\n15,16\"\\\n\\\\\n\nnk\"" << std::endl;
+        out << "17,18,\"ju\\\n\\\n\\\n\\\\\n\nnk\"" << std::endl;
+        out << "19,20,just strings" << std::endl;
+    }
+    auto bad_lines = 15;
+    auto num_errors = 0;
+
+    auto [p, _] =
+        make_parser<buffer_mode, ss::multiline_restricted<2>, ss::quote<'"'>,
+                    ss::escape<'\\'>, Ts...>(f.name, ",");
+    std::vector<X> i;
+
+    while (!p.eof()) {
+        try {
+            auto a = p.template get_next<int, double, std::string>();
+            if (p.valid()) {
+                i.emplace_back(ss::to_object<X>(a));
+            } else {
+                ++num_errors;
+            }
+        } catch (const std::exception& e) {
+            ++num_errors;
+        }
+    }
+
+    CHECK(bad_lines == num_errors);
+
+    std::vector<X> data = {{1, 2, "just\n\nstrings"},
+#ifndef _WIN32
+                           {5, 6, "just\n\r\nstrings"},
+#else
+                           {5, 6, "just\n\nstrings"},
+#endif
+                           {9, 10, "just\n\nstrings"},
+                           {19, 20, "just strings"}};
+
+    for (auto& [_, __, s] : i) {
+        update_if_crlf(s);
+    }
+
+    if (i.size() != data.size()) {
+        CHECK_EQ(i.size(), data.size());
+    }
+
+    CHECK_EQ(i, data);
+}
+
+TEST_CASE("parser test multiline restricted") {
+    test_multiline_restricted<false>();
+    test_multiline_restricted<false, ss::string_error>();
+    test_multiline_restricted<false, ss::throw_on_error>();
+    test_multiline_restricted<true>();
+    test_multiline_restricted<true, ss::string_error>();
+    test_multiline_restricted<true, ss::throw_on_error>();
+}
+
+template <bool buffer_mode, typename... Ts>
+void test_unterminated_line_impl(const std::vector<std::string>& lines,
+                                 size_t bad_line) {
+    unique_file_name f{"test_parser"};
+    std::ofstream out{f.name};
+    for (const auto& line : lines) {
+        out << line << std::endl;
+    }
+    out.close();
+
+    auto [p, _] = make_parser<buffer_mode, Ts...>(f.name);
+    size_t line = 0;
+    while (!p.eof()) {
+        auto command = [&p = p] {
+            p.template get_next<int, double, std::string>();
+        };
+
+        if (line == bad_line) {
+            expect_error_on_command(p, command);
+            break;
+        } else {
+            command();
+            CHECK(p.valid());
+            ++line;
+        }
+    }
+}
+
+template <typename... Ts>
+void test_unterminated_line(const std::vector<std::string>& lines,
+                            size_t bad_line) {
+    test_unterminated_line_impl<false, Ts...>(lines, bad_line);
+    test_unterminated_line_impl<false, Ts..., ss::string_error>(lines,
+                                                                bad_line);
+    test_unterminated_line_impl<false, Ts..., ss::throw_on_error>(lines,
+                                                                  bad_line);
+    test_unterminated_line_impl<true, Ts...>(lines, bad_line);
+    test_unterminated_line_impl<true, Ts..., ss::string_error>(lines, bad_line);
+    test_unterminated_line_impl<true, Ts..., ss::throw_on_error>(lines,
+                                                                 bad_line);
+}
+
+TEST_CASE("parser test csv on multiline with errors") {
+    using multiline = ss::multiline_restricted<3>;
+    using escape = ss::escape<'\\'>;
+    using quote = ss::quote<'"'>;
+
+    // unterminated escape
+    {
+        const std::vector<std::string> lines{"1,2,just\\"};
+        test_unterminated_line<multiline, escape>(lines, 0);
+        test_unterminated_line<multiline, escape, quote>(lines, 0);
+    }
+
+    {
+        const std::vector<std::string> lines{"1,2,just\\", "9,8,second"};
+        test_unterminated_line<multiline, escape>(lines, 0);
+        test_unterminated_line<multiline, escape, quote>(lines, 0);
+    }
+
+    {
+        const std::vector<std::string> lines{"9,8,first", "1,2,just\\"};
+        test_unterminated_line<multiline, escape>(lines, 1);
+        test_unterminated_line<multiline, escape, quote>(lines, 1);
+    }
+
+    {
+        const std::vector<std::string> lines{"9,8,first", "1,2,just\\",
+                                             "3,4,third"};
+        test_unterminated_line<multiline, escape>(lines, 1);
+        test_unterminated_line<multiline, escape, quote>(lines, 1);
+    }
+
+    {
+        const std::vector<std::string> lines{"9,8,first",
+                                             "1,2,just\\\nstrings\\",
+                                             "3,4,th\\\nird"};
+        test_unterminated_line<multiline, escape>(lines, 1);
+        test_unterminated_line<multiline, escape, quote>(lines, 1);
+    }
+
+    {
+        const std::vector<std::string> lines{"9,8,first", "3,4,second",
+                                             "1,2,just\\"};
+        test_unterminated_line<multiline, escape>(lines, 2);
+        test_unterminated_line<multiline, escape, quote>(lines, 2);
+    }
+
+    {
+        const std::vector<std::string> lines{"9,8,\\first", "3,4,second",
+                                             "1,2,jus\\t\\"};
+        test_unterminated_line<multiline, escape>(lines, 2);
+        test_unterminated_line<multiline, escape, quote>(lines, 2);
+    }
+
+    // unterminated quote
+    {
+        const std::vector<std::string> lines{"1,2,\"just"};
+        test_unterminated_line<multiline, escape, quote>(lines, 0);
+        test_unterminated_line<multiline, quote>(lines, 0);
+    }
+
+    {
+        const std::vector<std::string> lines{"1,2,\"just", "9,8,second"};
+        test_unterminated_line<multiline, escape, quote>(lines, 0);
+        test_unterminated_line<multiline, quote>(lines, 0);
+    }
+
+    {
+        const std::vector<std::string> lines{"9,8,first", "1,2,\"just"};
+        test_unterminated_line<multiline, escape, quote>(lines, 1);
+        test_unterminated_line<multiline, quote>(lines, 1);
+    }
+
+    {
+        const std::vector<std::string> lines{"9,8,first", "1,2,\"just",
+                                             "3,4,th\\,ird"};
+        test_unterminated_line<multiline, escape, quote>(lines, 1);
+        test_unterminated_line<multiline, quote>(lines, 1);
+    }
+
+    {
+        const std::vector<std::string> lines{"9,8,first", "3,4,second",
+                                             "1,2,\"just"};
+        test_unterminated_line<multiline, escape, quote>(lines, 2);
+        test_unterminated_line<multiline, quote>(lines, 2);
+    }
+
+    {
+        const std::vector<std::string> lines{"9,8,\"first\"",
+                                             "\"3\",4,\"sec,ond\"",
+                                             "1,2,\"ju\"\"st"};
+        test_unterminated_line<multiline, escape, quote>(lines, 2);
+        test_unterminated_line<multiline, quote>(lines, 2);
+    }
+
+    // unterminated quote and escape
+    {
+        const std::vector<std::string> lines{"1,2,\"just\\"};
+        test_unterminated_line<multiline, escape, quote>(lines, 0);
+        test_unterminated_line<multiline, escape, quote>(lines, 0);
+    }
+
+    {
+        const std::vector<std::string> lines{"1,2,\"just\\\n\\"};
+        test_unterminated_line<multiline, escape, quote>(lines, 0);
+    }
+
+    {
+        const std::vector<std::string> lines{"1,2,\"just\n\\"};
+        test_unterminated_line<multiline, escape, quote>(lines, 0);
+    }
+
+    {
+        const std::vector<std::string> lines{"9,8,first", "1,2,\"just\n\\"};
+        test_unterminated_line<multiline, escape, quote>(lines, 1);
+    }
+
+    {
+        const std::vector<std::string> lines{"9,8,first", "1,2,\"just\n\\",
+                                             "4,3,thrid"};
+        test_unterminated_line<multiline, escape, quote>(lines, 1);
+    }
+
+    {
+        const std::vector<std::string> lines{"9,8,f\\\nirst", "1,2,\"just\n\\",
+                                             "4,3,thrid"};
+        test_unterminated_line<multiline, escape, quote>(lines, 1);
+    }
+
+    {
+        const std::vector<std::string> lines{"9,8,\"f\ni\nrst\"",
+                                             "1,2,\"just\n\\", "4,3,thrid"};
+        test_unterminated_line<multiline, escape, quote>(lines, 1);
+    }
+
+    // multiline limmit reached escape
+    {
+        const std::vector<std::string> lines{"1,2,\\\n\\\n\\\n\\\njust"};
+        test_unterminated_line<multiline, escape>(lines, 0);
+        test_unterminated_line<multiline, escape, quote>(lines, 0);
+    }
+
+    {
+        const std::vector<std::string> lines{"9,8,first",
+                                             "1,2,\\\n\\\n\\\n\\\njust"};
+        test_unterminated_line<multiline, escape>(lines, 1);
+        test_unterminated_line<multiline, escape, quote>(lines, 1);
+    }
+
+    {
+        const std::vector<std::string> lines{"9,8,fi\\\nrs\\\nt",
+                                             "1,2,\\\n\\\n\\\n\\\njust"};
+        test_unterminated_line<multiline, escape>(lines, 1);
+        test_unterminated_line<multiline, escape, quote>(lines, 1);
+    }
+
+    {
+        const std::vector<std::string> lines{"9,8,first",
+                                             "1,2,\\\n\\\n\\\n\\\njust",
+                                             "4,3,third"};
+        test_unterminated_line<multiline, escape>(lines, 1);
+        test_unterminated_line<multiline, escape, quote>(lines, 1);
+    }
+
+    // multiline limmit reached quote
+    {
+        const std::vector<std::string> lines{"1,2,\"\n\n\n\n\njust\""};
+        test_unterminated_line<multiline, escape, quote>(lines, 0);
+        test_unterminated_line<multiline, quote>(lines, 0);
+    }
+
+    {
+        const std::vector<std::string> lines{"9,8,first",
+                                             "1,2,\"\n\n\n\n\njust\""};
+        test_unterminated_line<multiline, escape, quote>(lines, 1);
+        test_unterminated_line<multiline, quote>(lines, 1);
+    }
+
+    {
+        const std::vector<std::string> lines{"9,8,\"fir\nst\"",
+                                             "1,2,\"\n\n\n\n\njust\""};
+        test_unterminated_line<multiline, escape, quote>(lines, 1);
+        test_unterminated_line<multiline, quote>(lines, 1);
+    }
+
+    // multiline limmit reached quote and escape
+    {
+        const std::vector<std::string> lines{"1,2,\"\\\n\n\\\n\\\n\\\njust"};
+        test_unterminated_line<multiline, escape, quote>(lines, 0);
+    }
+
+    {
+        const std::vector<std::string> lines{"9,8,first",
+                                             "1,2,\"\\\n\n\\\n\\\n\\\njust"};
+        test_unterminated_line<multiline, escape, quote>(lines, 1);
+    }
+
+    {
+        const std::vector<std::string> lines{"9,8,fi\\\nrst",
+                                             "1,2,\"\\\n\n\\\n\\\n\\\njust"};
+        test_unterminated_line<multiline, escape, quote>(lines, 1);
+    }
+
+    {
+        const std::vector<std::string> lines{"9,8,\"fi\nrst\"",
+                                             "1,2,\"\\\n\n\\\n\\\n\\\njust"};
+        test_unterminated_line<multiline, escape, quote>(lines, 1);
+    }
+
+    {
+        const std::vector<std::string> lines{"9,8,\"fi\nr\\\nst\"",
+                                             "1,2,\"\\\n\n\\\n\\\n\\\njust"};
+        test_unterminated_line<multiline, escape, quote>(lines, 1);
+    }
+}

test/test_parser1_4.cpp

@@ -0,0 +1,501 @@
+#include "test_parser1.hpp"
+
+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>...> {};
+
+template <bool buffer_mode, typename Setup, typename... Ts>
+static void test_fields_impl(const std::string file_name,
+                             const std::vector<X>& data,
+                             const std::vector<std::string>& fields) {
+    using CaseType = std::tuple<Ts...>;
+
+    auto [p, _] = make_parser<buffer_mode, Setup>(file_name, ",");
+    CHECK_FALSE(p.field_exists("Unknown"));
+    p.use_fields(fields);
+    std::vector<CaseType> i;
+
+    for (const auto& a : p.template iterate<CaseType>()) {
+        i.push_back(a);
+    }
+
+    CHECK_EQ(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);
+        }
+    }
+}
+
+template <typename... Ts>
+static void test_fields(const std::string file_name, const std::vector<X>& data,
+                        const std::vector<std::string>& fields) {
+    test_fields_impl<false, ss::setup<>, Ts...>(file_name, data, fields);
+    test_fields_impl<false, ss::setup<ss::string_error>, Ts...>(file_name, data,
+                                                                fields);
+    test_fields_impl<false, ss::setup<ss::throw_on_error>, Ts...>(file_name,
+                                                                  data, fields);
+    test_fields_impl<true, ss::setup<>, Ts...>(file_name, data, fields);
+    test_fields_impl<true, ss::setup<ss::string_error>, Ts...>(file_name, data,
+                                                               fields);
+    test_fields_impl<true, ss::setup<ss::throw_on_error>, Ts...>(file_name,
+                                                                 data, fields);
+}
+
+TEST_CASE("parser test various cases with header") {
+    unique_file_name f{"test_parser"};
+    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)
+        */
+
+    test_fields<str>(o, d, {Str});
+    test_fields<int>(o, d, {Int});
+    test_fields<double>(o, d, {Dbl});
+    test_fields<str, int>(o, d, {Str, Int});
+    test_fields<str, double>(o, d, {Str, Dbl});
+    test_fields<int, str>(o, d, {Int, Str});
+    test_fields<int, double>(o, d, {Int, Dbl});
+    test_fields<double, str>(o, d, {Dbl, Str});
+    test_fields<double, int>(o, d, {Dbl, Int});
+    test_fields<str, int, double>(o, d, {Str, Int, Dbl});
+    test_fields<str, double, int>(o, d, {Str, Dbl, Int});
+    test_fields<int, str, double>(o, d, {Int, Str, Dbl});
+    test_fields<int, double, str>(o, d, {Int, Dbl, Str});
+    test_fields<double, str, int>(o, d, {Dbl, Str, Int});
+    test_fields<double, int, str>(o, d, {Dbl, Int, Str});
+}
+
+template <bool buffer_mode, typename... Ts>
+void test_invalid_fields_impl(const std::vector<std::string>& lines,
+                              const std::vector<std::string>& fields) {
+    unique_file_name f{"test_parser"};
+    {
+        std::ofstream out{f.name};
+        for (const auto& line : lines) {
+            out << line << std::endl;
+        }
+    }
+
+    {
+        // No fields specified
+        auto [p, _] = make_parser<buffer_mode, Ts...>(f.name, ",");
+        auto command = [&p = p] { p.use_fields(); };
+        expect_error_on_command(p, command);
+    }
+
+    {
+        // Unknown field
+        auto [p, _] = make_parser<buffer_mode, Ts...>(f.name, ",");
+        auto command = [&p = p] { p.use_fields("Unknown"); };
+        expect_error_on_command(p, command);
+    }
+
+    {
+        // Field used multiple times
+        auto [p, _] = make_parser<buffer_mode, Ts...>(f.name, ",");
+        auto command = [&p = p, &fields = fields] {
+            p.use_fields(fields.at(0), fields.at(0));
+        };
+        if (!fields.empty()) {
+            expect_error_on_command(p, command);
+        }
+    }
+
+    {
+        // Mapping out of range
+        auto [p, _] = make_parser<buffer_mode, Ts...>(f.name, ",");
+        auto command = [&p = p, &fields = fields] {
+            p.use_fields(fields.at(0));
+            p.template get_next<std::string, std::string>();
+        };
+        if (!fields.empty()) {
+            expect_error_on_command(p, command);
+        }
+    }
+
+    {
+        // Invalid header
+        auto [p, _] = make_parser<buffer_mode, Ts...>(f.name, ",");
+        auto command = [&p = p, &fields = fields] { p.use_fields(fields); };
+
+        if (!fields.empty()) {
+            // Pass if there are no duplicates, fail otherwise
+            if (std::unordered_set<std::string>{fields.begin(), fields.end()}
+                    .size() != fields.size()) {
+                expect_error_on_command(p, command);
+            } else {
+                command();
+                CHECK(p.valid());
+                if (!p.valid()) {
+                    if constexpr (ss::setup<Ts...>::string_error) {
+                        std::cout << p.error_msg() << std::endl;
+                    }
+                }
+            }
+        }
+    }
+}
+
+template <typename... Ts>
+void test_invalid_fields(const std::vector<std::string>& lines,
+                         const std::vector<std::string>& fields) {
+    test_invalid_fields_impl<false>(lines, fields);
+    test_invalid_fields_impl<false, ss::string_error>(lines, fields);
+    test_invalid_fields_impl<false, ss::throw_on_error>(lines, fields);
+    test_invalid_fields_impl<true>(lines, fields);
+    test_invalid_fields_impl<true, ss::string_error>(lines, fields);
+    test_invalid_fields_impl<true, ss::throw_on_error>(lines, fields);
+}
+
+TEST_CASE("parser test invalid header fields usage") {
+    test_invalid_fields({}, {});
+
+    test_invalid_fields({"Int"}, {"Int"});
+    test_invalid_fields({"Int", "1"}, {"Int"});
+    test_invalid_fields({"Int", "1", "2"}, {"Int"});
+
+    test_invalid_fields({"Int,String"}, {"Int", "String"});
+    test_invalid_fields({"Int,String", "1,hi"}, {"Int", "String"});
+    test_invalid_fields({"Int,String", "2,hello"}, {"Int", "String"});
+
+    test_invalid_fields({"Int,String,Double"}, {"Int", "String", "Double"});
+    test_invalid_fields({"Int,String,Double", "1,hi,2.34"},
+                        {"Int", "String", "Double"});
+    test_invalid_fields({"Int,String,Double", "1,hi,2.34", "2,hello,3.45"},
+                        {"Int", "String", "Double"});
+
+    test_invalid_fields({"Int,Int,Int"}, {"Int", "Int", "Int"});
+    test_invalid_fields({"Int,Int,Int", "1,2,3"}, {"Int", "Int", "Int"});
+
+    test_invalid_fields({"Int,String,Int"}, {"Int", "String", "Int"});
+    test_invalid_fields({"Int,String,Int", "1,hi,3"}, {"Int", "String", "Int"});
+}
+
+template <bool buffer_mode, typename... Ts>
+void test_invalid_rows_with_header() {
+    unique_file_name f{"test_parser"};
+    {
+        std::ofstream out{f.name};
+        out << "Int,String,Double" << std::endl;
+        out << "1,line1,2.34" << std::endl;
+        out << "2,line2" << std::endl;
+        out << "3,line3,67.8" << std::endl;
+        out << "4,line4,67.8,9" << std::endl;
+        out << "5,line5,9.10" << std::endl;
+        out << "six,line6,10.11" << std::endl;
+    }
+
+    {
+        auto [p, _] = make_parser<buffer_mode, Ts...>(f.name);
+
+        p.use_fields("Int", "String", "Double");
+        using data = std::tuple<int, std::string, double>;
+        std::vector<data> i;
+
+        CHECK(p.valid());
+
+        while (!p.eof()) {
+            try {
+                const auto& t = p.template get_next<data>();
+                if (p.valid()) {
+                    i.push_back(t);
+                }
+            } catch (const ss::exception&) {
+                continue;
+            }
+        }
+
+        std::vector<data> expected = {{1, "line1", 2.34},
+                                      {3, "line3", 67.8},
+                                      {5, "line5", 9.10}};
+        CHECK_EQ(i, expected);
+    }
+
+    {
+        auto [p, _] = make_parser<buffer_mode, Ts...>(f.name);
+
+        p.use_fields("Double", "Int");
+        using data = std::tuple<double, int>;
+        std::vector<data> i;
+
+        CHECK(p.valid());
+
+        while (!p.eof()) {
+            try {
+                const auto& t = p.template get_next<data>();
+                if (p.valid()) {
+                    i.push_back(t);
+                }
+            } catch (const ss::exception&) {
+                continue;
+            }
+        }
+
+        std::vector<data> expected = {{2.34, 1}, {67.8, 3}, {9.10, 5}};
+        CHECK_EQ(i, expected);
+    }
+
+    {
+        auto [p, _] = make_parser<buffer_mode, Ts...>(f.name);
+
+        p.use_fields("String", "Double");
+        using data = std::tuple<std::string, double>;
+        std::vector<data> i;
+
+        CHECK(p.valid());
+
+        while (!p.eof()) {
+            try {
+                const auto& t = p.template get_next<data>();
+                if (p.valid()) {
+                    i.push_back(t);
+                }
+            } catch (const ss::exception&) {
+                continue;
+            }
+        }
+
+        std::vector<data> expected = {{"line1", 2.34},
+                                      {"line3", 67.8},
+                                      {"line5", 9.10},
+                                      {"line6", 10.11}};
+        CHECK_EQ(i, expected);
+    }
+}
+
+TEST_CASE("parser test invalid rows with header") {
+    test_invalid_rows_with_header<false>();
+    test_invalid_rows_with_header<false, ss::string_error>();
+    test_invalid_rows_with_header<false, ss::throw_on_error>();
+    test_invalid_rows_with_header<true>();
+    test_invalid_rows_with_header<true, ss::string_error>();
+    test_invalid_rows_with_header<true, ss::throw_on_error>();
+}
+
+template <bool buffer_mode, typename... Ts>
+void test_ignore_empty_impl(const std::vector<X>& data) {
+    unique_file_name f{"test_parser"};
+    make_and_write(f.name, data);
+
+    std::vector<X> expected;
+    for (const auto& d : data) {
+        if (d.s != X::empty) {
+            expected.push_back(d);
+        }
+    }
+
+    {
+        auto [p, _] =
+            make_parser<buffer_mode, ss::ignore_empty, Ts...>(f.name, ",");
+
+        std::vector<X> i;
+        for (const auto& a : p.template iterate<X>()) {
+            i.push_back(a);
+        }
+
+        CHECK_EQ(i, expected);
+    }
+
+    {
+        auto [p, _] = make_parser<buffer_mode, Ts...>(f.name, ",");
+        std::vector<X> i;
+        size_t n = 0;
+        while (!p.eof()) {
+            try {
+                ++n;
+                const auto& a = p.template get_next<X>();
+                if (data.at(n - 1).s == X::empty) {
+                    CHECK_FALSE(p.valid());
+                    continue;
+                }
+                i.push_back(a);
+            } catch (...) {
+                CHECK_EQ(data.at(n - 1).s, X::empty);
+            }
+        }
+
+        CHECK_EQ(i, expected);
+    }
+}
+
+template <typename... Ts>
+void test_ignore_empty(const std::vector<X>& data) {
+    test_ignore_empty_impl<false>(data);
+    test_ignore_empty_impl<false, ss::string_error>(data);
+    test_ignore_empty_impl<false, ss::throw_on_error>(data);
+    test_ignore_empty_impl<true>(data);
+    test_ignore_empty_impl<true, ss::string_error>(data);
+    test_ignore_empty_impl<true, ss::throw_on_error>(data);
+}
+
+TEST_CASE("parser test various cases with empty lines") {
+    test_ignore_empty({{1, 2, "x"}, {3, 4, "y"}, {9, 10, "v"}, {11, 12, "w"}});
+
+    test_ignore_empty(
+        {{1, 2, X::empty}, {3, 4, "y"}, {9, 10, "v"}, {11, 12, "w"}});
+
+    test_ignore_empty(
+        {{1, 2, "x"}, {3, 4, "y"}, {9, 10, "v"}, {11, 12, X::empty}});
+
+    test_ignore_empty(
+        {{1, 2, "x"}, {5, 6, X::empty}, {9, 10, "v"}, {11, 12, "w"}});
+
+    test_ignore_empty(
+        {{1, 2, X::empty}, {5, 6, X::empty}, {9, 10, "v"}, {11, 12, "w"}});
+
+    test_ignore_empty(
+        {{1, 2, X::empty}, {3, 4, "y"}, {9, 10, "v"}, {11, 12, X::empty}});
+
+    test_ignore_empty(
+        {{1, 2, "x"}, {3, 4, "y"}, {9, 10, X::empty}, {11, 12, X::empty}});
+
+    test_ignore_empty(
+        {{1, 2, X::empty}, {3, 4, "y"}, {9, 10, X::empty}, {11, 12, X::empty}});
+
+    test_ignore_empty({{1, 2, X::empty},
+                       {3, 4, X::empty},
+                       {9, 10, X::empty},
+                       {11, 12, X::empty}});
+
+    test_ignore_empty(
+        {{1, 2, "x"}, {3, 4, X::empty}, {9, 10, X::empty}, {11, 12, X::empty}});
+
+    test_ignore_empty(
+        {{1, 2, X::empty}, {3, 4, X::empty}, {9, 10, X::empty}, {11, 12, "w"}});
+
+    test_ignore_empty({{11, 12, X::empty}});
+
+    test_ignore_empty({});
+}

test/test_parser2.hpp

@@ -121,7 +121,7 @@ column make_column(const std::string& input_header,
 }
 
 [[maybe_unused]] void replace_all2(std::string& s, const std::string& old_value,
-                  const std::string& new_value) {
+                                   const std::string& new_value) {
     for (size_t i = 0; i < 999; ++i) {
         size_t pos = s.find(old_value);
         if (pos == std::string::npos) {
@@ -257,9 +257,12 @@ std::vector<std::string> generate_csv_data(const std::vector<field>& data,
 }
 
 [[maybe_unused]] void write_to_file(const std::vector<std::string>& data,
-                   const std::string& delim, const std::string& file_name) {
+                                    const std::string& delim,
+                                    const std::string& file_name,
+                                    bool add_new_line = true) {
     std::ofstream out{file_name, std::ios_base::app};
     std::string line;
+
     for (size_t i = 0; i < data.size(); ++i) {
         line += data[i];
         if (i != data.size() - 1) {
@@ -267,7 +270,10 @@ std::vector<std::string> generate_csv_data(const std::vector<field>& data,
         }
     }
 
-    out << line << std::endl;
+    out << line;
+    if (add_new_line) {
+        out << std::endl;
+    }
 }
 
 #define CHECK_EQ_CRLF(V1, V2)                                                  \
@@ -299,7 +305,7 @@ std::vector<std::string> generate_csv_data(const std::vector<field>& data,
         CHECK(V1 == V2);                                                       \
     }
 
-template <typename... Ts>
+template <bool buffer_mode, typename... Ts>
 void test_data_combinations(const std::vector<column>& input_data,
                             const std::string& delim, bool include_header) {
     using setup = ss::setup<Ts...>;
@@ -329,7 +335,11 @@ void test_data_combinations(const std::vector<column>& input_data,
 
     if (include_header) {
         auto header_data = generate_csv_data<Ts...>(field_header, delim);
-        write_to_file(header_data, delim, f.name);
+        if (input_data.size() == 0 && rand() % 10 == 0) {
+            write_to_file(header_data, delim, f.name, false);
+        } else {
+            write_to_file(header_data, delim, f.name);
+        }
     }
 
     std::vector<int> layout;
@@ -354,15 +364,12 @@ void test_data_combinations(const std::vector<column>& input_data,
 
         expected_data.push_back(raw_data);
         auto data = generate_csv_data<Ts...>(raw_data, delim);
-        write_to_file(data, delim, f.name);
 
-        /*
-        std::cout << "[.";
-        for (const auto& el : data) {
-            std::cout << el << '.';
+        if (i + 1 == n && rand() % 10 == 0) {
+            write_to_file(data, delim, f.name, false);
+        } else {
+            write_to_file(data, delim, f.name);
         }
-        std::cout << "]" << std::endl;
-        */
     }
 
     auto layout_combinations = include_header && !setup::ignore_header
@@ -388,7 +395,7 @@ void test_data_combinations(const std::vector<column>& input_data,
     }
 
     for (const auto& layout : unique_layout_combinations) {
-        ss::parser<setup> p{f.name, delim};
+        auto [p, _] = make_parser<buffer_mode, setup>(f.name, delim);
 
         if (include_header && !setup::ignore_header) {
             std::vector<std::string> fields;
@@ -409,7 +416,7 @@ void test_data_combinations(const std::vector<column>& input_data,
             REQUIRE(p.valid());
         }
 
-        auto check_error = [&p] {
+        auto check_error = [&p = p] {
             CHECK(p.valid());
             if (!p.valid()) {
                 if constexpr (setup::string_error) {
@@ -426,7 +433,6 @@ void test_data_combinations(const std::vector<column>& input_data,
                     auto s0 = p.template get_next<std::string>();
                     if (i < n) {
                         check_error();
-                        // std::cout << s0 << std::endl;
                         CHECK_EQ_CRLF(s0, expected_data[i][layout[0]].value);
                     } else {
                         CHECK(p.eof());
@@ -439,7 +445,6 @@ void test_data_combinations(const std::vector<column>& input_data,
                         p.template get_next<std::string, std::string>();
                     if (i < n) {
                         check_error();
-                        // std::cout << s0 << ' ' << s1 << std::endl;
                         CHECK_EQ_CRLF(s0, expected_data[i][layout[0]].value);
                         CHECK_EQ_CRLF(s1, expected_data[i][layout[1]].value);
                     } else {
@@ -454,8 +459,6 @@ void test_data_combinations(const std::vector<column>& input_data,
                                             std::string>();
                     if (i < n) {
                         check_error();
-                        // std::cout << s0 << ' ' << s1 << ' ' << s2 <<
-                        // std::endl;
                         CHECK_EQ_CRLF(s0, expected_data[i][layout[0]].value);
                         CHECK_EQ_CRLF(s1, expected_data[i][layout[1]].value);
                         CHECK_EQ_CRLF(s2, expected_data[i][layout[2]].value);
@@ -471,10 +474,6 @@ void test_data_combinations(const std::vector<column>& input_data,
                                             std::string, std::string>();
                     if (i < n) {
                         check_error();
-                        /*
-                        std::cout << s0 << ' ' << s1 << ' ' << s2 << ' ' << s3
-                                  << std::endl;
-                                  */
                         CHECK_EQ_CRLF(s0, expected_data[i][layout[0]].value);
                         CHECK_EQ_CRLF(s1, expected_data[i][layout[1]].value);
                         CHECK_EQ_CRLF(s2, expected_data[i][layout[2]].value);
@@ -492,9 +491,6 @@ void test_data_combinations(const std::vector<column>& input_data,
                                             std::string>();
                     if (i < n) {
                         check_error();
-                        // std::cout << s0 << ' ' << s1 << ' ' << s2 << ' ' <<
-                        // s3
-                        //  << ' ' << s4 << std::endl;
                         CHECK_EQ_CRLF(s0, expected_data[i][layout[0]].value);
                         CHECK_EQ_CRLF(s1, expected_data[i][layout[1]].value);
                         CHECK_EQ_CRLF(s2, expected_data[i][layout[2]].value);
@@ -570,8 +566,14 @@ void test_option_combinations() {
                  {columns0, columns1, columns2, columns3, columns4, columns5,
                   columns6, columns7}) {
                 try {
-                    test_data_combinations<Ts...>(columns, delimiter, false);
-                    test_data_combinations<Ts...>(columns, delimiter, true);
+                    test_data_combinations<false, Ts...>(columns, delimiter,
+                                                         false);
+                    test_data_combinations<false, Ts...>(columns, delimiter,
+                                                         true);
+                    test_data_combinations<true, Ts...>(columns, delimiter,
+                                                        false);
+                    test_data_combinations<true, Ts...>(columns, delimiter,
+                                                        true);
                 } catch (std::exception& e) {
                     std::cout << typeid(ss::parser<Ts...>).name() << std::endl;
                     FAIL_CHECK(std::string{e.what()});
@@ -616,6 +618,7 @@ void test_option_combinations3() {
 
 } /* namespace */
 
+// Tests split into multiple compilation units
 #if 0
 
 TEST_CASE("parser test various cases version 2 segment 1") {
@@ -627,25 +630,33 @@ TEST_CASE("parser test various cases version 2 segment 1") {
     using multiline_r = ss::multiline_restricted<10>;
     using trimr = ss::trim_right<' '>;
     using triml = ss::trim_left<' '>;
+    using trim = ss::trim<' '>;
 
     // segment 1
     test_option_combinations3<>();
     test_option_combinations3<escape>();
-    test_option_combinations3<quote>();
 
     // segment 2
+    test_option_combinations3<quote>();
     test_option_combinations3<escape, quote>();
+
+    // segment 3
     test_option_combinations3<escape, multiline>();
     test_option_combinations3<quote, multiline>();
 
-    // segment 3
+    // segment 4
     test_option_combinations3<escape, quote, multiline>();
     test_option_combinations3<escape, quote, multiline_r>();
 
-    // segment 4
+    // segment 5
     test_option_combinations<escape, quote, multiline, triml>();
     test_option_combinations<escape, quote, multiline, trimr>();
+
+    // segment 6
+    test_option_combinations3<escape, quote, multiline>();
+    test_option_combinations3<escape, quote, multiline, trim>();
 #else
+
     test_option_combinations3<escape, quote, multiline>();
 #endif
 }

test/test_parser2_1.cpp

@@ -3,12 +3,10 @@
 
 TEST_CASE("parser test various cases version 2 segment 1") {
 #ifdef CMAKE_GITHUB_CI
-    using quote = ss::quote<'"'>;
     using escape = ss::escape<'\\'>;
 
     test_option_combinations3<>();
     test_option_combinations3<escape>();
-    test_option_combinations3<quote>();
 #endif
 }
 

test/test_parser2_2.cpp

@@ -5,11 +5,9 @@ TEST_CASE("parser test various cases version 2 segment 2") {
 #ifdef CMAKE_GITHUB_CI
     using quote = ss::quote<'"'>;
     using escape = ss::escape<'\\'>;
-    using multiline = ss::multiline;
 
+    test_option_combinations3<quote>();
     test_option_combinations3<escape, quote>();
-    test_option_combinations3<escape, multiline>();
-    test_option_combinations3<quote, multiline>();
 #endif
 }
 

test/test_parser2_3.cpp

@@ -6,10 +6,9 @@ TEST_CASE("parser test various cases version 2 segment 3") {
     using quote = ss::quote<'"'>;
     using escape = ss::escape<'\\'>;
     using multiline = ss::multiline;
-    using multiline_r = ss::multiline_restricted<10>;
 
-    test_option_combinations3<escape, quote, multiline>();
-    test_option_combinations3<escape, quote, multiline_r>();
+    test_option_combinations3<escape, multiline>();
+    test_option_combinations3<quote, multiline>();
 #endif
 }
 

test/test_parser2_4.cpp

@@ -2,18 +2,14 @@
 #include "test_parser2.hpp"
 
 TEST_CASE("parser test various cases version 2 segment 4") {
+#ifdef CMAKE_GITHUB_CI
     using quote = ss::quote<'"'>;
     using escape = ss::escape<'\\'>;
     using multiline = ss::multiline;
+    using multiline_r = ss::multiline_restricted<10>;
 
-#ifdef CMAKE_GITHUB_CI
-    using trimr = ss::trim_right<' '>;
-    using triml = ss::trim_left<' '>;
-
-    test_option_combinations<escape, quote, multiline, triml>();
-    test_option_combinations<escape, quote, multiline, trimr>();
-#else
     test_option_combinations3<escape, quote, multiline>();
+    test_option_combinations3<escape, quote, multiline_r>();
 #endif
 }
 

test/test_parser2_5.cpp

@@ -0,0 +1,16 @@
+#define SEGMENT_NAME "segment5"
+#include "test_parser2.hpp"
+
+TEST_CASE("parser test various cases version 2 segment 5") {
+#ifdef CMAKE_GITHUB_CI
+    using quote = ss::quote<'"'>;
+    using escape = ss::escape<'\\'>;
+    using multiline = ss::multiline;
+    using trimr = ss::trim_right<' '>;
+    using triml = ss::trim_left<' '>;
+
+    test_option_combinations<escape, quote, multiline, triml>();
+    test_option_combinations<escape, quote, multiline, trimr>();
+#endif
+}
+

test/test_parser2_6.cpp

@@ -0,0 +1,11 @@
+#define SEGMENT_NAME "segment6"
+#include "test_parser2.hpp"
+
+TEST_CASE("parser test various cases version 2 segment 6") {
+    using quote = ss::quote<'"'>;
+    using escape = ss::escape<'\\'>;
+    using multiline = ss::multiline;
+
+    test_option_combinations3<escape, quote, multiline>();
+}
+

test/test_splitter.cpp

@@ -775,6 +775,23 @@ TEST_CASE("splitter test resplit unterminated quote") {
             CHECK_EQ(words(vec), expected);
         }
     }
+
+    {
+        ss::converter<ss::quote<'"'>, ss::escape<'\\'>, ss::multiline> c;
+        auto& s = c.splitter;
+        auto vec = expect_unterminated_quote(s, R"("just\"some","ra)");
+        std::vector<std::string> expected{"just\"some"};
+        auto w = words(vec);
+        w.pop_back();
+        CHECK_EQ(w, expected);
+        REQUIRE(s.unterminated_quote());
+        {
+            auto new_line = buff.append(R"(n,dom",str\"ings)");
+            // invalid resplit size
+            vec = c.resplit(new_line, 4);
+            CHECK(!s.valid());
+        }
+    }
 }
 
 TEST_CASE("splitter test resplit unterminated quote with exceptions") {
@@ -1040,47 +1057,57 @@ TEST_CASE("splitter test resplit unterminated quote with exceptions") {
     }
 }
 
-TEST_CASE("splitter test invalid splits") {
-    ss::converter<ss::string_error, ss::quote<'"'>, ss::trim<' '>,
-                  ss::escape<'\\'>>
-        c;
+template <typename... Ts>
+void test_invalid_splits() {
+    ss::converter<ss::quote<'"'>, ss::trim<' '>, ss::escape<'\\'>, Ts...> c;
     auto& s = c.splitter;
 
+    auto check_error_msg = [&] {
+        if constexpr (ss::setup<Ts...>::string_error) {
+            CHECK_FALSE(s.error_msg().empty());
+        }
+    };
+
     // empty delimiter
     s.split(buff("some,random,strings"), "");
     CHECK_FALSE(s.valid());
     CHECK_FALSE(s.unterminated_quote());
-    CHECK_FALSE(s.error_msg().empty());
+    check_error_msg();
 
     // mismatched delimiter
     s.split(buff(R"(some,"random,"strings")"));
     CHECK_FALSE(s.valid());
     CHECK_FALSE(s.unterminated_quote());
-    CHECK_FALSE(s.error_msg().empty());
+    check_error_msg();
 
     // unterminated escape
     s.split(buff(R"(some,random,strings\)"));
     CHECK_FALSE(s.valid());
     CHECK_FALSE(s.unterminated_quote());
-    CHECK_FALSE(s.error_msg().empty());
+    check_error_msg();
 
     // unterminated escape
     s.split(buff(R"(some,random,"strings\)"));
     CHECK_FALSE(s.valid());
     CHECK_FALSE(s.unterminated_quote());
-    CHECK_FALSE(s.error_msg().empty());
+    check_error_msg();
 
     // unterminated quote
     s.split(buff("some,random,\"strings"));
     CHECK_FALSE(s.valid());
     CHECK(s.unterminated_quote());
-    CHECK_FALSE(s.error_msg().empty());
+    check_error_msg();
 
     // invalid resplit
     char new_line[] = "some";
     c.resplit(new_line, strlen(new_line));
     CHECK_FALSE(s.valid());
-    CHECK_FALSE(s.error_msg().empty());
+    check_error_msg();
+}
+
+TEST_CASE("splitter test invalid splits") {
+    test_invalid_splits();
+    test_invalid_splits<ss::string_error>();
 }
 
 TEST_CASE("splitter test invalid splits with exceptions") {