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

get rid of maybe-uninitialized warnings

Browse Source
This commit is contained in:
ado 2021-02-01 00:56:42 +01:00
parent 035e27c5ab
commit d887dff82a
6 changed files with 88 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
include/ss/converter.hpp
View File

@ -127,12 +127,11 @@ public:
no_void_validator_tup_t<Ts...> convert(
line_ptr_type line, const std::string& delim = default_delimiter) {
input_ = split(line, delim);
/* TODO
if (!splitter_.valid()) {
// set error
return {};
set_error_line_not_split();
no_void_validator_tup_t<Ts...> ret{};
return ret;
}
*/
return convert<Ts...>(input_);
}
@ -235,19 +234,10 @@ private:
return error;
}
void set_error_invalid_quotation() {
void set_error_line_not_split() {
if (error_mode_ == error_mode::error_string) {
string_error_.clear();
string_error_.append("invalid quotation");
} else {
bool_error_ = true;
}
}
void set_error_unterminated_quote() {
if (error_mode_ == error_mode::error_string) {
string_error_.clear();
string_error_.append("unterminated quote");
string_error_.append("line not split correctly");
} else {
bool_error_ = true;
}
@ -293,9 +283,9 @@ private:
template <typename... Ts>
no_void_validator_tup_t<Ts...> convert_impl(const split_input& elems) {
clear_error();
no_void_validator_tup_t<Ts...> ret{};
if (sizeof...(Ts) != elems.size()) {
set_error_number_of_colums(sizeof...(Ts), elems.size());
no_void_validator_tup_t<Ts...> ret{};
return ret;
}
return extract_tuple<Ts...>(elems);
@ -368,7 +358,7 @@ private:
no_void_validator_tup_t<Ts...> extract_tuple(const split_input& elems) {
static_assert(!all_of<std::is_void, Ts...>::value,
"at least one parameter must be non void");
no_void_validator_tup_t<Ts...> ret;
no_void_validator_tup_t<Ts...> ret{};
extract_multiple<0, 0, Ts...>(ret, elems);
return ret;
}

5
include/ss/parser.hpp
View File

@ -9,9 +9,6 @@
#include <string>
#include <vector>
// TODO remove
#include <iostream>
namespace ss {
template <typename... Matchers>
@ -262,7 +259,6 @@ private:
bool crlf;
bool escaped_eol(size_t size) {
// escaped new line
if constexpr (setup<Matchers...>::escape::enabled) {
const char* curr;
for (curr = next_line_buffer_ + size - 1;
@ -277,7 +273,6 @@ private:
}
bool unterminated_quote() {
// unterimated quote
if constexpr (ss::setup<Matchers...>::quote::enabled) {
if (next_line_converter_.unterminated_quote()) {
return true;

4
include/ss/splitter.hpp
View File

@ -428,8 +428,8 @@ private:
std::vector<string_range> output_;
std::string string_error_;
bool bool_error_;
bool unterminated_quote_;
bool bool_error_{false};
bool unterminated_quote_{false};
enum error_mode error_mode_ { error_mode::error_bool };
line_ptr_type begin_;
line_ptr_type curr_;

164
test/test_converter.cpp
View File

@ -13,7 +13,7 @@ TEST_CASE("testing split") {
{"x\t-\ty", {"x", "y"}, "\t-\t"},
{"x", {"x"}, ","}} // clang-format on
) {
auto split = c.split(buff(s), delim);
auto split = c.split(s, delim);
CHECK(split.size() == expected.size());
for (size_t i = 0; i < split.size(); ++i) {
auto s = std::string(split[i].first, split[i].second);
@ -26,84 +26,83 @@ TEST_CASE("testing valid conversions") {
ss::converter c;
{
auto tup = c.convert<int>(buff("5"));
auto tup = c.convert<int>("5");
REQUIRE(c.valid());
CHECK(tup == 5);
}
{
auto tup = c.convert<int, void>(buff("5,junk"));
auto tup = c.convert<int, void>("5,junk");
REQUIRE(c.valid());
CHECK(tup == 5);
}
{
auto tup = c.convert<void, int>(buff("junk,5"));
auto tup = c.convert<void, int>("junk,5");
REQUIRE(c.valid());
CHECK(tup == 5);
}
{
auto tup = c.convert<int, void, void>(buff("5\njunk\njunk"), "\n");
auto tup = c.convert<int, void, void>("5\njunk\njunk", "\n");
REQUIRE(c.valid());
CHECK(tup == 5);
}
{
auto tup = c.convert<void, int, void>(buff("junk 5 junk"), " ");
auto tup = c.convert<void, int, void>("junk 5 junk", " ");
REQUIRE(c.valid());
CHECK(tup == 5);
}
{
auto tup = c.convert<void, void, int>(buff("junk\tjunk\t5"), "\t");
auto tup = c.convert<void, void, int>("junk\tjunk\t5", "\t");
REQUIRE(c.valid());
CHECK(tup == 5);
}
{
auto tup =
c.convert<void, void, std::optional<int>>(buff("junk\tjunk\t5"),
"\t");
c.convert<void, void, std::optional<int>>("junk\tjunk\t5", "\t");
REQUIRE(c.valid());
REQUIRE(tup.has_value());
CHECK(tup == 5);
}
{
auto tup = c.convert<int, double, void>(buff("5,6.6,junk"));
auto tup = c.convert<int, double, void>("5,6.6,junk");
REQUIRE(c.valid());
CHECK(tup == std::make_tuple(5, 6.6));
}
{
auto tup = c.convert<int, void, double>(buff("5,junk,6.6"));
auto tup = c.convert<int, void, double>("5,junk,6.6");
REQUIRE(c.valid());
CHECK(tup == std::make_tuple(5, 6.6));
}
{
auto tup = c.convert<void, int, double>(buff("junk;5;6.6"), ";");
auto tup = c.convert<void, int, double>("junk;5;6.6", ";");
REQUIRE(c.valid());
CHECK(tup == std::make_tuple(5, 6.6));
}
{
auto tup =
c.convert<void, std::optional<int>, double>(buff("junk;5;6.6"),
";");
c.convert<void, std::optional<int>, double>("junk;5;6.6", ";");
REQUIRE(c.valid());
REQUIRE(std::get<0>(tup).has_value());
CHECK(tup == std::make_tuple(5, 6.6));
}
{
auto tup =
c.convert<void, std::optional<int>, double>(buff("junk;5.4;6.6"),
";");
c.convert<void, std::optional<int>, double>("junk;5.4;6.6", ";");
REQUIRE(c.valid());
REQUIRE(!std::get<0>(tup).has_value());
CHECK(tup == std::make_tuple(std::optional<int>{}, 6.6));
}
{
auto tup = c.convert<void, std::variant<int, double>,
double>(buff("junk;5;6.6"), ";");
auto tup =
c.convert<void, std::variant<int, double>, double>("junk;5;6.6",
";");
REQUIRE(c.valid());
REQUIRE(std::holds_alternative<int>(std::get<0>(tup)));
CHECK(tup == std::make_tuple(std::variant<int, double>{5}, 6.6));
}
{
auto tup = c.convert<void, std::variant<int, double>,
double>(buff("junk;5.5;6.6"), ";");
auto tup =
c.convert<void, std::variant<int, double>, double>("junk;5.5;6.6",
";");
REQUIRE(c.valid());
REQUIRE(std::holds_alternative<double>(std::get<0>(tup)));
CHECK(tup == std::make_tuple(std::variant<int, double>{5.5}, 6.6));
@ -113,63 +112,60 @@ TEST_CASE("testing valid conversions") {
TEST_CASE("testing invalid conversions") {
ss::converter c;
c.convert<int>(buff(""));
c.convert<int>("");
REQUIRE(!c.valid());
c.convert<int, void>(buff(""));
c.convert<int, void>("");
REQUIRE(!c.valid());
c.convert<int, void>(buff(",junk"));
c.convert<int, void>(",junk");
REQUIRE(!c.valid());
c.convert<void, int>(buff("junk,"));
c.convert<void, int>("junk,");
REQUIRE(!c.valid());
c.convert<int>(buff("x"));
c.convert<int>("x");
REQUIRE(!c.valid());
c.convert<int, void>(buff("x"));
c.convert<int, void>("x");
REQUIRE(!c.valid());
c.convert<int, void>(buff("x,junk"));
c.convert<int, void>("x,junk");
REQUIRE(!c.valid());
c.convert<void, int>(buff("junk,x"));
c.convert<void, int>("junk,x");
REQUIRE(!c.valid());
c.convert<void, std::variant<int, double>, double>(buff("junk;.5.5;6"),
";");
c.convert<void, std::variant<int, double>, double>("junk;.5.5;6", ";");
REQUIRE(!c.valid());
}
TEST_CASE("testing ss:ax restriction (all except)") {
ss::converter c;
c.convert<ss::ax<int, 0>>(buff("0"));
c.convert<ss::ax<int, 0>>("0");
REQUIRE(!c.valid());
c.convert<ss::ax<int, 0, 1, 2>>(buff("1"));
c.convert<ss::ax<int, 0, 1, 2>>("1");
REQUIRE(!c.valid());
c.convert<void, char, ss::ax<int, 0, 1, 2>>(buff("junk,c,1"));
c.convert<void, char, ss::ax<int, 0, 1, 2>>("junk,c,1");
REQUIRE(!c.valid());
c.convert<ss::ax<int, 1>, char>(buff("1,c"));
c.convert<ss::ax<int, 1>, char>("1,c");
REQUIRE(!c.valid());
{
int tup = c.convert<ss::ax<int, 1>>(buff("3"));
int tup = c.convert<ss::ax<int, 1>>("3");
REQUIRE(c.valid());
CHECK(tup == 3);
}
{
std::tuple<char, int> tup =
c.convert<char, ss::ax<int, 1>>(buff("c,3"));
std::tuple<char, int> tup = c.convert<char, ss::ax<int, 1>>("c,3");
REQUIRE(c.valid());
CHECK(tup == std::make_tuple('c', 3));
}
{
std::tuple<int, char> tup =
c.convert<ss::ax<int, 1>, char>(buff("3,c"));
std::tuple<int, char> tup = c.convert<ss::ax<int, 1>, char>("3,c");
REQUIRE(c.valid());
CHECK(tup == std::make_tuple(3, 'c'));
}
@ -178,33 +174,32 @@ TEST_CASE("testing ss:ax restriction (all except)") {
TEST_CASE("testing ss:nx restriction (none except)") {
ss::converter c;
c.convert<ss::nx<int, 1>>(buff("3"));
c.convert<ss::nx<int, 1>>("3");
REQUIRE(!c.valid());
c.convert<char, ss::nx<int, 1, 2, 69>>(buff("c,3"));
c.convert<char, ss::nx<int, 1, 2, 69>>("c,3");
REQUIRE(!c.valid());
c.convert<ss::nx<int, 1>, char>(buff("3,c"));
c.convert<ss::nx<int, 1>, char>("3,c");
REQUIRE(!c.valid());
{
auto tup = c.convert<ss::nx<int, 3>>(buff("3"));
auto tup = c.convert<ss::nx<int, 3>>("3");
REQUIRE(c.valid());
CHECK(tup == 3);
}
{
auto tup = c.convert<ss::nx<int, 0, 1, 2>>(buff("2"));
auto tup = c.convert<ss::nx<int, 0, 1, 2>>("2");
REQUIRE(c.valid());
CHECK(tup == 2);
}
{
auto tup =
c.convert<char, void, ss::nx<int, 0, 1, 2>>(buff("c,junk,1"));
auto tup = c.convert<char, void, ss::nx<int, 0, 1, 2>>("c,junk,1");
REQUIRE(c.valid());
CHECK(tup == std::make_tuple('c', 1));
}
{
auto tup = c.convert<ss::nx<int, 1>, char>(buff("1,c"));
auto tup = c.convert<ss::nx<int, 1>, char>("1,c");
REQUIRE(c.valid());
CHECK(tup == std::make_tuple(1, 'c'));
}
@ -213,32 +208,32 @@ TEST_CASE("testing ss:nx restriction (none except)") {
TEST_CASE("testing ss:ir restriction (in range)") {
ss::converter c;
c.convert<ss::ir<int, 0, 2>>(buff("3"));
c.convert<ss::ir<int, 0, 2>>("3");
REQUIRE(!c.valid());
c.convert<char, ss::ir<int, 4, 69>>(buff("c,3"));
c.convert<char, ss::ir<int, 4, 69>>("c,3");
REQUIRE(!c.valid());
c.convert<ss::ir<int, 1, 2>, char>(buff("3,c"));
c.convert<ss::ir<int, 1, 2>, char>("3,c");
REQUIRE(!c.valid());
{
auto tup = c.convert<ss::ir<int, 1, 5>>(buff("3"));
auto tup = c.convert<ss::ir<int, 1, 5>>("3");
REQUIRE(c.valid());
CHECK(tup == 3);
}
{
auto tup = c.convert<ss::ir<int, 0, 2>>(buff("2"));
auto tup = c.convert<ss::ir<int, 0, 2>>("2");
REQUIRE(c.valid());
CHECK(tup == 2);
}
{
auto tup = c.convert<char, void, ss::ir<int, 0, 1>>(buff("c,junk,1"));
auto tup = c.convert<char, void, ss::ir<int, 0, 1>>("c,junk,1");
REQUIRE(c.valid());
CHECK(tup == std::make_tuple('c', 1));
}
{
auto tup = c.convert<ss::ir<int, 1, 20>, char>(buff("1,c"));
auto tup = c.convert<ss::ir<int, 1, 20>, char>("1,c");
REQUIRE(c.valid());
CHECK(tup == std::make_tuple(1, 'c'));
}
@ -247,32 +242,32 @@ TEST_CASE("testing ss:ir restriction (in range)") {
TEST_CASE("testing ss:oor restriction (out of range)") {
ss::converter c;
c.convert<ss::oor<int, 1, 5>>(buff("3"));
c.convert<ss::oor<int, 1, 5>>("3");
REQUIRE(!c.valid());
c.convert<ss::oor<int, 0, 2>>(buff("2"));
c.convert<ss::oor<int, 0, 2>>("2");
REQUIRE(!c.valid());
c.convert<char, ss::oor<int, 0, 1>, void>(buff("c,1,junk"));
c.convert<char, ss::oor<int, 0, 1>, void>("c,1,junk");
REQUIRE(!c.valid());
c.convert<ss::oor<int, 1, 20>, char>(buff("1,c"));
c.convert<ss::oor<int, 1, 20>, char>("1,c");
REQUIRE(!c.valid());
{
auto tup = c.convert<ss::oor<int, 0, 2>>(buff("3"));
auto tup = c.convert<ss::oor<int, 0, 2>>("3");
REQUIRE(c.valid());
CHECK(tup == 3);
}
{
auto tup = c.convert<char, void, ss::oor<int, 4, 69>>(buff("c,junk,3"));
auto tup = c.convert<char, void, ss::oor<int, 4, 69>>("c,junk,3");
REQUIRE(c.valid());
CHECK(tup == std::make_tuple('c', 3));
}
{
auto tup = c.convert<ss::oor<int, 1, 2>, char>(buff("3,c"));
auto tup = c.convert<ss::oor<int, 1, 2>, char>("3,c");
REQUIRE(c.valid());
CHECK(tup == std::make_tuple(3, 'c'));
}
@ -294,34 +289,33 @@ inline bool ss::extract(const char* begin, const char* end,
TEST_CASE("testing ss:ne restriction (not empty)") {
ss::converter c;
c.convert<ss::ne<std::string>>(buff(""));
c.convert<ss::ne<std::string>>("");
REQUIRE(!c.valid());
c.convert<int, ss::ne<std::string>>(buff("3,"));
c.convert<int, ss::ne<std::string>>("3,");
REQUIRE(!c.valid());
c.convert<ss::ne<std::string>, int>(buff(",3"));
c.convert<ss::ne<std::string>, int>(",3");
REQUIRE(!c.valid());
c.convert<void, ss::ne<std::string>, int>(buff("junk,,3"));
c.convert<void, ss::ne<std::string>, int>("junk,,3");
REQUIRE(!c.valid());
c.convert<ss::ne<std::vector<int>>>(buff(""));
c.convert<ss::ne<std::vector<int>>>("");
REQUIRE(!c.valid());
{
auto tup = c.convert<ss::ne<std::string>>(buff("s"));
auto tup = c.convert<ss::ne<std::string>>("s");
REQUIRE(c.valid());
CHECK(tup == "s");
}
{
auto tup =
c.convert<std::optional<int>, ss::ne<std::string>>(buff("1,s"));
auto tup = c.convert<std::optional<int>, ss::ne<std::string>>("1,s");
REQUIRE(c.valid());
CHECK(tup == std::make_tuple(1, "s"));
}
{
auto tup = c.convert<ss::ne<std::vector<int>>>(buff("{1 2 3}"));
auto tup = c.convert<ss::ne<std::vector<int>>>("{1 2 3}");
REQUIRE(c.valid());
CHECK(tup == extracted_vector);
}
@ -330,56 +324,56 @@ TEST_CASE("testing ss:ne restriction (not empty)") {
TEST_CASE("testing ss:lt ss::lte ss::gt ss::gte restriction (in range)") {
ss::converter c;
c.convert<ss::lt<int, 3>>(buff("3"));
c.convert<ss::lt<int, 3>>("3");
REQUIRE(!c.valid());
c.convert<ss::lt<int, 2>>(buff("3"));
c.convert<ss::lt<int, 2>>("3");
REQUIRE(!c.valid());
c.convert<ss::gt<int, 3>>(buff("3"));
c.convert<ss::gt<int, 3>>("3");
REQUIRE(!c.valid());
c.convert<ss::gt<int, 4>>(buff("3"));
c.convert<ss::gt<int, 4>>("3");
REQUIRE(!c.valid());
c.convert<ss::lte<int, 2>>(buff("3"));
c.convert<ss::lte<int, 2>>("3");
REQUIRE(!c.valid());
c.convert<ss::gte<int, 4>>(buff("3"));
c.convert<ss::gte<int, 4>>("3");
REQUIRE(!c.valid());
{
auto tup = c.convert<ss::lt<int, 4>>(buff("3"));
auto tup = c.convert<ss::lt<int, 4>>("3");
REQUIRE(c.valid());
CHECK(tup == 3);
}
{
auto tup = c.convert<ss::gt<int, 2>>(buff("3"));
auto tup = c.convert<ss::gt<int, 2>>("3");
REQUIRE(c.valid());
CHECK(tup == 3);
}
{
auto tup = c.convert<ss::lte<int, 4>>(buff("3"));
auto tup = c.convert<ss::lte<int, 4>>("3");
REQUIRE(c.valid());
CHECK(tup == 3);
}
{
auto tup = c.convert<ss::lte<int, 3>>(buff("3"));
auto tup = c.convert<ss::lte<int, 3>>("3");
REQUIRE(c.valid());
CHECK(tup == 3);
}
{
auto tup = c.convert<ss::gte<int, 2>>(buff("3"));
auto tup = c.convert<ss::gte<int, 2>>("3");
REQUIRE(c.valid());
CHECK(tup == 3);
}
{
auto tup = c.convert<ss::gte<int, 3>>(buff("3"));
auto tup = c.convert<ss::gte<int, 3>>("3");
REQUIRE(c.valid());
CHECK(tup == 3);
}
@ -388,12 +382,12 @@ TEST_CASE("testing ss:lt ss::lte ss::gt ss::gte restriction (in range)") {
TEST_CASE("testing error mode") {
ss::converter c;
c.convert<int>(buff("junk"));
c.convert<int>("junk");
CHECK(!c.valid());
CHECK(c.error_msg().empty());
c.set_error_mode(ss::error_mode::error_string);
c.convert<int>(buff("junk"));
c.convert<int>("junk");
CHECK(!c.valid());
CHECK(!c.error_msg().empty());
}
@ -421,7 +415,7 @@ TEST_CASE("testing converter with quotes spacing and escaping") {
ss::converter<ss::trim<' '>> c;
auto tup = c.convert<std::string, std::string, double, char>(
R"( just , some , 12.3 ,a )");
buff(R"( just , some , 12.3 ,a )"));
REQUIRE(c.valid());
CHECK(tup == std::make_tuple("just", "some", 12.3, 'a'));
}

6
test/test_parser.cpp
View File

@ -541,9 +541,6 @@ TEST_CASE("testing csv on multiple lines with quotes") {
while (!p.eof()) {
auto a = p.get_next<int, double, std::string>();
auto [x, y, z] = a;
std::cout << "=====================" << std::endl;
std::cout << x << ' ' << y << ' ' << z << std::endl;
i.emplace_back(ss::to_object<X>(a));
}
@ -575,9 +572,6 @@ TEST_CASE("testing csv on multiple lines with escapes") {
while (!p.eof()) {
auto a = p.get_next<int, double, std::string>();
auto [x, y, z] = a;
std::cout << "=====================" << std::endl;
std::cout << x << ' ' << y << ' ' << z << std::endl;
i.emplace_back(ss::to_object<X>(a));
}

2
test/test_splitter.cpp
View File

@ -4,8 +4,6 @@
#include <iostream>
#include <ss/splitter.hpp>
// TODO make ss::quote accept only one argument
namespace {
constexpr static auto combinations_size_default = 4;
size_t combinations_size = combinations_size_default;