ado/ssp
1
1
Fork 0
mirror of https://github.com/red0124/ssp.git synced 2025-01-23 04:55:20 +01:00
Code Issues Packages Projects Releases Wiki Activity

Updated and added new functions related to headers, resolved ODR issues, resolved clang-tidy warnings (#50)

Browse Source 
* Bugfix/odr violations (#47)

* Make common non-member functions inline, remove unreachable line from get_line_buffer

* [skip ci] Fix namespace comments

* Resolve clang-tidy warnings (#48)

* Resolve clang-tidy warnings, update single_header_generator.py

* Update single header test, resolve additional clang-tidy warnings

* Add header and raw_header methods,  update header usage methods error handling, write new and update existing unit tests

* Update parser error messages, fix parser tests

* Add [[nodiscard]] where fitting, update unit tests (#49)

* Add const where fitting, make splitter class members private, add #pragma once to ssp.hpp

* Modify header parsing for empty headers, update old and add new tests for header parsing

* Enable the parser to accept a header with one empty field, update unit tests

* Fix test CMakeLists.txt typo
This commit is contained in:
red0124 2024-03-14 17:22:57 +01:00 committed by GitHub
parent 1b9a01f787
commit 55d0a4e598
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
35 changed files with 1303 additions and 744 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.gitignore vendored
View File

@ -1,6 +1,8 @@
compile_commands.json compile_commands.json
.clang-format .clang-format
.ccls-cache/* .clang-tidy
.ccls-cache/
.cache/
experiment/ experiment/
build/ build/
hbuild/ hbuild/

55
include/ss/common.hpp
View File

@ -1,11 +1,15 @@
#pragma once #pragma once
#include <cerrno> #include <cerrno>
#include <cstdint>
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
#include <cstring> #include <cstring>
#include <vector> #include <vector>
#if !__unix__
#include <array>
#include <cstdint>
#endif
namespace ss { namespace ss {
struct none {}; struct none {};
@ -17,18 +21,18 @@ constexpr inline auto default_delimiter = ",";
constexpr inline auto get_line_initial_buffer_size = 128; constexpr inline auto get_line_initial_buffer_size = 128;
template <bool StringError> template <bool StringError>
inline void assert_string_error_defined() { void assert_string_error_defined() {
static_assert(StringError, static_assert(StringError,
"'string_error' needs to be enabled to use 'error_msg'"); "'string_error' needs to be enabled to use 'error_msg'");
} }
template <bool ThrowOnError> template <bool ThrowOnError>
inline void assert_throw_on_error_not_defined() { void assert_throw_on_error_not_defined() {
static_assert(!ThrowOnError, "cannot handle errors manually if " static_assert(!ThrowOnError, "cannot handle errors manually if "
"'throw_on_error' is enabled"); "'throw_on_error' is enabled");
} }
inline void* strict_realloc(void* ptr, size_t size) { [[nodiscard]] inline void* strict_realloc(void* ptr, size_t size) {
ptr = std::realloc(ptr, size); ptr = std::realloc(ptr, size);
if (!ptr) { if (!ptr) {
throw std::bad_alloc{}; throw std::bad_alloc{};
@ -38,18 +42,20 @@ inline void* strict_realloc(void* ptr, size_t size) {
} }
#if __unix__ #if __unix__
inline ssize_t get_line_file(char*& lineptr, size_t& n, FILE* file) { [[nodiscard]] inline ssize_t get_line_file(char*& lineptr, size_t& n,
FILE* file) {
return getline(&lineptr, &n, file); return getline(&lineptr, &n, file);
} }
#else #else
using ssize_t = intptr_t; using ssize_t = intptr_t;
ssize_t get_line_file(char*& lineptr, size_t& n, FILE* file) { [[nodiscard]] inline ssize_t get_line_file(char*& lineptr, size_t& n,
char buff[get_line_initial_buffer_size]; FILE* file) {
std::array<char, get_line_initial_buffer_size> buff;
if (lineptr == nullptr || n < sizeof(buff)) { if (lineptr == nullptr || n < sizeof(buff)) {
size_t new_n = sizeof(buff); const size_t new_n = sizeof(buff);
lineptr = static_cast<char*>(strict_realloc(lineptr, new_n)); lineptr = static_cast<char*>(strict_realloc(lineptr, new_n));
n = new_n; n = new_n;
} }
@ -57,17 +63,17 @@ ssize_t get_line_file(char*& lineptr, size_t& n, FILE* file) {
lineptr[0] = '\0'; lineptr[0] = '\0';
size_t line_used = 0; size_t line_used = 0;
while (std::fgets(buff, sizeof(buff), file) != nullptr) { while (std::fgets(buff.data(), sizeof(buff), file) != nullptr) {
line_used = std::strlen(lineptr); line_used = std::strlen(lineptr);
size_t buff_used = std::strlen(buff); size_t buff_used = std::strlen(buff.data());
if (n <= buff_used + line_used) { if (n <= buff_used + line_used) {
size_t new_n = n * 2; const size_t new_n = n * 2;
lineptr = static_cast<char*>(strict_realloc(lineptr, new_n)); lineptr = static_cast<char*>(strict_realloc(lineptr, new_n));
n = new_n; n = new_n;
} }
std::memcpy(lineptr + line_used, buff, buff_used); std::memcpy(lineptr + line_used, buff.data(), buff_used);
line_used += buff_used; line_used += buff_used;
lineptr[line_used] = '\0'; lineptr[line_used] = '\0';
@ -81,15 +87,16 @@ ssize_t get_line_file(char*& lineptr, size_t& n, FILE* file) {
#endif #endif
ssize_t get_line_buffer(char*& lineptr, size_t& n, [[nodiscard]] inline ssize_t get_line_buffer(char*& lineptr, size_t& n,
const char* const csv_data_buffer, size_t csv_data_size, const char* const csv_data_buffer,
size_t csv_data_size,
size_t& curr_char) { size_t& curr_char) {
if (curr_char >= csv_data_size) { if (curr_char >= csv_data_size) {
return -1; return -1;
} }
if (lineptr == nullptr || n < get_line_initial_buffer_size) { if (lineptr == nullptr || n < get_line_initial_buffer_size) {
auto new_lineptr = static_cast<char*>( auto* new_lineptr = static_cast<char*>(
strict_realloc(lineptr, get_line_initial_buffer_size)); strict_realloc(lineptr, get_line_initial_buffer_size));
lineptr = new_lineptr; lineptr = new_lineptr;
n = get_line_initial_buffer_size; n = get_line_initial_buffer_size;
@ -98,7 +105,7 @@ ssize_t get_line_buffer(char*& lineptr, size_t& n,
size_t line_used = 0; size_t line_used = 0;
while (curr_char < csv_data_size) { while (curr_char < csv_data_size) {
if (line_used + 1 >= n) { if (line_used + 1 >= n) {
size_t new_n = n * 2; const size_t new_n = n * 2;
char* new_lineptr = char* new_lineptr =
static_cast<char*>(strict_realloc(lineptr, new_n)); static_cast<char*>(strict_realloc(lineptr, new_n));
@ -114,19 +121,15 @@ ssize_t get_line_buffer(char*& lineptr, size_t& n,
} }
} }
if (line_used != 0) {
lineptr[line_used] = '\0'; lineptr[line_used] = '\0';
return line_used; return line_used;
} }
return -1; [[nodiscard]] inline std::tuple<ssize_t, bool> get_line(
} char*& buffer, size_t& buffer_size, FILE* file,
const char* const csv_data_buffer, size_t csv_data_size,
std::tuple<ssize_t, bool> get_line(char*& buffer, size_t& buffer_size, size_t& curr_char) {
FILE* file, ssize_t ssize = 0;
const char* const csv_data_buffer,
size_t csv_data_size, size_t& curr_char) {
ssize_t ssize;
if (file) { if (file) {
ssize = get_line_file(buffer, buffer_size, file); ssize = get_line_file(buffer, buffer_size, file);
curr_char += ssize; curr_char += ssize;
@ -145,4 +148,4 @@ std::tuple<ssize_t, bool> get_line(char*& buffer, size_t& buffer_size,
return {ssize, false}; return {ssize, false};
} }
} /* ss */ } /* namespace ss */

59
include/ss/converter.hpp
View File

@ -110,19 +110,19 @@ public:
// parses line with given delimiter, returns a 'T' object created with // parses line with given delimiter, returns a 'T' object created with
// extracted values of type 'Ts' // extracted values of type 'Ts'
template <typename T, typename... Ts> template <typename T, typename... Ts>
T convert_object(line_ptr_type line, [[nodiscard]] T convert_object(
const std::string& delim = default_delimiter) { line_ptr_type line, const std::string& delim = default_delimiter) {
return to_object<T>(convert<Ts...>(line, delim)); return to_object<T>(convert<Ts...>(line, delim));
} }
// parses line with given delimiter, returns tuple of objects with // parses line with given delimiter, returns tuple of objects with
// extracted values of type 'Ts' // extracted values of type 'Ts'
template <typename... Ts> template <typename... Ts>
no_void_validator_tup_t<Ts...> convert( [[nodiscard]] no_void_validator_tup_t<Ts...> convert(
line_ptr_type line, const std::string& delim = default_delimiter) { line_ptr_type line, const std::string& delim = default_delimiter) {
split(line, delim); split(line, delim);
if (splitter_.valid()) { if (splitter_.valid()) {
return convert<Ts...>(splitter_.split_data_); return convert<Ts...>(splitter_.get_split_data());
} else { } else {
handle_error_bad_split(); handle_error_bad_split();
return {}; return {};
@ -131,13 +131,13 @@ public:
// parses already split line, returns 'T' object with extracted values // parses already split line, returns 'T' object with extracted values
template <typename T, typename... Ts> template <typename T, typename... Ts>
T convert_object(const split_data& elems) { [[nodiscard]] T convert_object(const split_data& elems) {
return to_object<T>(convert<Ts...>(elems)); return to_object<T>(convert<Ts...>(elems));
} }
// same as above, but uses cached split line // same as above, but uses cached split line
template <typename T, typename... Ts> template <typename T, typename... Ts>
T convert_object() { [[nodiscard]] T convert_object() {
return to_object<T>(convert<Ts...>()); return to_object<T>(convert<Ts...>());
} }
@ -146,7 +146,8 @@ public:
// one argument is given which is a class which has a tied // one argument is given which is a class which has a tied
// method which returns a tuple, returns that type // method which returns a tuple, returns that type
template <typename T, typename... Ts> template <typename T, typename... Ts>
no_void_validator_tup_t<T, Ts...> convert(const split_data& elems) { [[nodiscard]] no_void_validator_tup_t<T, Ts...> convert(
const split_data& elems) {
if constexpr (sizeof...(Ts) == 0 && is_instance_of_v<std::tuple, T>) { if constexpr (sizeof...(Ts) == 0 && is_instance_of_v<std::tuple, T>) {
return convert_impl(elems, static_cast<T*>(nullptr)); return convert_impl(elems, static_cast<T*>(nullptr));
} else if constexpr (tied_class_v<T, Ts...>) { } else if constexpr (tied_class_v<T, Ts...>) {
@ -162,11 +163,11 @@ public:
// same as above, but uses cached split line // same as above, but uses cached split line
template <typename T, typename... Ts> template <typename T, typename... Ts>
no_void_validator_tup_t<T, Ts...> convert() { [[nodiscard]] no_void_validator_tup_t<T, Ts...> convert() {
return convert<T, Ts...>(splitter_.split_data_); return convert<T, Ts...>(splitter_.get_split_data());
} }
bool valid() const { [[nodiscard]] bool valid() const {
if constexpr (string_error) { if constexpr (string_error) {
return error_.empty(); return error_.empty();
} else if constexpr (throw_on_error) { } else if constexpr (throw_on_error) {
@ -176,12 +177,12 @@ public:
} }
} }
const std::string& error_msg() const { [[nodiscard]] const std::string& error_msg() const {
assert_string_error_defined<string_error>(); assert_string_error_defined<string_error>();
return error_; return error_;
} }
bool unterminated_quote() const { [[nodiscard]] bool unterminated_quote() const {
return splitter_.unterminated_quote(); return splitter_.unterminated_quote();
} }
@ -189,9 +190,9 @@ public:
// contain the beginnings and the ends of each column of the string // contain the beginnings and the ends of each column of the string
const split_data& split(line_ptr_type line, const split_data& split(line_ptr_type line,
const std::string& delim = default_delimiter) { const std::string& delim = default_delimiter) {
splitter_.split_data_.clear(); splitter_.clear_split_data();
if (line[0] == '\0') { if (line[0] == '\0') {
return splitter_.split_data_; return splitter_.get_split_data();
} }
return splitter_.split(line, delim); return splitter_.split(line, delim);
@ -207,7 +208,7 @@ private:
return splitter_.resplit(new_line, new_size, delim); return splitter_.resplit(new_line, new_size, delim);
} }
size_t size_shifted() { [[nodiscard]] size_t size_shifted() {
return splitter_.size_shifted(); return splitter_.size_shifted();
} }
@ -223,9 +224,11 @@ private:
} }
} }
std::string error_sufix(const string_range msg, size_t pos) const { [[nodiscard]] std::string error_sufix(const string_range msg,
size_t pos) const {
constexpr static auto reserve_size = 32;
std::string error; std::string error;
error.reserve(32); error.reserve(reserve_size);
error.append("at column ") error.append("at column ")
.append(std::to_string(pos + 1)) .append(std::to_string(pos + 1))
.append(": \'") .append(": \'")
@ -350,7 +353,8 @@ private:
//////////////// ////////////////
template <typename... Ts> template <typename... Ts>
no_void_validator_tup_t<Ts...> convert_impl(const split_data& elems) { [[nodiscard]] no_void_validator_tup_t<Ts...> convert_impl(
const split_data& elems) {
clear_error(); clear_error();
if (!splitter_.valid()) { if (!splitter_.valid()) {
@ -381,7 +385,7 @@ private:
} }
template <typename... Ts> template <typename... Ts>
no_void_validator_tup_t<std::tuple<Ts...>> convert_impl( [[nodiscard]] no_void_validator_tup_t<std::tuple<Ts...>> convert_impl(
const split_data& elems, const std::tuple<Ts...>*) { const split_data& elems, const std::tuple<Ts...>*) {
return convert_impl<Ts...>(elems); return convert_impl<Ts...>(elems);
} }
@ -390,11 +394,11 @@ private:
// column mapping // column mapping
//////////////// ////////////////
bool columns_mapped() const { [[nodiscard]] bool columns_mapped() const {
return column_mappings_.size() != 0; return !column_mappings_.empty();
} }
size_t column_position(size_t tuple_position) const { [[nodiscard]] size_t column_position(size_t tuple_position) const {
if (!columns_mapped()) { if (!columns_mapped()) {
return tuple_position; return tuple_position;
} }
@ -404,7 +408,7 @@ private:
// assumes positions are valid and the vector is not empty // assumes positions are valid and the vector is not empty
void set_column_mapping(std::vector<size_t> positions, void set_column_mapping(std::vector<size_t> positions,
size_t number_of_columns) { size_t number_of_columns) {
column_mappings_ = positions; column_mappings_ = std::move(positions);
number_of_columns_ = number_of_columns; number_of_columns_ = number_of_columns;
} }
@ -425,7 +429,7 @@ private:
} }
if constexpr (std::is_same_v<T, std::string>) { if constexpr (std::is_same_v<T, std::string>) {
extract(msg.first, msg.second, dst); static_cast<void>(extract(msg.first, msg.second, dst));
return; return;
} }
@ -471,7 +475,8 @@ private:
} }
template <typename... Ts> template <typename... Ts>
no_void_validator_tup_t<Ts...> extract_tuple(const split_data& elems) { [[nodiscard]] no_void_validator_tup_t<Ts...> extract_tuple(
const split_data& elems) {
static_assert(!all_of_v<std::is_void, Ts...>, static_assert(!all_of_v<std::is_void, Ts...>,
"at least one parameter must be non void"); "at least one parameter must be non void");
no_void_validator_tup_t<Ts...> ret{}; no_void_validator_tup_t<Ts...> ret{};
@ -490,7 +495,7 @@ private:
friend class parser; friend class parser;
std::vector<size_t> column_mappings_; std::vector<size_t> column_mappings_;
size_t number_of_columns_; size_t number_of_columns_{0};
}; };
} /* ss */ } /* namespace ss */

6
include/ss/exception.hpp
View File

@ -12,12 +12,12 @@ class exception : public std::exception {
std::string msg_; std::string msg_;
public: public:
exception(const std::string& msg): msg_{msg} { exception(std::string msg) : msg_{std::move(msg)} {
} }
virtual char const* what() const noexcept { [[nodiscard]] char const* what() const noexcept override {
return msg_.c_str(); return msg_.c_str();
} }
}; };
} /* ss */ } /* namespace ss */

72
include/ss/extract.hpp
View File

@ -2,8 +2,8 @@
#include "type_traits.hpp" #include "type_traits.hpp"
#include <charconv> #include <charconv>
#include <cstdint>
#include <cstring> #include <cstring>
#include <functional>
#include <optional> #include <optional>
#include <string> #include <string>
#include <string_view> #include <string_view>
@ -13,6 +13,7 @@
#include <fast_float/fast_float.h> #include <fast_float/fast_float.h>
#else #else
#include <algorithm> #include <algorithm>
#include <array>
#include <cstdlib> #include <cstdlib>
#endif #endif
@ -25,8 +26,8 @@ namespace ss {
#ifndef SSP_DISABLE_FAST_FLOAT #ifndef SSP_DISABLE_FAST_FLOAT
template <typename T> template <typename T>
std::enable_if_t<std::is_floating_point_v<T>, std::optional<T>> to_num( [[nodiscard]] std::enable_if_t<std::is_floating_point_v<T>, std::optional<T>>
const char* const begin, const char* const end) { to_num(const char* const begin, const char* const end) {
T ret; T ret;
auto [ptr, ec] = fast_float::from_chars(begin, end, ret); auto [ptr, ec] = fast_float::from_chars(begin, end, ret);
@ -39,22 +40,23 @@ std::enable_if_t<std::is_floating_point_v<T>, std::optional<T>> to_num(
#else #else
template <typename T> template <typename T>
std::enable_if_t<std::is_floating_point_v<T>, std::optional<T>> to_num( [[nodiscard]] std::enable_if_t<std::is_floating_point_v<T>, std::optional<T>>
const char* const begin, const char* const end) { to_num(const char* const begin, const char* const end) {
static_assert(!std::is_same_v<T, long double>, static_assert(!std::is_same_v<T, long double>,
"Conversion to long double is disabled"); "Conversion to long double is disabled");
constexpr static auto buff_max = 64; constexpr static auto buff_max = 64;
char short_buff[buff_max]; std::array<char, buff_max> short_buff;
size_t string_range = std::distance(begin, end);
const size_t string_range = std::distance(begin, end);
std::string long_buff; std::string long_buff;
char* buff; char* buff = nullptr;
if (string_range > buff_max) { if (string_range > buff_max) {
long_buff = std::string{begin, end}; long_buff = std::string{begin, end};
buff = long_buff.data(); buff = long_buff.data();
} else { } else {
buff = short_buff; buff = short_buff.data();
buff[string_range] = '\0'; buff[string_range] = '\0';
std::copy_n(begin, string_range, buff); std::copy_n(begin, string_range, buff);
} }
@ -86,12 +88,14 @@ struct numeric_wrapper {
using type = T; using type = T;
numeric_wrapper() = default; numeric_wrapper() = default;
numeric_wrapper(numeric_wrapper&&) = default; numeric_wrapper(numeric_wrapper&&) noexcept = default;
numeric_wrapper(const numeric_wrapper&) = default; numeric_wrapper(const numeric_wrapper&) = default;
numeric_wrapper& operator=(numeric_wrapper&&) = default; numeric_wrapper& operator=(numeric_wrapper&&) noexcept = default;
numeric_wrapper& operator=(const numeric_wrapper&) = default; numeric_wrapper& operator=(const numeric_wrapper&) = default;
~numeric_wrapper() = default;
numeric_wrapper(T other) : value{other} { numeric_wrapper(T other) : value{other} {
} }
@ -110,7 +114,7 @@ using int8 = numeric_wrapper<int8_t>;
using uint8 = numeric_wrapper<uint8_t>; using uint8 = numeric_wrapper<uint8_t>;
template <typename T> template <typename T>
std::enable_if_t<std::is_integral_v<T>, std::optional<T>> to_num( [[nodiscard]] std::enable_if_t<std::is_integral_v<T>, std::optional<T>> to_num(
const char* const begin, const char* const end) { const char* const begin, const char* const end) {
T ret; T ret;
auto [ptr, ec] = std::from_chars(begin, end, ret); auto [ptr, ec] = std::from_chars(begin, end, ret);
@ -122,8 +126,9 @@ std::enable_if_t<std::is_integral_v<T>, std::optional<T>> to_num(
} }
template <typename T> template <typename T>
std::enable_if_t<is_instance_of_v<numeric_wrapper, T>, std::optional<T>> to_num( [[nodiscard]] std::enable_if_t<is_instance_of_v<numeric_wrapper, T>,
const char* const begin, const char* const end) { std::optional<T>>
to_num(const char* const begin, const char* const end) {
T ret; T ret;
auto [ptr, ec] = std::from_chars(begin, end, ret.value); auto [ptr, ec] = std::from_chars(begin, end, ret.value);
@ -142,10 +147,11 @@ template <typename T>
struct unsupported_type { struct unsupported_type {
constexpr static bool value = false; constexpr static bool value = false;
}; };
} /* namespace */ } /* namespace errors */
template <typename T> template <typename T>
std::enable_if_t<!std::is_integral_v<T> && !std::is_floating_point_v<T> && [[nodiscard]] std::enable_if_t<!std::is_integral_v<T> &&
!std::is_floating_point_v<T> &&
!is_instance_of_v<std::optional, T> && !is_instance_of_v<std::optional, T> &&
!is_instance_of_v<std::variant, T> && !is_instance_of_v<std::variant, T> &&
!is_instance_of_v<numeric_wrapper, T>, !is_instance_of_v<numeric_wrapper, T>,
@ -157,7 +163,8 @@ extract(const char*, const char*, T&) {
} }
template <typename T> template <typename T>
std::enable_if_t<std::is_integral_v<T> || std::is_floating_point_v<T> || [[nodiscard]] std::enable_if_t<std::is_integral_v<T> ||
std::is_floating_point_v<T> ||
is_instance_of_v<numeric_wrapper, T>, is_instance_of_v<numeric_wrapper, T>,
bool> bool>
extract(const char* begin, const char* end, T& value) { extract(const char* begin, const char* end, T& value) {
@ -170,8 +177,8 @@ extract(const char* begin, const char* end, T& value) {
} }
template <typename T> template <typename T>
std::enable_if_t<is_instance_of_v<std::optional, T>, bool> extract( [[nodiscard]] std::enable_if_t<is_instance_of_v<std::optional, T>, bool>
const char* begin, const char* end, T& value) { extract(const char* begin, const char* end, T& value) {
typename T::value_type raw_value; typename T::value_type raw_value;
if (extract(begin, end, raw_value)) { if (extract(begin, end, raw_value)) {
value = raw_value; value = raw_value;
@ -182,7 +189,8 @@ std::enable_if_t<is_instance_of_v<std::optional, T>, bool> extract(
} }
template <typename T, size_t I> template <typename T, size_t I>
bool extract_variant(const char* begin, const char* end, T& value) { [[nodiscard]] bool extract_variant(const char* begin, const char* end,
T& value) {
using IthType = std::variant_alternative_t<I, std::decay_t<T>>; using IthType = std::variant_alternative_t<I, std::decay_t<T>>;
IthType ithValue; IthType ithValue;
if (extract<IthType>(begin, end, ithValue)) { if (extract<IthType>(begin, end, ithValue)) {
@ -195,7 +203,7 @@ bool extract_variant(const char* begin, const char* end, T& value) {
} }
template <typename T> template <typename T>
std::enable_if_t<is_instance_of_v<std::variant, T>, bool> extract( [[nodiscard]] std::enable_if_t<is_instance_of_v<std::variant, T>, bool> extract(
const char* begin, const char* end, T& value) { const char* begin, const char* end, T& value) {
return extract_variant<T, 0>(begin, end, value); return extract_variant<T, 0>(begin, end, value);
} }
@ -205,7 +213,8 @@ std::enable_if_t<is_instance_of_v<std::variant, T>, bool> extract(
//////////////// ////////////////
template <> template <>
inline bool extract(const char* begin, const char* end, bool& value) { [[nodiscard]] inline bool extract(const char* begin, const char* end,
bool& value) {
if (end == begin + 1) { if (end == begin + 1) {
if (*begin == '1') { if (*begin == '1') {
value = true; value = true;
@ -215,10 +224,13 @@ inline bool extract(const char* begin, const char* end, bool& value) {
return false; return false;
} }
} else { } else {
size_t size = end - begin; constexpr static auto true_size = 4;
if (size == 4 && std::strncmp(begin, "true", size) == 0) { constexpr static auto false_size = 5;
const size_t size = end - begin;
if (size == true_size && std::strncmp(begin, "true", size) == 0) {
value = true; value = true;
} else if (size == 5 && std::strncmp(begin, "false", size) == 0) { } else if (size == false_size &&
std::strncmp(begin, "false", size) == 0) {
value = false; value = false;
} else { } else {
return false; return false;
@ -229,22 +241,24 @@ inline bool extract(const char* begin, const char* end, bool& value) {
} }
template <> template <>
inline bool extract(const char* begin, const char* end, char& value) { [[nodiscard]] inline bool extract(const char* begin, const char* end,
char& value) {
value = *begin; value = *begin;
return (end == begin + 1); return (end == begin + 1);
} }
template <> template <>
inline bool extract(const char* begin, const char* end, std::string& value) { [[nodiscard]] inline bool extract(const char* begin, const char* end,
std::string& value) {
value = std::string{begin, end}; value = std::string{begin, end};
return true; return true;
} }
template <> template <>
inline bool extract(const char* begin, const char* end, [[nodiscard]] inline bool extract(const char* begin, const char* end,
std::string_view& value) { std::string_view& value) {
value = std::string_view{begin, static_cast<size_t>(end - begin)}; value = std::string_view{begin, static_cast<size_t>(end - begin)};
return true; return true;
} }
} /* ss */ } /* namespace ss */

3
include/ss/function_traits.hpp
View File

@ -2,7 +2,6 @@
#include <cstdlib> #include <cstdlib>
#include <functional> #include <functional>
#include <tuple>
namespace ss { namespace ss {
@ -77,4 +76,4 @@ struct member_wrapper<R T::*> {
template <typename T> \ template <typename T> \
constexpr bool has_m_##method##_t = has_m_##method<T>::value; constexpr bool has_m_##method##_t = has_m_##method<T>::value;
} /* trait */ } /* namespace ss */

272
include/ss/parser.hpp
View File

@ -5,7 +5,6 @@
#include "exception.hpp" #include "exception.hpp"
#include "extract.hpp" #include "extract.hpp"
#include "restrictions.hpp" #include "restrictions.hpp"
#include <cerrno>
#include <cstdlib> #include <cstdlib>
#include <cstring> #include <cstring>
#include <optional> #include <optional>
@ -32,10 +31,12 @@ class parser {
constexpr static bool ignore_empty = setup<Options...>::ignore_empty; constexpr static bool ignore_empty = setup<Options...>::ignore_empty;
using header_splitter = ss::splitter<
ss::filter_not_t<ss::is_instance_of_multiline, Options...>>;
public: public:
parser(const std::string& file_name, parser(std::string file_name, std::string delim = ss::default_delimiter)
const std::string& delim = ss::default_delimiter) : file_name_{std::move(file_name)}, reader_{file_name_, delim} {
: file_name_{file_name}, reader_{file_name_, delim} {
if (reader_.file_) { if (reader_.file_) {
read_line(); read_line();
if constexpr (ignore_header) { if constexpr (ignore_header) {
@ -51,7 +52,7 @@ public:
parser(const char* const csv_data_buffer, size_t csv_data_size, parser(const char* const csv_data_buffer, size_t csv_data_size,
const std::string& delim = ss::default_delimiter) const std::string& delim = ss::default_delimiter)
: file_name_{"buffer line"}, : file_name_{"CSV data buffer"},
reader_{csv_data_buffer, csv_data_size, delim} { reader_{csv_data_buffer, csv_data_size, delim} {
if (csv_data_buffer) { if (csv_data_buffer) {
read_line(); read_line();
@ -66,14 +67,15 @@ public:
} }
} }
parser(parser&& other) = default; parser(parser&& other) noexcept = default;
parser& operator=(parser&& other) = default; parser& operator=(parser&& other) noexcept = default;
~parser() = default;
parser() = delete; parser() = delete;
parser(const parser& other) = delete; parser(const parser& other) = delete;
parser& operator=(const parser& other) = delete; parser& operator=(const parser& other) = delete;
bool valid() const { [[nodiscard]] bool valid() const {
if constexpr (string_error) { if constexpr (string_error) {
return error_.empty(); return error_.empty();
} else if constexpr (throw_on_error) { } else if constexpr (throw_on_error) {
@ -83,12 +85,12 @@ public:
} }
} }
const std::string& error_msg() const { [[nodiscard]] const std::string& error_msg() const {
assert_string_error_defined<string_error>(); assert_string_error_defined<string_error>();
return error_; return error_;
} }
bool eof() const { [[nodiscard]] bool eof() const {
return eof_; return eof_;
} }
@ -97,23 +99,21 @@ public:
} }
template <typename T, typename... Ts> template <typename T, typename... Ts>
T get_object() { [[nodiscard]] T get_object() {
return to_object<T>(get_next<Ts...>()); return to_object<T>(get_next<Ts...>());
} }
size_t line() const { [[nodiscard]] size_t line() const {
return reader_.line_number_ > 0 ? reader_.line_number_ - 1 return reader_.line_number_ > 0 ? reader_.line_number_ - 1
: reader_.line_number_; : reader_.line_number_;
} }
size_t position() const { [[nodiscard]] size_t position() const {
return reader_.chars_read_; return reader_.chars_read_;
} }
template <typename T, typename... Ts> template <typename T, typename... Ts>
no_void_validator_tup_t<T, Ts...> get_next() { [[nodiscard]] no_void_validator_tup_t<T, Ts...> get_next() {
std::optional<std::string> error;
if (!eof_) { if (!eof_) {
if constexpr (throw_on_error) { if constexpr (throw_on_error) {
try { try {
@ -162,20 +162,49 @@ public:
return value; return value;
} }
bool field_exists(const std::string& field) { [[nodiscard]] std::string raw_header() const {
assert_ignore_header_not_defined();
return raw_header_;
}
[[nodiscard]] std::vector<std::string> header() {
assert_ignore_header_not_defined();
clear_error();
header_splitter splitter;
std::string raw_header_copy = raw_header_;
if (!strict_split(splitter, raw_header_copy)) {
return {};
}
std::vector<std::string> split_header;
for (const auto& [begin, end] : splitter.get_split_data()) {
split_header.emplace_back(begin, end);
}
return split_header;
}
[[nodiscard]] bool field_exists(const std::string& field) {
assert_ignore_header_not_defined();
clear_error();
if (header_.empty()) { if (header_.empty()) {
split_header_data(); split_header_data();
} }
if (!valid()) {
return false;
}
return header_index(field).has_value(); return header_index(field).has_value();
} }
template <typename... Ts> template <typename... Ts>
void use_fields(const Ts&... fields_args) { void use_fields(const Ts&... fields_args) {
if constexpr (ignore_header) { assert_ignore_header_not_defined();
handle_error_header_ignored(); clear_error();
return;
}
if (header_.empty() && !eof()) { if (header_.empty() && !eof()) {
split_header_data(); split_header_data();
@ -188,7 +217,7 @@ public:
auto fields = std::vector<std::string>{fields_args...}; auto fields = std::vector<std::string>{fields_args...};
if (fields.empty()) { if (fields.empty()) {
handle_error_empty_mapping(); handle_error_invalid_use_fields_argument();
return; return;
} }
@ -236,13 +265,17 @@ public:
} }
iterator(const iterator& other) = default; iterator(const iterator& other) = default;
iterator(iterator&& other) = default; iterator(iterator&& other) noexcept = default;
~iterator() = default;
value& operator*() { iterator& operator=(const iterator& other) = delete;
iterator& operator=(iterator&& other) noexcept = delete;
[[nodiscard]] value& operator*() {
return value_; return value_;
} }
value* operator->() { [[nodiscard]] value* operator->() {
return &value_; return &value_;
} }
@ -261,17 +294,21 @@ public:
return *this; return *this;
} }
iterator& operator++(int) { iterator operator++(int) {
return ++*this; auto result = *this;
++*this;
return result;
} }
friend bool operator==(const iterator& lhs, const iterator& rhs) { [[nodiscard]] friend bool operator==(const iterator& lhs,
const iterator& rhs) {
return (lhs.parser_ == nullptr && rhs.parser_ == nullptr) || return (lhs.parser_ == nullptr && rhs.parser_ == nullptr) ||
(lhs.parser_ == rhs.parser_ && (lhs.parser_ == rhs.parser_ &&
&lhs.value_ == &rhs.value_); &lhs.value_ == &rhs.value_);
} }
friend bool operator!=(const iterator& lhs, const iterator& rhs) { [[nodiscard]] friend bool operator!=(const iterator& lhs,
const iterator& rhs) {
return !(lhs == rhs); return !(lhs == rhs);
} }
@ -283,11 +320,11 @@ public:
iterable(parser<Options...>* parser) : parser_{parser} { iterable(parser<Options...>* parser) : parser_{parser} {
} }
iterator begin() { [[nodiscard]] iterator begin() {
return ++iterator{parser_}; return ++iterator{parser_};
} }
iterator end() { [[nodiscard]] iterator end() {
return iterator{}; return iterator{};
} }
@ -296,12 +333,12 @@ public:
}; };
template <typename... Ts> template <typename... Ts>
auto iterate() { [[nodiscard]] auto iterate() {
return iterable<false, Ts...>{this}; return iterable<false, Ts...>{this};
} }
template <typename... Ts> template <typename... Ts>
auto iterate_object() { [[nodiscard]] auto iterate_object() {
return iterable<true, Ts...>{this}; return iterable<true, Ts...>{this};
} }
@ -326,7 +363,7 @@ public:
Fun&& fun = none{}) { Fun&& fun = none{}) {
using Value = no_void_validator_tup_t<Us...>; using Value = no_void_validator_tup_t<Us...>;
std::optional<Value> value; std::optional<Value> value;
try_convert_and_invoke<Value, Us...>(value, fun); try_convert_and_invoke<Value, Us...>(value, std::forward<Fun>(fun));
return composite_with(std::move(value)); return composite_with(std::move(value));
} }
@ -335,11 +372,11 @@ public:
template <typename U, typename... Us, typename Fun = none> template <typename U, typename... Us, typename Fun = none>
composite<Ts..., std::optional<U>> or_object(Fun&& fun = none{}) { composite<Ts..., std::optional<U>> or_object(Fun&& fun = none{}) {
std::optional<U> value; std::optional<U> value;
try_convert_and_invoke<U, Us...>(value, fun); try_convert_and_invoke<U, Us...>(value, std::forward<Fun>(fun));
return composite_with(std::move(value)); return composite_with(std::move(value));
} }
std::tuple<Ts...> values() { [[nodiscard]] std::tuple<Ts...> values() {
return values_; return values_;
} }
@ -362,7 +399,7 @@ public:
private: private:
template <typename T> template <typename T>
composite<Ts..., T> composite_with(T&& new_value) { [[nodiscard]] composite<Ts..., T> composite_with(T&& new_value) {
auto merged_values = auto merged_values =
std::tuple_cat(std::move(values_), std::tuple_cat(std::move(values_),
std::tuple<T>{parser_.valid() std::tuple<T>{parser_.valid()
@ -392,7 +429,7 @@ public:
} }
template <typename U, typename... Us> template <typename U, typename... Us>
no_void_validator_tup_t<U, Us...> try_same() { [[nodiscard]] no_void_validator_tup_t<U, Us...> try_same() {
parser_.clear_error(); parser_.clear_error();
auto value = auto value =
parser_.reader_.converter_.template convert<U, Us...>(); parser_.reader_.converter_.template convert<U, Us...>();
@ -413,8 +450,8 @@ public:
// tries to convert a line and returns a composite which is // tries to convert a line and returns a composite which is
// able to try additional conversions in case of failure // able to try additional conversions in case of failure
template <typename... Ts, typename Fun = none> template <typename... Ts, typename Fun = none>
composite<std::optional<no_void_validator_tup_t<Ts...>>> try_next( [[nodiscard]] composite<std::optional<no_void_validator_tup_t<Ts...>>>
Fun&& fun = none{}) { try_next(Fun&& fun = none{}) {
assert_throw_on_error_not_defined<throw_on_error>(); assert_throw_on_error_not_defined<throw_on_error>();
using Ret = no_void_validator_tup_t<Ts...>; using Ret = no_void_validator_tup_t<Ts...>;
return try_invoke_and_make_composite< return try_invoke_and_make_composite<
@ -424,7 +461,7 @@ public:
// identical to try_next but returns composite with object instead of a // identical to try_next but returns composite with object instead of a
// tuple // tuple
template <typename T, typename... Ts, typename Fun = none> template <typename T, typename... Ts, typename Fun = none>
composite<std::optional<T>> try_object(Fun&& fun = none{}) { [[nodiscard]] composite<std::optional<T>> try_object(Fun&& fun = none{}) {
assert_throw_on_error_not_defined<throw_on_error>(); assert_throw_on_error_not_defined<throw_on_error>();
return try_invoke_and_make_composite< return try_invoke_and_make_composite<
std::optional<T>>(get_object<T, Ts...>(), std::forward<Fun>(fun)); std::optional<T>>(get_object<T, Ts...>(), std::forward<Fun>(fun));
@ -443,7 +480,8 @@ private:
using Ret = decltype(try_invoke_impl(arg, std::forward<Fun>(fun))); using Ret = decltype(try_invoke_impl(arg, std::forward<Fun>(fun)));
constexpr bool returns_void = std::is_same_v<Ret, void>; constexpr bool returns_void = std::is_same_v<Ret, void>;
if constexpr (!returns_void) { if constexpr (!returns_void) {
if (!try_invoke_impl(arg, std::forward<Fun>(fun))) { if (!try_invoke_impl(std::forward<Arg>(arg),
std::forward<Fun>(fun))) {
handle_error_failed_check(); handle_error_failed_check();
} }
} else { } else {
@ -474,26 +512,55 @@ private:
} }
template <typename T, typename Fun = none> template <typename T, typename Fun = none>
composite<T> try_invoke_and_make_composite(T&& value, Fun&& fun) { [[nodiscard]] composite<T> try_invoke_and_make_composite(T&& value,
Fun&& fun) {
if (valid()) { if (valid()) {
try_invoke(*value, std::forward<Fun>(fun)); try_invoke(*value, std::forward<Fun>(fun));
} }
return {valid() ? std::move(value) : std::nullopt, *this}; return {valid() ? std::forward<T>(value) : std::nullopt, *this};
} }
//////////////// ////////////////
// header // header
//////////////// ////////////////
void assert_ignore_header_not_defined() const {
static_assert(!ignore_header,
"cannot use this method when 'ignore_header' is defined");
}
[[nodiscard]] bool strict_split(header_splitter& splitter,
std::string& header) {
if constexpr (throw_on_error) {
try {
splitter.split(header.data(), reader_.delim_);
} catch (const ss::exception& e) {
decorate_rethrow_invalid_header_split(e);
}
} else {
splitter.split(header.data(), reader_.delim_);
if (!splitter.valid()) {
handle_error_invalid_header_split(splitter);
return false;
}
}
return true;
}
void split_header_data() { void split_header_data() {
ss::splitter<Options...> splitter; header_splitter splitter;
std::string raw_header_copy = raw_header_; std::string raw_header_copy = raw_header_;
splitter.split(raw_header_copy.data(), reader_.delim_);
for (const auto& [begin, end] : splitter.split_data_) { if (!strict_split(splitter, raw_header_copy)) {
return;
}
for (const auto& [begin, end] : splitter.get_split_data()) {
std::string field{begin, end}; std::string field{begin, end};
if (std::find(header_.begin(), header_.end(), field) != if (std::find(header_.begin(), header_.end(), field) !=
header_.end()) { header_.end()) {
handle_error_invalid_header(field); handle_error_duplicate_header_field(field);
header_.clear(); header_.clear();
return; return;
} }
@ -501,7 +568,7 @@ private:
} }
} }
std::optional<size_t> header_index(const std::string& field) { [[nodiscard]] std::optional<size_t> header_index(const std::string& field) {
auto it = std::find(header_.begin(), header_.end(), field); auto it = std::find(header_.begin(), header_.end(), field);
if (it == header_.end()) { if (it == header_.end()) {
@ -524,7 +591,7 @@ private:
} }
void handle_error_failed_check() { void handle_error_failed_check() {
constexpr static auto error_msg = " failed check"; constexpr static auto error_msg = ": failed check";
if constexpr (string_error) { if constexpr (string_error) {
error_.clear(); error_.clear();
@ -537,7 +604,7 @@ private:
} }
void handle_error_null_buffer() { void handle_error_null_buffer() {
constexpr static auto error_msg = " received null data buffer"; constexpr static auto error_msg = ": received null data buffer";
if constexpr (string_error) { if constexpr (string_error) {
error_.clear(); error_.clear();
@ -550,7 +617,7 @@ private:
} }
void handle_error_file_not_open() { void handle_error_file_not_open() {
constexpr static auto error_msg = " could not be opened"; constexpr static auto error_msg = ": could not be opened";
if constexpr (string_error) { if constexpr (string_error) {
error_.clear(); error_.clear();
@ -563,7 +630,7 @@ private:
} }
void handle_error_eof_reached() { void handle_error_eof_reached() {
constexpr static auto error_msg = " read on end of file"; constexpr static auto error_msg = ": read on end of file";
if constexpr (string_error) { if constexpr (string_error) {
error_.clear(); error_.clear();
@ -588,20 +655,6 @@ private:
} }
} }
void handle_error_header_ignored() {
constexpr static auto error_msg =
": the header row is ignored within the setup it cannot be used";
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_invalid_field(const std::string& field) { void handle_error_invalid_field(const std::string& field) {
constexpr static auto error_msg = constexpr static auto error_msg =
": header does not contain given field: "; ": header does not contain given field: ";
@ -629,8 +682,9 @@ private:
} }
} }
void handle_error_empty_mapping() { void handle_error_invalid_use_fields_argument() {
constexpr static auto error_msg = "received empty mapping"; constexpr static auto error_msg =
"received invalid argument for 'use_fields'";
if constexpr (string_error) { if constexpr (string_error) {
error_.clear(); error_.clear();
@ -642,19 +696,53 @@ private:
} }
} }
void handle_error_invalid_header(const std::string& field) { void handle_error_invalid_header_field() {
constexpr static auto error_msg = "header contains duplicates: "; constexpr static auto error_msg = ": header contains empty field";
if constexpr (string_error) { if constexpr (string_error) {
error_.clear(); error_.clear();
error_.append(error_msg).append(error_msg); error_.append(file_name_).append(error_msg);
} else if constexpr (throw_on_error) { } else if constexpr (throw_on_error) {
throw ss::exception{error_msg + field}; throw ss::exception{file_name_ + error_msg};
} else { } else {
error_ = true; error_ = true;
} }
} }
void handle_error_duplicate_header_field(const std::string& field) {
constexpr static auto error_msg = ": header contains duplicate: ";
if constexpr (string_error) {
error_.clear();
error_.append(file_name_).append(error_msg).append(field);
} else if constexpr (throw_on_error) {
throw ss::exception{file_name_ + error_msg + field};
} else {
error_ = true;
}
}
void handle_error_invalid_header_split(const header_splitter& splitter) {
constexpr static auto error_msg = ": failed header parsing: ";
if constexpr (string_error) {
error_.clear();
error_.append(file_name_)
.append(error_msg)
.append(splitter.error_msg());
} else {
error_ = true;
}
}
void decorate_rethrow_invalid_header_split(const ss::exception& e) const {
static_assert(throw_on_error,
"throw_on_error needs to be enabled to use this method");
throw ss::exception{std::string{file_name_}
.append(": failed header parsing: ")
.append(e.what())};
}
void decorate_rethrow(const ss::exception& e) const { void decorate_rethrow(const ss::exception& e) const {
static_assert(throw_on_error, static_assert(throw_on_error,
"throw_on_error needs to be enabled to use this method"); "throw_on_error needs to be enabled to use this method");
@ -674,17 +762,18 @@ private:
} }
struct reader { struct reader {
reader(const std::string& file_name_, const std::string& delim) reader(const std::string& file_name_, std::string delim)
: delim_{delim}, file_{std::fopen(file_name_.c_str(), "rb")} { : delim_{std::move(delim)},
file_{std::fopen(file_name_.c_str(), "rb")} {
} }
reader(const char* const buffer, size_t csv_data_size, reader(const char* const buffer, size_t csv_data_size,
const std::string& delim) std::string delim)
: delim_{delim}, csv_data_buffer_{buffer}, : delim_{std::move(delim)}, csv_data_buffer_{buffer},
csv_data_size_{csv_data_size} { csv_data_size_{csv_data_size} {
} }
reader(reader&& other) reader(reader&& other) noexcept
: buffer_{other.buffer_}, : buffer_{other.buffer_},
next_line_buffer_{other.next_line_buffer_}, next_line_buffer_{other.next_line_buffer_},
helper_buffer_{other.helper_buffer_}, helper_buffer_{other.helper_buffer_},
@ -705,7 +794,7 @@ private:
other.file_ = nullptr; other.file_ = nullptr;
} }
reader& operator=(reader&& other) { reader& operator=(reader&& other) noexcept {
if (this != &other) { if (this != &other) {
buffer_ = other.buffer_; buffer_ = other.buffer_;
next_line_buffer_ = other.next_line_buffer_; next_line_buffer_ = other.next_line_buffer_;
@ -741,7 +830,7 @@ private:
std::free(helper_buffer_); std::free(helper_buffer_);
if (file_) { if (file_) {
std::fclose(file_); std::ignore = std::fclose(file_);
} }
} }
@ -750,7 +839,7 @@ private:
reader& operator=(const reader& other) = delete; reader& operator=(const reader& other) = delete;
// read next line each time in order to set eof_ // read next line each time in order to set eof_
bool read_next() { [[nodiscard]] bool read_next() {
next_line_converter_.clear_error(); next_line_converter_.clear_error();
size_t size = 0; size_t size = 0;
while (size == 0) { while (size == 0) {
@ -842,7 +931,7 @@ private:
std::swap(converter_, next_line_converter_); std::swap(converter_, next_line_converter_);
} }
bool multiline_limit_reached(size_t& limit) { [[nodiscard]] bool multiline_limit_reached(size_t& limit) {
if constexpr (multiline::size > 0) { if constexpr (multiline::size > 0) {
if (limit++ >= multiline::size) { if (limit++ >= multiline::size) {
next_line_converter_.handle_error_multiline_limit_reached(); next_line_converter_.handle_error_multiline_limit_reached();
@ -852,8 +941,8 @@ private:
return false; return false;
} }
bool escaped_eol(size_t size) { [[nodiscard]] bool escaped_eol(size_t size) {
const char* curr; const char* curr = nullptr;
for (curr = next_line_buffer_ + size - 1; for (curr = next_line_buffer_ + size - 1;
curr >= next_line_buffer_ && curr >= next_line_buffer_ &&
setup<Options...>::escape::match(*curr); setup<Options...>::escape::match(*curr);
@ -862,7 +951,7 @@ private:
return (next_line_buffer_ - curr + size) % 2 == 0; return (next_line_buffer_ - curr + size) % 2 == 0;
} }
bool unterminated_quote() { [[nodiscard]] bool unterminated_quote() {
return next_line_converter_.unterminated_quote(); return next_line_converter_.unterminated_quote();
} }
@ -877,7 +966,7 @@ private:
} }
} }
size_t remove_eol(char*& buffer, size_t ssize) { [[nodiscard]] size_t remove_eol(char*& buffer, size_t ssize) {
if (buffer[ssize - 1] != '\n') { if (buffer[ssize - 1] != '\n') {
crlf_ = false; crlf_ = false;
return ssize; return ssize;
@ -899,7 +988,7 @@ private:
size_t& buffer_size, const char* const second, size_t& buffer_size, const char* const second,
size_t second_size) { size_t second_size) {
buffer_size = first_size + second_size + 3; buffer_size = first_size + second_size + 3;
auto new_first = static_cast<char*>( auto* new_first = static_cast<char*>(
strict_realloc(static_cast<void*>(first), buffer_size)); strict_realloc(static_cast<void*>(first), buffer_size));
first = new_first; first = new_first;
@ -907,7 +996,8 @@ private:
first_size += second_size; first_size += second_size;
} }
bool append_next_line_to_buffer(char*& buffer, size_t& line_size, [[nodiscard]] bool append_next_line_to_buffer(char*& buffer,
size_t& line_size,
size_t buffer_size) { size_t buffer_size) {
undo_remove_eol(buffer, line_size, buffer_size); undo_remove_eol(buffer, line_size, buffer_size);
@ -927,8 +1017,8 @@ private:
return true; return true;
} }
std::string get_buffer() { [[nodiscard]] std::string get_buffer() {
return std::string{next_line_buffer_, next_line_buffer_size_}; return std::string{next_line_buffer_, next_line_size_};
} }
//////////////// ////////////////
@ -971,4 +1061,4 @@ private:
bool eof_{false}; bool eof_{false};
}; };
} /* ss */ } /* namespace ss */

30
include/ss/restrictions.hpp
View File

@ -10,7 +10,7 @@ template <typename T, auto... Values>
struct ax { struct ax {
private: private:
template <auto X, auto... Xs> template <auto X, auto... Xs>
bool ss_valid_impl(const T& x) const { [[nodiscard]] bool ss_valid_impl(const T& x) const {
if constexpr (sizeof...(Xs) != 0) { if constexpr (sizeof...(Xs) != 0) {
return x != X && ss_valid_impl<Xs...>(x); return x != X && ss_valid_impl<Xs...>(x);
} }
@ -18,11 +18,11 @@ private:
} }
public: public:
bool ss_valid(const T& value) const { [[nodiscard]] bool ss_valid(const T& value) const {
return ss_valid_impl<Values...>(value); return ss_valid_impl<Values...>(value);
} }
const char* error() const { [[nodiscard]] const char* error() const {
return "value excluded"; return "value excluded";
} }
}; };
@ -35,7 +35,7 @@ template <typename T, auto... Values>
struct nx { struct nx {
private: private:
template <auto X, auto... Xs> template <auto X, auto... Xs>
bool ss_valid_impl(const T& x) const { [[nodiscard]] bool ss_valid_impl(const T& x) const {
if constexpr (sizeof...(Xs) != 0) { if constexpr (sizeof...(Xs) != 0) {
return x == X || ss_valid_impl<Xs...>(x); return x == X || ss_valid_impl<Xs...>(x);
} }
@ -43,11 +43,11 @@ private:
} }
public: public:
bool ss_valid(const T& value) const { [[nodiscard]] bool ss_valid(const T& value) const {
return ss_valid_impl<Values...>(value); return ss_valid_impl<Values...>(value);
} }
const char* error() const { [[nodiscard]] const char* error() const {
return "value excluded"; return "value excluded";
} }
}; };
@ -61,28 +61,28 @@ public:
template <typename T, auto N> template <typename T, auto N>
struct gt { struct gt {
bool ss_valid(const T& value) const { [[nodiscard]] bool ss_valid(const T& value) const {
return value > N; return value > N;
} }
}; };
template <typename T, auto N> template <typename T, auto N>
struct gte { struct gte {
bool ss_valid(const T& value) const { [[nodiscard]] bool ss_valid(const T& value) const {
return value >= N; return value >= N;
} }
}; };
template <typename T, auto N> template <typename T, auto N>
struct lt { struct lt {
bool ss_valid(const T& value) const { [[nodiscard]] bool ss_valid(const T& value) const {
return value < N; return value < N;
} }
}; };
template <typename T, auto N> template <typename T, auto N>
struct lte { struct lte {
bool ss_valid(const T& value) const { [[nodiscard]] bool ss_valid(const T& value) const {
return value <= N; return value <= N;
} }
}; };
@ -93,7 +93,7 @@ struct lte {
template <typename T, auto Min, auto Max> template <typename T, auto Min, auto Max>
struct ir { struct ir {
bool ss_valid(const T& value) const { [[nodiscard]] bool ss_valid(const T& value) const {
return value >= Min && value <= Max; return value >= Min && value <= Max;
} }
}; };
@ -104,7 +104,7 @@ struct ir {
template <typename T, auto Min, auto Max> template <typename T, auto Min, auto Max>
struct oor { struct oor {
bool ss_valid(const T& value) const { [[nodiscard]] bool ss_valid(const T& value) const {
return value < Min || value > Max; return value < Min || value > Max;
} }
}; };
@ -115,13 +115,13 @@ struct oor {
template <typename T> template <typename T>
struct ne { struct ne {
bool ss_valid(const T& value) const { [[nodiscard]] bool ss_valid(const T& value) const {
return !value.empty(); return !value.empty();
} }
const char* error() const { [[nodiscard]] const char* error() const {
return "empty field"; return "empty field";
} }
}; };
} /* ss */ } /* namespace ss */

5
include/ss/setup.hpp
View File

@ -293,4 +293,7 @@ private:
template <typename... Options> template <typename... Options>
struct setup<setup<Options...>> : setup<Options...> {}; struct setup<setup<Options...>> : setup<Options...> {};
} /* ss */ template <typename... Options>
struct setup<std::tuple<Options...>> : setup<Options...> {};
} /* namespace ss */

38
include/ss/splitter.hpp
View File

@ -2,11 +2,9 @@
#include "common.hpp" #include "common.hpp"
#include "exception.hpp" #include "exception.hpp"
#include "setup.hpp" #include "setup.hpp"
#include "type_traits.hpp"
#include <algorithm> #include <algorithm>
#include <cstdlib> #include <cstdlib>
#include <cstring> #include <cstring>
#include <memory>
#include <string> #include <string>
#include <vector> #include <vector>
@ -30,7 +28,7 @@ private:
public: public:
using line_ptr_type = std::conditional_t<is_const_line, const char*, char*>; using line_ptr_type = std::conditional_t<is_const_line, const char*, char*>;
bool valid() const { [[nodiscard]] bool valid() const {
if constexpr (string_error) { if constexpr (string_error) {
return error_.empty(); return error_.empty();
} else if constexpr (throw_on_error) { } else if constexpr (throw_on_error) {
@ -40,12 +38,12 @@ public:
} }
} }
const std::string& error_msg() const { [[nodiscard]] const std::string& error_msg() const {
assert_string_error_defined<string_error>(); assert_string_error_defined<string_error>();
return error_; return error_;
} }
bool unterminated_quote() const { [[nodiscard]] bool unterminated_quote() const {
return unterminated_quote_; return unterminated_quote_;
} }
@ -57,13 +55,21 @@ public:
return split_impl_select_delim(delimiter); return split_impl_select_delim(delimiter);
} }
[[nodiscard]] const split_data& get_split_data() const {
return split_data_;
}
void clear_split_data() {
split_data_.clear();
}
private: private:
//////////////// ////////////////
// resplit // resplit
//////////////// ////////////////
// number of characters the end of line is shifted backwards // number of characters the end of line is shifted backwards
size_t size_shifted() const { [[nodiscard]] size_t size_shifted() const {
return escaped_; return escaped_;
} }
@ -86,7 +92,7 @@ private:
} }
const auto [old_line, old_begin] = *std::prev(split_data_.end()); const auto [old_line, old_begin] = *std::prev(split_data_.end());
size_t begin = old_begin - old_line - 1; const size_t begin = old_begin - old_line - 1;
// safety measure // safety measure
if (new_size != -1 && static_cast<size_t>(new_size) < begin) { if (new_size != -1 && static_cast<size_t>(new_size) < begin) {
@ -194,19 +200,19 @@ private:
// matching // matching
//////////////// ////////////////
bool match(const char* const curr, char delim) { [[nodiscard]] bool match(const char* const curr, char delim) {
return *curr == delim; return *curr == delim;
}; };
bool match(const char* const curr, const std::string& delim) { [[nodiscard]] bool match(const char* const curr, const std::string& delim) {
return std::strncmp(curr, delim.c_str(), delim.size()) == 0; return std::strncmp(curr, delim.c_str(), delim.size()) == 0;
}; };
size_t delimiter_size(char) { [[nodiscard]] size_t delimiter_size(char) {
return 1; return 1;
} }
size_t delimiter_size(const std::string& delim) { [[nodiscard]] size_t delimiter_size(const std::string& delim) {
return delim.size(); return delim.size();
} }
@ -227,7 +233,7 @@ private:
} }
template <typename Delim> template <typename Delim>
std::tuple<size_t, bool> match_delimiter(line_ptr_type begin, [[nodiscard]] std::tuple<size_t, bool> match_delimiter(line_ptr_type begin,
const Delim& delim) { const Delim& delim) {
line_ptr_type end = begin; line_ptr_type end = begin;
@ -322,8 +328,9 @@ private:
trim_left_if_enabled(begin_); trim_left_if_enabled(begin_);
for (done_ = false; !done_; read(delim)) for (done_ = false; !done_;) {
; read(delim);
}
return split_data_; return split_data_;
} }
@ -462,7 +469,6 @@ private:
// members // members
//////////////// ////////////////
public:
error_type error_{}; error_type error_{};
bool unterminated_quote_{false}; bool unterminated_quote_{false};
bool done_{true}; bool done_{true};
@ -479,4 +485,4 @@ public:
friend class converter; friend class converter;
}; };
} /* ss */ } /* namespace ss */

12
include/ss/type_traits.hpp
View File

@ -34,7 +34,11 @@ struct left_of_impl;
template <size_t N, typename T, typename... Ts> template <size_t N, typename T, typename... Ts>
struct left_of_impl { struct left_of_impl {
static_assert(N < 128, "recursion limit reached"); private:
constexpr static auto recursion_limit = 128;
public:
static_assert(N < recursion_limit, "recursion limit reached");
static_assert(N != 0, "cannot take the whole tuple"); static_assert(N != 0, "cannot take the whole tuple");
using type = tup_cat_t<T, typename left_of_impl<N - 1, Ts...>::type>; using type = tup_cat_t<T, typename left_of_impl<N - 1, Ts...>::type>;
}; };
@ -362,12 +366,12 @@ constexpr bool is_instance_of_v = is_instance_of<Template, Ts...>::value;
//////////////// ////////////////
template <class T, std::size_t... Is, class U> template <class T, std::size_t... Is, class U>
T to_object_impl(std::index_sequence<Is...>, U&& data) { [[nodiscard]] T to_object_impl(std::index_sequence<Is...>, U&& data) {
return {std::get<Is>(std::forward<U>(data))...}; return {std::get<Is>(std::forward<U>(data))...};
} }
template <class T, class U> template <class T, class U>
T to_object(U&& data) { [[nodiscard]] T to_object(U&& data) {
using NoRefU = std::decay_t<U>; using NoRefU = std::decay_t<U>;
if constexpr (is_instance_of_v<std::tuple, NoRefU>) { if constexpr (is_instance_of_v<std::tuple, NoRefU>) {
return to_object_impl< return to_object_impl<
@ -378,4 +382,4 @@ T to_object(U&& data) {
} }
} }
} /* trait */ } /* namespace ss */

10
script/single_header_generator.py
View File

@ -14,14 +14,21 @@ headers = ['type_traits.hpp',
combined_file = [] combined_file = []
includes = [] includes = []
in_pp_block = False
for header in headers: for header in headers:
with open(headers_dir + header) as f: with open(headers_dir + header) as f:
for line in f.read().splitlines(): for line in f.read().splitlines():
if '#if ' in line:
in_pp_block = True
if '#endif' in line:
in_pp_block = False
if '#include "' in line or '#include <fast_float' in line: if '#include "' in line or '#include <fast_float' in line:
continue continue
if '#include <' in line: if '#include <' in line and not in_pp_block:
includes.append(line) includes.append(line)
continue continue
@ -30,6 +37,7 @@ for header in headers:
includes = sorted(set(includes)) includes = sorted(set(includes))
print('#pragma once')
print('\n'.join(includes)) print('\n'.join(includes))
print('#define SSP_DISABLE_FAST_FLOAT') print('#define SSP_DISABLE_FAST_FLOAT')
print('\n'.join(combined_file)) print('\n'.join(combined_file))

546
ssp.hpp
View File

File diff suppressed because it is too large Load Diff

9
test/CMakeLists.txt
View File

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

1
test/meson.build
View File

@ -6,6 +6,7 @@ tests = [
'parser1_2', 'parser1_2',
'parser1_3', 'parser1_3',
'parser1_4', 'parser1_4',
'parser1_5',
'splitter', 'splitter',
'converter', 'converter',
'extractions', 'extractions',

183
test/test_converter.cpp
View File

@ -1,5 +1,4 @@
#include "test_helpers.hpp" #include "test_helpers.hpp"
#include <algorithm>
#include <ss/converter.hpp> #include <ss/converter.hpp>
TEST_CASE("converter test split") { TEST_CASE("converter test split") {
@ -11,7 +10,8 @@ TEST_CASE("converter test split") {
{" x x x x | x ", {" x x x x ", " x "}, "|"}, {" x x x x | x ", {" x x x x ", " x "}, "|"},
{"a::b::c::d", {"a", "b", "c", "d"}, "::"}, {"a::b::c::d", {"a", "b", "c", "d"}, "::"},
{"x\t-\ty", {"x", "y"}, "\t-\t"}, {"x\t-\ty", {"x", "y"}, "\t-\t"},
{"x", {"x"}, ","}} // clang-format on {"x", {"x"}, ","}}
// clang-format on
) { ) {
auto split = c.split(s, delim); auto split = c.split(s, delim);
CHECK_EQ(split.size(), expected.size()); CHECK_EQ(split.size(), expected.size());
@ -278,36 +278,37 @@ TEST_CASE_TEMPLATE("converter test valid conversions with exceptions", T, int,
TEST_CASE_TEMPLATE("converter test invalid conversions", T, int, ss::uint8) { TEST_CASE_TEMPLATE("converter test invalid conversions", T, int, ss::uint8) {
ss::converter c; ss::converter c;
c.convert<T>(""); std::ignore = c.convert<T>("");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<T>("1", ""); std::ignore = c.convert<T>("1", "");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<T>("10", ""); std::ignore = c.convert<T>("10", "");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<T, void>(""); std::ignore = c.convert<T, void>("");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<T, void>(",junk"); std::ignore = c.convert<T, void>(",junk");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<void, T>("junk,"); std::ignore = c.convert<void, T>("junk,");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<T>("x"); std::ignore = c.convert<T>("x");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<T, void>("x"); std::ignore = c.convert<T, void>("x");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<T, void>("x,junk"); std::ignore = c.convert<T, void>("x,junk");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<void, T>("junk,x"); std::ignore = c.convert<void, T>("junk,x");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
std::ignore =
c.convert<void, std::variant<T, double>, double>("junk;.5.5;6", ";"); c.convert<void, std::variant<T, double>, double>("junk;.5.5;6", ";");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
} }
@ -316,34 +317,36 @@ TEST_CASE_TEMPLATE("converter test invalid conversions with exceptions", T, int,
ss::uint8) { ss::uint8) {
ss::converter<ss::throw_on_error> c; ss::converter<ss::throw_on_error> c;
REQUIRE_EXCEPTION(c.convert<T>("")); REQUIRE_EXCEPTION(std::ignore = c.convert<T>(""));
REQUIRE_EXCEPTION(c.convert<T>("1", "")); REQUIRE_EXCEPTION(std::ignore = c.convert<T>("1", ""));
REQUIRE_EXCEPTION(c.convert<T>("10", "")); REQUIRE_EXCEPTION(std::ignore = c.convert<T>("10", ""));
REQUIRE_EXCEPTION(c.convert<T, void>("")); REQUIRE_EXCEPTION(std::ignore = c.convert<T, void>(""));
REQUIRE_EXCEPTION(c.convert<T, void>(",junk")); REQUIRE_EXCEPTION(std::ignore = c.convert<T, void>(",junk"));
REQUIRE_EXCEPTION(c.convert<void, T>("junk,")); REQUIRE_EXCEPTION(std::ignore = c.convert<void, T>("junk,"));
REQUIRE_EXCEPTION(c.convert<T>("x")); REQUIRE_EXCEPTION(std::ignore = c.convert<T>("x"));
REQUIRE_EXCEPTION(c.convert<T, void>("x")); REQUIRE_EXCEPTION(std::ignore = c.convert<T, void>("x"));
REQUIRE_EXCEPTION(c.convert<T, void>("x,junk")); REQUIRE_EXCEPTION(std::ignore = c.convert<T, void>("x,junk"));
REQUIRE_EXCEPTION(c.convert<void, T>("junk,x")); REQUIRE_EXCEPTION(std::ignore = c.convert<void, T>("junk,x"));
REQUIRE_EXCEPTION( REQUIRE_EXCEPTION(
c.convert<void, std::variant<T, double>, double>("junk;.5.5;6", ";")); std::ignore =
c.convert<void, std::variant<T, double>, double>("junk;.5.5;6",
";"));
} }
TEST_CASE_TEMPLATE("converter test ss:ax restriction (all except)", T, int, TEST_CASE_TEMPLATE("converter test ss:ax restriction (all except)", T, int,
ss::uint8) { ss::uint8) {
ss::converter c; ss::converter c;
c.convert<ss::ax<T, 0>>("0"); std::ignore = c.convert<ss::ax<T, 0>>("0");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<ss::ax<T, 0, 1, 2>>("1"); std::ignore = c.convert<ss::ax<T, 0, 1, 2>>("1");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<void, char, ss::ax<T, 0, 1, 2>>("junk,c,1"); std::ignore = c.convert<void, char, ss::ax<T, 0, 1, 2>>("junk,c,1");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<ss::ax<T, 1>, char>("1,c"); std::ignore = c.convert<ss::ax<T, 1>, char>("1,c");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
{ {
T tup = c.convert<ss::ax<T, 1>>("3"); T tup = c.convert<ss::ax<T, 1>>("3");
@ -367,10 +370,11 @@ TEST_CASE_TEMPLATE(
ss::uint8) { ss::uint8) {
ss::converter<ss::throw_on_error> c; ss::converter<ss::throw_on_error> c;
REQUIRE_EXCEPTION(c.convert<ss::ax<T, 0>>("0")); REQUIRE_EXCEPTION(std::ignore = c.convert<ss::ax<T, 0>>("0"));
REQUIRE_EXCEPTION(c.convert<ss::ax<T, 0, 1, 2>>("1")); REQUIRE_EXCEPTION(std::ignore = c.convert<ss::ax<T, 0, 1, 2>>("1"));
REQUIRE_EXCEPTION(c.convert<void, char, ss::ax<T, 0, 1, 2>>("junk,c,1")); REQUIRE_EXCEPTION(
REQUIRE_EXCEPTION(c.convert<ss::ax<T, 1>, char>("1,c")); std::ignore = c.convert<void, char, ss::ax<T, 0, 1, 2>>("junk,c,1"));
REQUIRE_EXCEPTION(std::ignore = c.convert<ss::ax<T, 1>, char>("1,c"));
try { try {
{ {
@ -393,13 +397,13 @@ TEST_CASE_TEMPLATE(
TEST_CASE("converter test ss:nx restriction (none except)") { TEST_CASE("converter test ss:nx restriction (none except)") {
ss::converter c; ss::converter c;
c.convert<ss::nx<int, 1>>("3"); std::ignore = c.convert<ss::nx<int, 1>>("3");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<char, ss::nx<int, 1, 2, 69>>("c,3"); std::ignore = c.convert<char, ss::nx<int, 1, 2, 69>>("c,3");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<ss::nx<int, 1>, char>("3,c"); std::ignore = c.convert<ss::nx<int, 1>, char>("3,c");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
{ {
@ -427,9 +431,10 @@ TEST_CASE("converter test ss:nx restriction (none except)") {
TEST_CASE("converter test ss:nx restriction (none except) with exceptions") { TEST_CASE("converter test ss:nx restriction (none except) with exceptions") {
ss::converter<ss::throw_on_error> c; ss::converter<ss::throw_on_error> c;
REQUIRE_EXCEPTION(c.convert<ss::nx<int, 1>>("3")); REQUIRE_EXCEPTION(std::ignore = c.convert<ss::nx<int, 1>>("3"));
REQUIRE_EXCEPTION(c.convert<char, ss::nx<int, 1, 2, 69>>("c,3")); REQUIRE_EXCEPTION(std::ignore =
REQUIRE_EXCEPTION(c.convert<ss::nx<int, 1>, char>("3,c")); c.convert<char, ss::nx<int, 1, 2, 69>>("c,3"));
REQUIRE_EXCEPTION(std::ignore = c.convert<ss::nx<int, 1>, char>("3,c"));
try { try {
{ {
@ -461,13 +466,13 @@ TEST_CASE_TEMPLATE("converter test ss:ir restriction (in range)", T, int,
ss::uint8) { ss::uint8) {
ss::converter c; ss::converter c;
c.convert<ss::ir<T, 0, 2>>("3"); std::ignore = c.convert<ss::ir<T, 0, 2>>("3");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<char, ss::ir<T, 4, 69>>("c,3"); std::ignore = c.convert<char, ss::ir<T, 4, 69>>("c,3");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<ss::ir<T, 1, 2>, char>("3,c"); std::ignore = c.convert<ss::ir<T, 1, 2>, char>("3,c");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
{ {
@ -497,9 +502,9 @@ TEST_CASE_TEMPLATE(
ss::uint8) { ss::uint8) {
ss::converter<ss::throw_on_error> c; ss::converter<ss::throw_on_error> c;
REQUIRE_EXCEPTION(c.convert<ss::ir<T, 0, 2>>("3")); REQUIRE_EXCEPTION(std::ignore = c.convert<ss::ir<T, 0, 2>>("3"));
REQUIRE_EXCEPTION(c.convert<char, ss::ir<T, 4, 69>>("c,3")); REQUIRE_EXCEPTION(std::ignore = c.convert<char, ss::ir<T, 4, 69>>("c,3"));
REQUIRE_EXCEPTION(c.convert<ss::ir<T, 1, 2>, char>("3,c")); REQUIRE_EXCEPTION(std::ignore = c.convert<ss::ir<T, 1, 2>, char>("3,c"));
try { try {
{ {
@ -530,16 +535,16 @@ TEST_CASE_TEMPLATE(
TEST_CASE("converter test ss:oor restriction (out of range)") { TEST_CASE("converter test ss:oor restriction (out of range)") {
ss::converter c; ss::converter c;
c.convert<ss::oor<int, 1, 5>>("3"); std::ignore = c.convert<ss::oor<int, 1, 5>>("3");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<ss::oor<int, 0, 2>>("2"); std::ignore = c.convert<ss::oor<int, 0, 2>>("2");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<char, ss::oor<int, 0, 1>, void>("c,1,junk"); std::ignore = c.convert<char, ss::oor<int, 0, 1>, void>("c,1,junk");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<ss::oor<int, 1, 20>, char>("1,c"); std::ignore = c.convert<ss::oor<int, 1, 20>, char>("1,c");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
{ {
@ -564,10 +569,12 @@ TEST_CASE("converter test ss:oor restriction (out of range)") {
TEST_CASE("converter test ss:oor restriction (out of range) with exceptions") { TEST_CASE("converter test ss:oor restriction (out of range) with exceptions") {
ss::converter<ss::throw_on_error> c; ss::converter<ss::throw_on_error> c;
REQUIRE_EXCEPTION(c.convert<ss::oor<int, 1, 5>>("3")); REQUIRE_EXCEPTION(std::ignore = c.convert<ss::oor<int, 1, 5>>("3"));
REQUIRE_EXCEPTION(c.convert<ss::oor<int, 0, 2>>("2")); REQUIRE_EXCEPTION(std::ignore = c.convert<ss::oor<int, 0, 2>>("2"));
REQUIRE_EXCEPTION(c.convert<char, ss::oor<int, 0, 1>, void>("c,1,junk")); REQUIRE_EXCEPTION(
REQUIRE_EXCEPTION(c.convert<ss::oor<int, 1, 20>, char>("1,c")); std::ignore = c.convert<char, ss::oor<int, 0, 1>, void>("c,1,junk"));
REQUIRE_EXCEPTION(std::ignore =
c.convert<ss::oor<int, 1, 20>, char>("1,c"));
try { try {
{ {
@ -608,19 +615,19 @@ inline bool ss::extract(const char* begin, const char* end,
TEST_CASE("converter test ss:ne restriction (not empty)") { TEST_CASE("converter test ss:ne restriction (not empty)") {
ss::converter c; ss::converter c;
c.convert<ss::ne<std::string>>(""); std::ignore = c.convert<ss::ne<std::string>>("");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<int, ss::ne<std::string>>("3,"); std::ignore = c.convert<int, ss::ne<std::string>>("3,");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<ss::ne<std::string>, int>(",3"); std::ignore = c.convert<ss::ne<std::string>, int>(",3");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<void, ss::ne<std::string>, int>("junk,,3"); std::ignore = c.convert<void, ss::ne<std::string>, int>("junk,,3");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<ss::ne<std::vector<int>>>(""); std::ignore = c.convert<ss::ne<std::vector<int>>>("");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
{ {
@ -643,11 +650,12 @@ TEST_CASE("converter test ss:ne restriction (not empty)") {
TEST_CASE("converter test ss:ne restriction (not empty) with exceptions") { TEST_CASE("converter test ss:ne restriction (not empty) with exceptions") {
ss::converter<ss::throw_on_error> c; ss::converter<ss::throw_on_error> c;
REQUIRE_EXCEPTION(c.convert<ss::ne<std::string>>("")); REQUIRE_EXCEPTION(std::ignore = c.convert<ss::ne<std::string>>(""));
REQUIRE_EXCEPTION(c.convert<int, ss::ne<std::string>>("3,")); REQUIRE_EXCEPTION(std::ignore = c.convert<int, ss::ne<std::string>>("3,"));
REQUIRE_EXCEPTION(c.convert<ss::ne<std::string>, int>(",3")); REQUIRE_EXCEPTION(std::ignore = c.convert<ss::ne<std::string>, int>(",3"));
REQUIRE_EXCEPTION(c.convert<void, ss::ne<std::string>, int>("junk,,3")); REQUIRE_EXCEPTION(std::ignore =
REQUIRE_EXCEPTION(c.convert<ss::ne<std::vector<int>>>("")); c.convert<void, ss::ne<std::string>, int>("junk,,3"));
REQUIRE_EXCEPTION(std::ignore = c.convert<ss::ne<std::vector<int>>>(""));
try { try {
{ {
@ -675,22 +683,22 @@ TEST_CASE(
"converter test ss:lt ss::lte ss::gt ss::gte restriction (in range)") { "converter test ss:lt ss::lte ss::gt ss::gte restriction (in range)") {
ss::converter c; ss::converter c;
c.convert<ss::lt<int, 3>>("3"); std::ignore = c.convert<ss::lt<int, 3>>("3");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<ss::lt<int, 2>>("3"); std::ignore = c.convert<ss::lt<int, 2>>("3");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<ss::gt<int, 3>>("3"); std::ignore = c.convert<ss::gt<int, 3>>("3");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<ss::gt<int, 4>>("3"); std::ignore = c.convert<ss::gt<int, 4>>("3");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<ss::lte<int, 2>>("3"); std::ignore = c.convert<ss::lte<int, 2>>("3");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
c.convert<ss::gte<int, 4>>("3"); std::ignore = c.convert<ss::gte<int, 4>>("3");
REQUIRE_FALSE(c.valid()); REQUIRE_FALSE(c.valid());
{ {
@ -734,12 +742,12 @@ TEST_CASE("converter test ss:lt ss::lte ss::gt ss::gte restriction (in range) "
"with exception") { "with exception") {
ss::converter<ss::throw_on_error> c; ss::converter<ss::throw_on_error> c;
REQUIRE_EXCEPTION(c.convert<ss::lt<int, 3>>("3")); REQUIRE_EXCEPTION(std::ignore = c.convert<ss::lt<int, 3>>("3"));
REQUIRE_EXCEPTION(c.convert<ss::lt<int, 2>>("3")); REQUIRE_EXCEPTION(std::ignore = c.convert<ss::lt<int, 2>>("3"));
REQUIRE_EXCEPTION(c.convert<ss::gt<int, 3>>("3")); REQUIRE_EXCEPTION(std::ignore = c.convert<ss::gt<int, 3>>("3"));
REQUIRE_EXCEPTION(c.convert<ss::gt<int, 4>>("3")); REQUIRE_EXCEPTION(std::ignore = c.convert<ss::gt<int, 4>>("3"));
REQUIRE_EXCEPTION(c.convert<ss::lte<int, 2>>("3")); REQUIRE_EXCEPTION(std::ignore = c.convert<ss::lte<int, 2>>("3"));
REQUIRE_EXCEPTION(c.convert<ss::gte<int, 4>>("3")); REQUIRE_EXCEPTION(std::ignore = c.convert<ss::gte<int, 4>>("3"));
try { try {
{ {
@ -784,14 +792,14 @@ TEST_CASE("converter test ss:lt ss::lte ss::gt ss::gte restriction (in range) "
TEST_CASE("converter test error mode") { TEST_CASE("converter test error mode") {
ss::converter<ss::string_error> c; ss::converter<ss::string_error> c;
c.convert<int>("junk"); std::ignore = c.convert<int>("junk");
CHECK_FALSE(c.valid()); CHECK_FALSE(c.valid());
CHECK_FALSE(c.error_msg().empty()); CHECK_FALSE(c.error_msg().empty());
} }
TEST_CASE("converter test throw on error mode") { TEST_CASE("converter test throw on error mode") {
ss::converter<ss::throw_on_error> c; ss::converter<ss::throw_on_error> c;
REQUIRE_EXCEPTION(c.convert<int>("junk")); REQUIRE_EXCEPTION(std::ignore = c.convert<int>("junk"));
} }
TEST_CASE("converter test converter with quotes spacing and escaping") { TEST_CASE("converter test converter with quotes spacing and escaping") {
@ -908,7 +916,7 @@ TEST_CASE("converter test invalid split conversions") {
{ {
// mismatched quote // mismatched quote
c.convert<std::string, std::string, double, char>( std::ignore = c.convert<std::string, std::string, double, char>(
buff(R"( "just , some , "12.3","a" )")); buff(R"( "just , some , "12.3","a" )"));
CHECK_FALSE(c.valid()); CHECK_FALSE(c.valid());
CHECK_FALSE(c.unterminated_quote()); CHECK_FALSE(c.unterminated_quote());
@ -917,7 +925,7 @@ TEST_CASE("converter test invalid split conversions") {
{ {
// unterminated quote // unterminated quote
c.convert<std::string, std::string, double, std::string>( std::ignore = c.convert<std::string, std::string, double, std::string>(
buff(R"( ju\,st , "so,me" , 12.34 , "str""ings)")); buff(R"( ju\,st , "so,me" , 12.34 , "str""ings)"));
CHECK_FALSE(c.valid()); CHECK_FALSE(c.valid());
CHECK(c.unterminated_quote()); CHECK(c.unterminated_quote());
@ -926,7 +934,7 @@ TEST_CASE("converter test invalid split conversions") {
{ {
// unterminated escape // unterminated escape
c.convert<std::string, std::string, double, std::string>( std::ignore = c.convert<std::string, std::string, double, std::string>(
buff(R"(just,some,2,strings\)")); buff(R"(just,some,2,strings\)"));
CHECK_FALSE(c.valid()); CHECK_FALSE(c.valid());
CHECK_FALSE(c.unterminated_quote()); CHECK_FALSE(c.unterminated_quote());
@ -935,7 +943,7 @@ TEST_CASE("converter test invalid split conversions") {
{ {
// unterminated escape while quoting // unterminated escape while quoting
c.convert<std::string, std::string, double, std::string>( std::ignore = c.convert<std::string, std::string, double, std::string>(
buff(R"(just,some,2,"strings\)")); buff(R"(just,some,2,"strings\)"));
CHECK_FALSE(c.valid()); CHECK_FALSE(c.valid());
CHECK_FALSE(c.unterminated_quote()); CHECK_FALSE(c.unterminated_quote());
@ -944,7 +952,7 @@ TEST_CASE("converter test invalid split conversions") {
{ {
// unterminated escaped quote // unterminated escaped quote
c.convert<std::string, std::string, double, std::string>( std::ignore = c.convert<std::string, std::string, double, std::string>(
buff(R"(just,some,2,"strings\")")); buff(R"(just,some,2,"strings\")"));
CHECK_FALSE(c.valid()); CHECK_FALSE(c.valid());
CHECK(c.unterminated_quote()); CHECK(c.unterminated_quote());
@ -958,27 +966,32 @@ TEST_CASE("converter test invalid split conversions with exceptions") {
c; c;
// mismatched quote // mismatched quote
REQUIRE_EXCEPTION(c.convert<std::string, std::string, double, char>( REQUIRE_EXCEPTION(std::ignore =
c.convert<std::string, std::string, double, char>(
buff(R"( "just , some , "12.3","a" )"))); buff(R"( "just , some , "12.3","a" )")));
CHECK_FALSE(c.unterminated_quote()); CHECK_FALSE(c.unterminated_quote());
// unterminated quote // unterminated quote
REQUIRE_EXCEPTION(c.convert<std::string, std::string, double, std::string>( REQUIRE_EXCEPTION(
std::ignore = c.convert<std::string, std::string, double, std::string>(
buff(R"( ju\,st , "so,me" , 12.34 , "str""ings)"))); buff(R"( ju\,st , "so,me" , 12.34 , "str""ings)")));
CHECK(c.unterminated_quote()); CHECK(c.unterminated_quote());
// unterminated escape // unterminated escape
REQUIRE_EXCEPTION(c.convert<std::string, std::string, double, std::string>( REQUIRE_EXCEPTION(
std::ignore = c.convert<std::string, std::string, double, std::string>(
buff(R"(just,some,2,strings\)"))); buff(R"(just,some,2,strings\)")));
CHECK_FALSE(c.unterminated_quote()); CHECK_FALSE(c.unterminated_quote());
// unterminated escape while quoting // unterminated escape while quoting
REQUIRE_EXCEPTION(c.convert<std::string, std::string, double, std::string>( REQUIRE_EXCEPTION(
std::ignore = c.convert<std::string, std::string, double, std::string>(
buff(R"(just,some,2,"strings\)"))); buff(R"(just,some,2,"strings\)")));
CHECK_FALSE(c.unterminated_quote()); CHECK_FALSE(c.unterminated_quote());
// unterminated escaped quote // unterminated escaped quote
REQUIRE_EXCEPTION(c.convert<std::string, std::string, double, std::string>( REQUIRE_EXCEPTION(
std::ignore = c.convert<std::string, std::string, double, std::string>(
buff(R"(just,some,2,"strings\")"))); buff(R"(just,some,2,"strings\")")));
CHECK(c.unterminated_quote()); CHECK(c.unterminated_quote());
} }

2
test/test_extractions.cpp
View File

@ -23,7 +23,7 @@ struct is_unsigned : public std::is_unsigned<T> {};
template <> template <>
struct is_unsigned<ss::uint8> : public std::true_type {}; struct is_unsigned<ss::uint8> : public std::true_type {};
} /* namespace */ } /* anonymous namespace */
static_assert(is_signed<ss::int8>::value); static_assert(is_signed<ss::int8>::value);
static_assert(is_unsigned<ss::uint8>::value); static_assert(is_unsigned<ss::uint8>::value);

1
test/test_extractions_without_fast_float.cpp
View File

@ -1,5 +1,4 @@
#include "test_helpers.hpp" #include "test_helpers.hpp"
#include <algorithm>
#define SSP_DISABLE_FAST_FLOAT #define SSP_DISABLE_FAST_FLOAT
#include <ss/extract.hpp> #include <ss/extract.hpp>

32
test/test_helpers.hpp
View File

@ -19,7 +19,7 @@
namespace ss { namespace ss {
template <typename... Ts> template <typename... Ts>
class parser; class parser;
} /* ss */ } /* namespace ss */
namespace { namespace {
@ -145,6 +145,17 @@ struct unique_file_name {
CHECK_FALSE(std::string{e.what()}.empty()); \ CHECK_FALSE(std::string{e.what()}.empty()); \
} }
#define CHECK_EQ_ARRAY(first, second) \
{ \
const auto& first_ = (first); \
const auto& second_ = (second); \
CHECK_EQ(first_.size(), second_.size()); \
for (size_t i_ = 0; i_ < std::min(first_.size(), second_.size()); \
++i_) { \
CHECK_EQ(first_[i_], second_[i_]); \
} \
}
template <typename T> template <typename T>
[[maybe_unused]] std::vector<std::vector<T>> vector_combinations( [[maybe_unused]] std::vector<std::vector<T>> vector_combinations(
const std::vector<T>& v, size_t n) { const std::vector<T>& v, size_t n) {
@ -166,6 +177,22 @@ template <typename T>
return ret; return ret;
} }
[[maybe_unused]] std::string merge_header(
const std::vector<std::string>& header,
const std::string& delimiter = ss::default_delimiter) {
std::string s;
if (!header.empty()) {
for (const auto& i : header) {
s.append(i);
s.append(delimiter);
}
for (size_t i = 0; i < delimiter.size(); ++i) {
s.pop_back();
}
}
return s;
};
[[maybe_unused]] std::string make_buffer(const std::string& file_name) { [[maybe_unused]] std::string make_buffer(const std::string& file_name) {
std::ifstream in{file_name, std::ios::binary}; std::ifstream in{file_name, std::ios::binary};
std::string tmp; std::string tmp;
@ -185,6 +212,7 @@ template <typename T>
} }
}; };
// Evade small string optimization
out.reserve(sizeof(out) + 1); out.reserve(sizeof(out) + 1);
copy_if_whitespaces(); copy_if_whitespaces();
@ -224,4 +252,4 @@ make_parser(const std::string& file_name,
return make_parser_impl<buffer_mode, Ts...>(file_name, delim); return make_parser_impl<buffer_mode, Ts...>(file_name, delim);
} }
} /* namespace */ } /* anonymous namespace */

16
test/test_parser1.hpp
View File

@ -12,7 +12,8 @@
#include <unordered_set> #include <unordered_set>
namespace { namespace {
[[maybe_unused]] void replace_all(std::string& s, const std::string& from, #ifdef _WIN32
void replace_all(std::string& s, const std::string& from,
const std::string& to) { const std::string& to) {
if (from.empty()) return; if (from.empty()) return;
size_t start_pos = 0; size_t start_pos = 0;
@ -21,6 +22,7 @@ namespace {
start_pos += to.length(); start_pos += to.length();
} }
} }
#endif
template <typename... Ts> template <typename... Ts>
void expect_error_on_command(ss::parser<Ts...>& p, void expect_error_on_command(ss::parser<Ts...>& p,
@ -28,6 +30,7 @@ void expect_error_on_command(ss::parser<Ts...>& p,
if (ss::setup<Ts...>::throw_on_error) { if (ss::setup<Ts...>::throw_on_error) {
try { try {
command(); command();
FAIL("expected exception");
} catch (const std::exception& e) { } catch (const std::exception& e) {
CHECK_FALSE(std::string{e.what()}.empty()); CHECK_FALSE(std::string{e.what()}.empty());
} }
@ -55,7 +58,7 @@ struct X {
double d; double d;
std::string s; std::string s;
std::string to_string() const { [[nodiscard]] std::string to_string() const {
if (s == empty) { if (s == empty) {
return ""; return "";
} }
@ -66,14 +69,15 @@ struct X {
.append(delim) .append(delim)
.append(s); .append(s);
} }
auto tied() const {
[[nodiscard]] auto tied() const {
return std::tie(i, d, s); return std::tie(i, d, s);
} }
}; };
template <typename T> template <typename T>
std::enable_if_t<ss::has_m_tied_t<T>, bool> operator==(const T& lhs, [[nodiscard]] std::enable_if_t<ss::has_m_tied_t<T>, bool> operator==(
const T& rhs) { const T& lhs, const T& rhs) {
return lhs.tied() == rhs.tied(); return lhs.tied() == rhs.tied();
} }
@ -109,4 +113,4 @@ static void make_and_write(const std::string& file_name,
} }
} }
} /* namespace */ } /* anonymous namespace */

5
test/test_parser1_1.cpp
View File

@ -57,7 +57,7 @@ struct Y {
.append(s3); .append(s3);
} }
auto tied() const { [[nodiscard]] auto tied() const {
return std::tie(s1, s2, s3); return std::tie(s1, s2, s3);
} }
}; };
@ -115,7 +115,8 @@ TEST_CASE_TEMPLATE("test line method", T, ParserOptionCombinations) {
CHECK_EQ(p.line(), expected_line); CHECK_EQ(p.line(), expected_line);
while (!p.eof()) { while (!p.eof()) {
auto _ = p.template get_next<std::string, std::string, std::string>(); std::ignore =
p.template get_next<std::string, std::string, std::string>();
++expected_line; ++expected_line;
CHECK_EQ(p.line(), expected_line); CHECK_EQ(p.line(), expected_line);
} }

9
test/test_parser1_2.cpp
View File

@ -51,12 +51,14 @@ TEST_CASE_TEMPLATE("test moving of parsed composite values", T,
// to compile is enough // to compile is enough
return; return;
auto [p, _] = make_parser<buffer_mode, ErrorMode>("", ""); auto [p, _] = make_parser<buffer_mode, ErrorMode>("", "");
std::ignore =
p.template try_next<my_string, my_string, my_string>() p.template try_next<my_string, my_string, my_string>()
.template or_else<my_string, my_string, my_string, my_string>( .template or_else<my_string, my_string, my_string, my_string>(
[](auto&&) {}) [](auto&&) {})
.template or_else<my_string>([](auto&) {}) .template or_else<my_string>([](auto&) {})
.template or_else<xyz>([](auto&&) {}) .template or_else<xyz>([](auto&&) {})
.template or_object<xyz, my_string, my_string, my_string>([](auto&&) {}) .template or_object<xyz, my_string, my_string, my_string>(
[](auto&&) {})
.template or_else<std::tuple<my_string, my_string, my_string>>( .template or_else<std::tuple<my_string, my_string, my_string>>(
[](auto&, auto&, auto&) {}); [](auto&, auto&, auto&) {});
} }
@ -73,7 +75,7 @@ TEST_CASE_TEMPLATE("parser test string error mode", BufferMode, std::true_type,
auto [p, _] = make_parser<BufferMode::value, ss::string_error>(f.name, ","); auto [p, _] = make_parser<BufferMode::value, ss::string_error>(f.name, ",");
REQUIRE_FALSE(p.eof()); REQUIRE_FALSE(p.eof());
p.template get_next<int>(); std::ignore = p.template get_next<int>();
CHECK_FALSE(p.valid()); CHECK_FALSE(p.valid());
CHECK_FALSE(p.error_msg().empty()); CHECK_FALSE(p.error_msg().empty());
} }
@ -92,7 +94,7 @@ TEST_CASE_TEMPLATE("parser throw on error mode", BufferMode, std::true_type,
REQUIRE_FALSE(p.eof()); REQUIRE_FALSE(p.eof());
try { try {
p.template get_next<int>(); std::ignore = p.template get_next<int>();
FAIL("Expected exception..."); FAIL("Expected exception...");
} catch (const std::exception& e) { } catch (const std::exception& e) {
CHECK_FALSE(std::string{e.what()}.empty()); CHECK_FALSE(std::string{e.what()}.empty());
@ -148,6 +150,7 @@ TEST_CASE_TEMPLATE("test quote multiline", T, ParserOptionCombinations) {
make_parser<buffer_mode, ErrorMode, ss::quote<'"'>>(f.name, ","); make_parser<buffer_mode, ErrorMode, ss::quote<'"'>>(f.name, ",");
while (!p.eof()) { while (!p.eof()) {
auto command = [&p_no_multiline = p_no_multiline] { auto command = [&p_no_multiline = p_no_multiline] {
std::ignore =
p_no_multiline.template get_next<int, double, std::string>(); p_no_multiline.template get_next<int, double, std::string>();
}; };
expect_error_on_command(p_no_multiline, command); expect_error_on_command(p_no_multiline, command);

2
test/test_parser1_3.cpp
View File

@ -83,7 +83,7 @@ void test_unterminated_line(const std::vector<std::string>& lines,
size_t line = 0; size_t line = 0;
while (!p.eof()) { while (!p.eof()) {
auto command = [&p = p] { auto command = [&p = p] {
p.template get_next<int, double, std::string>(); std::ignore = p.template get_next<int, double, std::string>();
}; };
if (line == bad_line) { if (line == bad_line) {

217
test/test_parser1_4.cpp
View File

@ -9,6 +9,7 @@ struct has_type<T, std::tuple<Us...>>
template <typename T, typename... Ts> template <typename T, typename... Ts>
static void test_fields(const std::string file_name, const std::vector<X>& data, static void test_fields(const std::string file_name, const std::vector<X>& data,
const std::vector<std::string>& header,
const std::vector<std::string>& fields) { const std::vector<std::string>& fields) {
constexpr auto buffer_mode = T::BufferMode::value; constexpr auto buffer_mode = T::BufferMode::value;
using ErrorMode = typename T::ErrorMode; using ErrorMode = typename T::ErrorMode;
@ -17,9 +18,14 @@ static void test_fields(const std::string file_name, const std::vector<X>& data,
auto [p, _] = make_parser<buffer_mode, ErrorMode>(file_name, ","); auto [p, _] = make_parser<buffer_mode, ErrorMode>(file_name, ",");
CHECK_FALSE(p.field_exists("Unknown")); CHECK_FALSE(p.field_exists("Unknown"));
p.use_fields(fields); p.use_fields(fields);
CHECK_EQ_ARRAY(header, p.header());
CHECK_EQ(merge_header(p.header(), ","), p.raw_header());
std::vector<CaseType> i; std::vector<CaseType> i;
for (const auto& a : p.template iterate<CaseType>()) { for (const auto& a : p.template iterate<CaseType>()) {
CHECK_EQ_ARRAY(header, p.header());
CHECK_EQ(merge_header(p.header(), ","), p.raw_header());
i.push_back(a); i.push_back(a);
} }
@ -40,12 +46,12 @@ static void test_fields(const std::string file_name, const std::vector<X>& data,
TEST_CASE_TEMPLATE("test various cases with header", T, TEST_CASE_TEMPLATE("test various cases with header", T,
ParserOptionCombinations) { ParserOptionCombinations) {
unique_file_name f{"various_cases_with_header"}; unique_file_name f{"various_cases_with_header"};
using str = std::string;
constexpr static auto Int = "Int"; constexpr static auto Int = "Int";
constexpr static auto Dbl = "Double"; constexpr static auto Dbl = "Double";
constexpr static auto Str = "String"; constexpr static auto Str = "String";
using str = std::string; const std::vector<std::string> header{Int, Dbl, Str};
std::vector<std::string> header{Int, Dbl, Str};
std::vector<X> data = {{1, 2, "x"}, {3, 4, "y"}, {5, 6, "z"}, std::vector<X> data = {{1, 2, "x"}, {3, 4, "y"}, {5, 6, "z"},
{7, 8, "u"}, {9, 10, "v"}, {11, 12, "w"}}; {7, 8, "u"}, {9, 10, "v"}, {11, 12, "w"}};
@ -59,6 +65,8 @@ TEST_CASE_TEMPLATE("test various cases with header", T,
std::vector<X> i; std::vector<X> i;
for (const auto& a : p.iterate<int, double, std::string>()) { for (const auto& a : p.iterate<int, double, std::string>()) {
CHECK_EQ(header, p.header());
CHECK_EQ(merge_header(p.header(), ","), p.raw_header());
i.emplace_back(ss::to_object<X>(a)); i.emplace_back(ss::to_object<X>(a));
} }
@ -71,46 +79,22 @@ TEST_CASE_TEMPLATE("test various cases with header", T,
p.ignore_next(); p.ignore_next();
for (const auto& a : p.iterate<int, double, std::string>()) { for (const auto& a : p.iterate<int, double, std::string>()) {
CHECK_EQ(header, p.header());
CHECK_EQ(merge_header(p.header(), ","), p.raw_header());
i.emplace_back(ss::to_object<X>(a)); i.emplace_back(ss::to_object<X>(a));
} }
CHECK_EQ(i, data); 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, ","}; ss::parser<ss::string_error> p{f.name, ","};
CHECK_EQ(header, p.header());
CHECK_EQ(merge_header(p.header(), ","), p.raw_header());
p.use_fields(Int, Dbl); p.use_fields(Int, Dbl);
CHECK_EQ(header, p.header());
CHECK_EQ(merge_header(p.header(), ","), p.raw_header());
{ {
auto [int_, double_] = p.get_next<int, double>(); auto [int_, double_] = p.get_next<int, double>();
@ -119,6 +103,8 @@ TEST_CASE_TEMPLATE("test various cases with header", T,
} }
p.use_fields(Dbl, Int); p.use_fields(Dbl, Int);
CHECK_EQ(header, p.header());
CHECK_EQ(merge_header(p.header(), ","), p.raw_header());
{ {
auto [double_, int_] = p.get_next<double, int>(); auto [double_, int_] = p.get_next<double, int>();
@ -163,25 +149,25 @@ TEST_CASE_TEMPLATE("test various cases with header", T,
template_params.append(type) template_params.append(type)
arg_params.append(header[type]) arg_params.append(header[type])
call = 'testFields<' + ', '.join(template_params) + \ call = 'testFields<' + ', '.join(template_params) + \
'>(o, d, {' + ', '.join(arg_params) + '});' '>(o, d, header, {' + ', '.join(arg_params) + '});'
print(call) print(call)
*/ */
test_fields<T, str>(o, d, {Str}); test_fields<T, str>(o, d, header, {Str});
test_fields<T, int>(o, d, {Int}); test_fields<T, int>(o, d, header, {Int});
test_fields<T, double>(o, d, {Dbl}); test_fields<T, double>(o, d, header, {Dbl});
test_fields<T, str, int>(o, d, {Str, Int}); test_fields<T, str, int>(o, d, header, {Str, Int});
test_fields<T, str, double>(o, d, {Str, Dbl}); test_fields<T, str, double>(o, d, header, {Str, Dbl});
test_fields<T, int, str>(o, d, {Int, Str}); test_fields<T, int, str>(o, d, header, {Int, Str});
test_fields<T, int, double>(o, d, {Int, Dbl}); test_fields<T, int, double>(o, d, header, {Int, Dbl});
test_fields<T, double, str>(o, d, {Dbl, Str}); test_fields<T, double, str>(o, d, header, {Dbl, Str});
test_fields<T, double, int>(o, d, {Dbl, Int}); test_fields<T, double, int>(o, d, header, {Dbl, Int});
test_fields<T, str, int, double>(o, d, {Str, Int, Dbl}); test_fields<T, str, int, double>(o, d, header, {Str, Int, Dbl});
test_fields<T, str, double, int>(o, d, {Str, Dbl, Int}); test_fields<T, str, double, int>(o, d, header, {Str, Dbl, Int});
test_fields<T, int, str, double>(o, d, {Int, Str, Dbl}); test_fields<T, int, str, double>(o, d, header, {Int, Str, Dbl});
test_fields<T, int, double, str>(o, d, {Int, Dbl, Str}); test_fields<T, int, double, str>(o, d, header, {Int, Dbl, Str});
test_fields<T, double, str, int>(o, d, {Dbl, Str, Int}); test_fields<T, double, str, int>(o, d, header, {Dbl, Str, Int});
test_fields<T, double, int, str>(o, d, {Dbl, Int, Str}); test_fields<T, double, int, str>(o, d, header, {Dbl, Int, Str});
} }
template <typename T> template <typename T>
@ -190,6 +176,18 @@ void test_invalid_fields(const std::vector<std::string>& lines,
constexpr auto buffer_mode = T::BufferMode::value; constexpr auto buffer_mode = T::BufferMode::value;
using ErrorMode = typename T::ErrorMode; using ErrorMode = typename T::ErrorMode;
auto check_header = [&lines](auto& p) {
if (lines.empty()) {
CHECK_EQ(p.header().size(), 1);
CHECK_EQ(p.header().at(0), "");
CHECK_EQ(merge_header(p.header(), ","), p.raw_header());
} else {
CHECK_EQ(lines[0], merge_header(p.header()));
CHECK_EQ(merge_header(p.header(), ","), p.raw_header());
}
CHECK(p.valid());
};
unique_file_name f{"invalid_fields"}; unique_file_name f{"invalid_fields"};
{ {
std::ofstream out{f.name}; std::ofstream out{f.name};
@ -203,6 +201,7 @@ void test_invalid_fields(const std::vector<std::string>& lines,
auto [p, _] = make_parser<buffer_mode, ErrorMode>(f.name, ","); auto [p, _] = make_parser<buffer_mode, ErrorMode>(f.name, ",");
auto command = [&p = p] { p.use_fields(); }; auto command = [&p = p] { p.use_fields(); };
expect_error_on_command(p, command); expect_error_on_command(p, command);
check_header(p);
} }
{ {
@ -210,6 +209,7 @@ void test_invalid_fields(const std::vector<std::string>& lines,
auto [p, _] = make_parser<buffer_mode, ErrorMode>(f.name, ","); auto [p, _] = make_parser<buffer_mode, ErrorMode>(f.name, ",");
auto command = [&p = p] { p.use_fields("Unknown"); }; auto command = [&p = p] { p.use_fields("Unknown"); };
expect_error_on_command(p, command); expect_error_on_command(p, command);
check_header(p);
} }
{ {
@ -221,6 +221,7 @@ void test_invalid_fields(const std::vector<std::string>& lines,
if (!fields.empty()) { if (!fields.empty()) {
expect_error_on_command(p, command); expect_error_on_command(p, command);
} }
check_header(p);
} }
{ {
@ -228,17 +229,21 @@ void test_invalid_fields(const std::vector<std::string>& lines,
auto [p, _] = make_parser<buffer_mode, ErrorMode>(f.name, ","); auto [p, _] = make_parser<buffer_mode, ErrorMode>(f.name, ",");
auto command = [&p = p, &fields = fields] { auto command = [&p = p, &fields = fields] {
p.use_fields(fields.at(0)); p.use_fields(fields.at(0));
p.template get_next<std::string, std::string>(); std::ignore = p.template get_next<std::string, std::string>();
}; };
check_header(p);
if (!fields.empty()) { if (!fields.empty()) {
expect_error_on_command(p, command); expect_error_on_command(p, command);
} }
check_header(p);
} }
{ {
// Invalid header // Invalid header
auto [p, _] = make_parser<buffer_mode, ErrorMode>(f.name, ","); auto [p, _] = make_parser<buffer_mode, ErrorMode>(f.name, ",");
auto command = [&p = p, &fields = fields] { p.use_fields(fields); }; auto command = [&p = p, &fields = fields] { p.use_fields(fields); };
check_header(p);
if (!fields.empty()) { if (!fields.empty()) {
// Pass if there are no duplicates, fail otherwise // Pass if there are no duplicates, fail otherwise
@ -255,10 +260,11 @@ void test_invalid_fields(const std::vector<std::string>& lines,
} }
} }
} }
check_header(p);
} }
} }
TEST_CASE_TEMPLATE("test invalid fheader fields usage", T, TEST_CASE_TEMPLATE("test invalid header fields usage", T,
ParserOptionCombinations) { ParserOptionCombinations) {
test_invalid_fields<T>({}, {}); test_invalid_fields<T>({}, {});
@ -289,7 +295,7 @@ TEST_CASE_TEMPLATE("test invalid rows with header", T,
constexpr auto buffer_mode = T::BufferMode::value; constexpr auto buffer_mode = T::BufferMode::value;
using ErrorMode = typename T::ErrorMode; using ErrorMode = typename T::ErrorMode;
unique_file_name f{"invalid rows with header"}; unique_file_name f{"invalid_rows_with_header"};
{ {
std::ofstream out{f.name}; std::ofstream out{f.name};
out << "Int,String,Double" << std::endl; out << "Int,String,Double" << std::endl;
@ -301,8 +307,12 @@ TEST_CASE_TEMPLATE("test invalid rows with header", T,
out << "six,line6,10.11" << std::endl; out << "six,line6,10.11" << std::endl;
} }
std::vector<std::string> header = {"Int", "String", "Double"};
{ {
auto [p, _] = make_parser<buffer_mode, ErrorMode>(f.name); auto [p, _] = make_parser<buffer_mode, ErrorMode>(f.name);
CHECK_EQ_ARRAY(header, p.header());
CHECK_EQ(merge_header(p.header()), p.raw_header());
p.use_fields("Int", "String", "Double"); p.use_fields("Int", "String", "Double");
using data = std::tuple<int, std::string, double>; using data = std::tuple<int, std::string, double>;
@ -325,10 +335,14 @@ TEST_CASE_TEMPLATE("test invalid rows with header", T,
{3, "line3", 67.8}, {3, "line3", 67.8},
{5, "line5", 9.10}}; {5, "line5", 9.10}};
CHECK_EQ(i, expected); CHECK_EQ(i, expected);
CHECK_EQ_ARRAY(header, p.header());
CHECK_EQ(merge_header(p.header()), p.raw_header());
} }
{ {
auto [p, _] = make_parser<buffer_mode, ErrorMode>(f.name); auto [p, _] = make_parser<buffer_mode, ErrorMode>(f.name);
CHECK_EQ_ARRAY(header, p.header());
CHECK_EQ(merge_header(p.header()), p.raw_header());
p.use_fields("Double", "Int"); p.use_fields("Double", "Int");
using data = std::tuple<double, int>; using data = std::tuple<double, int>;
@ -349,10 +363,14 @@ TEST_CASE_TEMPLATE("test invalid rows with header", T,
std::vector<data> expected = {{2.34, 1}, {67.8, 3}, {9.10, 5}}; std::vector<data> expected = {{2.34, 1}, {67.8, 3}, {9.10, 5}};
CHECK_EQ(i, expected); CHECK_EQ(i, expected);
CHECK_EQ_ARRAY(header, p.header());
CHECK_EQ(merge_header(p.header()), p.raw_header());
} }
{ {
auto [p, _] = make_parser<buffer_mode, ErrorMode>(f.name); auto [p, _] = make_parser<buffer_mode, ErrorMode>(f.name);
CHECK_EQ_ARRAY(header, p.header());
CHECK_EQ(merge_header(p.header()), p.raw_header());
p.use_fields("String", "Double"); p.use_fields("String", "Double");
using data = std::tuple<std::string, double>; using data = std::tuple<std::string, double>;
@ -376,96 +394,7 @@ TEST_CASE_TEMPLATE("test invalid rows with header", T,
{"line5", 9.10}, {"line5", 9.10},
{"line6", 10.11}}; {"line6", 10.11}};
CHECK_EQ(i, expected); CHECK_EQ(i, expected);
CHECK_EQ_ARRAY(header, p.header());
CHECK_EQ(merge_header(p.header()), p.raw_header());
} }
} }
template <typename T>
void test_ignore_empty(const std::vector<X>& data) {
constexpr auto buffer_mode = T::BufferMode::value;
using ErrorMode = typename T::ErrorMode;
unique_file_name f{"ignore_empty"};
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, ErrorMode, ss::ignore_empty>(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, ErrorMode>(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);
}
}
TEST_CASE_TEMPLATE("test various cases with empty lines", T,
ParserOptionCombinations) {
test_ignore_empty<T>(
{{1, 2, "x"}, {3, 4, "y"}, {9, 10, "v"}, {11, 12, "w"}});
test_ignore_empty<T>(
{{1, 2, X::empty}, {3, 4, "y"}, {9, 10, "v"}, {11, 12, "w"}});
test_ignore_empty<T>(
{{1, 2, "x"}, {3, 4, "y"}, {9, 10, "v"}, {11, 12, X::empty}});
test_ignore_empty<T>(
{{1, 2, "x"}, {5, 6, X::empty}, {9, 10, "v"}, {11, 12, "w"}});
test_ignore_empty<T>(
{{1, 2, X::empty}, {5, 6, X::empty}, {9, 10, "v"}, {11, 12, "w"}});
test_ignore_empty<T>(
{{1, 2, X::empty}, {3, 4, "y"}, {9, 10, "v"}, {11, 12, X::empty}});
test_ignore_empty<T>(
{{1, 2, "x"}, {3, 4, "y"}, {9, 10, X::empty}, {11, 12, X::empty}});
test_ignore_empty<T>(
{{1, 2, X::empty}, {3, 4, "y"}, {9, 10, X::empty}, {11, 12, X::empty}});
test_ignore_empty<T>({{1, 2, X::empty},
{3, 4, X::empty},
{9, 10, X::empty},
{11, 12, X::empty}});
test_ignore_empty<T>(
{{1, 2, "x"}, {3, 4, X::empty}, {9, 10, X::empty}, {11, 12, X::empty}});
test_ignore_empty<T>(
{{1, 2, X::empty}, {3, 4, X::empty}, {9, 10, X::empty}, {11, 12, "w"}});
test_ignore_empty<T>({{11, 12, X::empty}});
test_ignore_empty<T>({});
}

301
test/test_parser1_5.cpp Normal file
View File

@ -0,0 +1,301 @@
#include "test_parser1.hpp"
TEST_CASE_TEMPLATE("test empty fields header", T, ParserOptionCombinations) {
constexpr auto buffer_mode = T::BufferMode::value;
using ErrorMode = typename T::ErrorMode;
unique_file_name f{"empty_fields_header"};
// Empty header
{
std::ofstream out{f.name};
out << "" << std::endl;
out << "1" << std::endl;
}
{
std::vector<std::string> expected_header = {""};
auto [p, _] = make_parser<buffer_mode, ErrorMode>(f.name);
CHECK_EQ_ARRAY(expected_header, p.header());
CHECK_EQ("", p.raw_header());
CHECK(p.valid());
}
// All empty header fields
{
std::ofstream out{f.name};
out << ",," << std::endl;
out << "1,2,3" << std::endl;
}
{
std::vector<std::string> expected_header = {"", "", ""};
auto [p, _] = make_parser<buffer_mode, ErrorMode>(f.name);
CHECK_EQ_ARRAY(expected_header, p.header());
CHECK_EQ(",,", p.raw_header());
CHECK(p.valid());
auto command1 = [&p = p] { std::ignore = p.field_exists("Int"); };
expect_error_on_command(p, command1);
auto command2 = [&p = p] { p.use_fields("Int"); };
expect_error_on_command(p, command2);
}
// One empty field
const std::vector<std::string> valid_fields = {"Int0", "Int1", ""};
using svec = std::vector<std::string>;
const std::vector<std::vector<std::string>> valid_field_combinations =
{svec{"Int0"},
svec{"Int1"},
svec{""},
svec{"", "Int0"},
svec{"Int0", "Int1"},
svec{"Int1", ""},
svec{"Int0", "", "Int1"},
svec{"", "Int1", "Int0"}};
// Last header field empty
{
std::ofstream out{f.name};
out << "Int0,Int1," << std::endl;
out << "1,2,3" << std::endl;
}
{
std::vector<std::string> expected_header = {"Int0", "Int1", ""};
auto [p, _] = make_parser<buffer_mode, ErrorMode>(f.name);
CHECK_EQ_ARRAY(expected_header, p.header());
CHECK_EQ("Int0,Int1,", p.raw_header());
CHECK(p.valid());
for (const auto& field : valid_fields) {
CHECK(p.field_exists(field));
CHECK(p.valid());
}
for (const auto& fields : valid_field_combinations) {
p.use_fields(fields);
CHECK(p.valid());
}
}
// First header field empty
{
std::ofstream out{f.name};
out << ",Int0,Int1" << std::endl;
out << "1,2,3" << std::endl;
}
{
std::vector<std::string> expected_header = {"", "Int0", "Int1"};
auto [p, _] = make_parser<buffer_mode, ErrorMode>(f.name);
CHECK_EQ_ARRAY(expected_header, p.header());
CHECK_EQ(",Int0,Int1", p.raw_header());
CHECK(p.valid());
for (const auto& field : valid_fields) {
CHECK(p.field_exists(field));
CHECK(p.valid());
}
for (const auto& fields : valid_field_combinations) {
p.use_fields(fields);
CHECK(p.valid());
}
}
// Middle header field empty
{
std::ofstream out{f.name};
out << "Int0,,Int1" << std::endl;
out << "1,2,3" << std::endl;
}
{
std::vector<std::string> expected_header = {"Int0", "", "Int1"};
auto [p, _] = make_parser<buffer_mode, ErrorMode>(f.name);
CHECK_EQ_ARRAY(expected_header, p.header());
CHECK_EQ("Int0,,Int1", p.raw_header());
CHECK(p.valid());
for (const auto& field : valid_fields) {
CHECK(p.field_exists(field));
CHECK(p.valid());
}
for (const auto& fields : valid_field_combinations) {
p.use_fields(fields);
CHECK(p.valid());
}
}
}
template <typename T, typename... Ts>
void test_unterminated_quote_header() {
constexpr auto buffer_mode = T::BufferMode::value;
using ErrorMode = typename T::ErrorMode;
unique_file_name f{"unterminated_quote_header"};
{
std::ofstream out{f.name};
out << "\"Int" << std::endl;
out << "1" << std::endl;
}
{
auto [p, _] = make_parser<buffer_mode, ErrorMode, Ts...>(f.name);
auto command0 = [&p = p] { std::ignore = p.header(); };
expect_error_on_command(p, command0);
CHECK_EQ(p.raw_header(), "\"Int");
auto command1 = [&p = p] { std::ignore = p.field_exists("Int"); };
expect_error_on_command(p, command1);
auto command2 = [&p = p] { p.use_fields("Int"); };
expect_error_on_command(p, command2);
}
}
TEST_CASE_TEMPLATE("test unterminated quote header", T,
ParserOptionCombinations) {
using quote = ss::quote<'"'>;
using escape = ss::escape<'\\'>;
test_unterminated_quote_header<T, quote>();
test_unterminated_quote_header<T, quote, ss::multiline>();
test_unterminated_quote_header<T, quote, escape>();
test_unterminated_quote_header<T, quote, escape, ss::multiline>();
}
template <typename T, typename... Ts>
void test_unterminated_escape_header() {
constexpr auto buffer_mode = T::BufferMode::value;
using ErrorMode = typename T::ErrorMode;
unique_file_name f{"unterminated_escape_header"};
// Unterminated escape in header
{
std::ofstream out{f.name};
out << "Int\\" << std::endl;
out << "1" << std::endl;
}
{
auto [p, _] = make_parser<buffer_mode, ErrorMode, Ts...>(f.name);
auto command0 = [&p = p] { std::ignore = p.header(); };
expect_error_on_command(p, command0);
CHECK_EQ(p.raw_header(), "Int\\");
auto command1 = [&p = p] { std::ignore = p.field_exists("Int"); };
expect_error_on_command(p, command1);
auto command2 = [&p = p] { p.use_fields("Int"); };
expect_error_on_command(p, command2);
}
}
TEST_CASE_TEMPLATE("test unterminated escape header", T,
ParserOptionCombinations) {
using quote = ss::quote<'"'>;
using escape = ss::escape<'\\'>;
test_unterminated_escape_header<T, escape>();
test_unterminated_escape_header<T, escape, ss::multiline>();
test_unterminated_escape_header<T, escape, quote>();
test_unterminated_escape_header<T, escape, quote, ss::multiline>();
}
template <typename T>
void test_ignore_empty(const std::vector<X>& data) {
constexpr auto buffer_mode = T::BufferMode::value;
using ErrorMode = typename T::ErrorMode;
unique_file_name f{"ignore_empty"};
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, ErrorMode, ss::ignore_empty>(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, ErrorMode>(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);
}
}
TEST_CASE_TEMPLATE("test various cases with empty lines", T,
ParserOptionCombinations) {
test_ignore_empty<T>(
{{1, 2, "x"}, {3, 4, "y"}, {9, 10, "v"}, {11, 12, "w"}});
test_ignore_empty<T>(
{{1, 2, X::empty}, {3, 4, "y"}, {9, 10, "v"}, {11, 12, "w"}});
test_ignore_empty<T>(
{{1, 2, "x"}, {3, 4, "y"}, {9, 10, "v"}, {11, 12, X::empty}});
test_ignore_empty<T>(
{{1, 2, "x"}, {5, 6, X::empty}, {9, 10, "v"}, {11, 12, "w"}});
test_ignore_empty<T>(
{{1, 2, X::empty}, {5, 6, X::empty}, {9, 10, "v"}, {11, 12, "w"}});
test_ignore_empty<T>(
{{1, 2, X::empty}, {3, 4, "y"}, {9, 10, "v"}, {11, 12, X::empty}});
test_ignore_empty<T>(
{{1, 2, "x"}, {3, 4, "y"}, {9, 10, X::empty}, {11, 12, X::empty}});
test_ignore_empty<T>(
{{1, 2, X::empty}, {3, 4, "y"}, {9, 10, X::empty}, {11, 12, X::empty}});
test_ignore_empty<T>({{1, 2, X::empty},
{3, 4, X::empty},
{9, 10, X::empty},
{11, 12, X::empty}});
test_ignore_empty<T>(
{{1, 2, "x"}, {3, 4, X::empty}, {9, 10, X::empty}, {11, 12, X::empty}});
test_ignore_empty<T>(
{{1, 2, X::empty}, {3, 4, X::empty}, {9, 10, X::empty}, {11, 12, "w"}});
test_ignore_empty<T>({{11, 12, X::empty}});
test_ignore_empty<T>({});
}

29
test/test_parser2.hpp
View File

@ -1,13 +1,7 @@
#include "test_helpers.hpp" #include "test_helpers.hpp"
#include <algorithm>
#include <filesystem>
#include <fstream> #include <fstream>
#include <iomanip>
#include <iostream> #include <iostream>
#include <regex>
#include <ss/parser.hpp> #include <ss/parser.hpp>
#include <sstream>
#include <unordered_map>
#include <unordered_set> #include <unordered_set>
#ifndef SEGMENT_NAME #ifndef SEGMENT_NAME
@ -91,7 +85,7 @@ struct column {
}; };
template <typename... Ts> template <typename... Ts>
column make_column(const std::string& input_header, [[nodiscard]] column make_column(const std::string& input_header,
const std::vector<field>& input_fields) { const std::vector<field>& input_fields) {
using setup = ss::setup<Ts...>; using setup = ss::setup<Ts...>;
std::vector<field> filtered_fields; std::vector<field> filtered_fields;
@ -133,8 +127,8 @@ column make_column(const std::string& input_header,
} }
template <typename... Ts> template <typename... Ts>
std::vector<std::string> generate_csv_data(const std::vector<field>& data, [[nodiscard]] std::vector<std::string> generate_csv_data(
const std::string& delim) { const std::vector<field>& data, const std::string& delim) {
(void)delim; (void)delim;
using setup = ss::setup<Ts...>; using setup = ss::setup<Ts...>;
constexpr static auto escape = '\\'; constexpr static auto escape = '\\';
@ -333,8 +327,10 @@ void test_data_combinations(const std::vector<column>& input_data,
field_header.push_back(field{el.header}); field_header.push_back(field{el.header});
} }
std::string header_line;
if (include_header) { if (include_header) {
auto header_data = generate_csv_data<Ts...>(field_header, delim); auto header_data = generate_csv_data<Ts...>(field_header, delim);
header_line = merge_header(header_data, delim);
if (input_data.size() == 0 && rand() % 10 == 0) { if (input_data.size() == 0 && rand() % 10 == 0) {
write_to_file(header_data, delim, f.name, false); write_to_file(header_data, delim, f.name, false);
} else { } else {
@ -403,7 +399,9 @@ void test_data_combinations(const std::vector<column>& input_data,
fields.push_back(header[index]); fields.push_back(header[index]);
} }
if constexpr (!setup::ignore_header) {
p.use_fields(fields); p.use_fields(fields);
}
if (!p.valid()) { if (!p.valid()) {
if constexpr (setup::string_error) { if constexpr (setup::string_error) {
@ -425,8 +423,19 @@ void test_data_combinations(const std::vector<column>& input_data,
} }
}; };
auto check_header = [&p = p, &header = header, include_header,
header_line] {
if (include_header) {
if constexpr (!setup::ignore_header) {
CHECK_EQ_ARRAY(header, p.header());
CHECK_EQ(header_line, p.raw_header());
}
}
};
int num_columns = layout.size(); int num_columns = layout.size();
for (size_t i = 0; i < n + 1; ++i) { for (size_t i = 0; i < n + 1; ++i) {
check_header();
try { try {
switch (num_columns) { switch (num_columns) {
case 1: { case 1: {
@ -616,7 +625,7 @@ void test_option_combinations3() {
test_option_combinations2<Ts..., trim>(); test_option_combinations2<Ts..., trim>();
} }
} /* namespace */ } /* anonymous namespace */
// Tests split into multiple compilation units // Tests split into multiple compilation units
#if 0 #if 0

1
test/test_parser2_1.cpp
View File

@ -9,4 +9,3 @@ TEST_CASE("parser test various cases version 2 segment 1") {
test_option_combinations3<escape>(); test_option_combinations3<escape>();
#endif #endif
} }

1
test/test_parser2_2.cpp
View File

@ -10,4 +10,3 @@ TEST_CASE("parser test various cases version 2 segment 2") {
test_option_combinations3<escape, quote>(); test_option_combinations3<escape, quote>();
#endif #endif
} }

1
test/test_parser2_3.cpp
View File

@ -11,4 +11,3 @@ TEST_CASE("parser test various cases version 2 segment 3") {
test_option_combinations3<quote, multiline>(); test_option_combinations3<quote, multiline>();
#endif #endif
} }

1
test/test_parser2_4.cpp
View File

@ -12,4 +12,3 @@ TEST_CASE("parser test various cases version 2 segment 4") {
test_option_combinations3<escape, quote, multiline_r>(); test_option_combinations3<escape, quote, multiline_r>();
#endif #endif
} }

1
test/test_parser2_5.cpp
View File

@ -13,4 +13,3 @@ TEST_CASE("parser test various cases version 2 segment 5") {
test_option_combinations<escape, quote, multiline, trimr>(); test_option_combinations<escape, quote, multiline, trimr>();
#endif #endif
} }

1
test/test_parser2_6.cpp
View File

@ -8,4 +8,3 @@ TEST_CASE("parser test various cases version 2 segment 6") {
test_option_combinations3<escape, quote, multiline>(); test_option_combinations3<escape, quote, multiline>();
} }

14
test/test_single_header.sh
View File

@ -3,12 +3,14 @@
set -x set -x
set -e set -e
python3 script/single_header_generator.py > ssp.cpp TMP_HDR=test_single_header.hpp
TMP_SRC=test_single_header.cpp
TMP_BIN=test_single_header
echo 'int main(){ ss::parser p{""}; p.get_next<int, float>(); return 0; }' \ python3 script/single_header_generator.py > ${TMP_HDR}
>> ssp.cpp cat ${TMP_HDR} test/test_single_header_main.txt > ${TMP_SRC}
g++ -std=c++17 ssp.cpp -o ssp.bin -Wall -Wextra g++ -std=c++17 ${TMP_SRC} -o ${TMP_BIN} -Wall -Wextra
./ssp.bin ./${TMP_BIN}
rm ssp.cpp ssp.bin rm ${TMP_HDR} ${TMP_SRC} ${TMP_BIN}

12
test/test_single_header_main.txt Normal file
View File

@ -0,0 +1,12 @@
int main() {
using quote = ss::quote<'"'>;
using escape = ss::escape<'\\'>;
using trim = ss::trim<' '>;
std::string data = "1,string,2.34,c";
ss::parser<quote, escape, trim, ss::multiline> p{data.c_str(), data.size()};
auto tup = p.get_next<int, std::string, float, std::optional<char>>();
return 0;
}

4
test/test_splitter.cpp
View File

@ -145,7 +145,7 @@ make_combinations(const std::vector<std::string>& input,
return {std::move(lines), std::move(expectations)}; return {std::move(lines), std::move(expectations)};
} }
} /* namespace */ } /* anonymous namespace */
/* ********************************** */ /* ********************************** */
/* ********************************** */ /* ********************************** */
@ -548,7 +548,7 @@ public:
return splitter.size_shifted(); return splitter.size_shifted();
} }
}; };
} /* ss */ } /* namespace ss */
TEST_CASE("splitter test resplit unterminated quote") { TEST_CASE("splitter test resplit unterminated quote") {