operator>> on a tied tuple with std::ignore - c++

Question

I have stumbled upon the following problem while designing a 'generic' reader:
The following Code works perfectly fine (you need c++1z support to compile as it uses constexpr if, but with minor modifications it should also compile with c++11):
#include <vector>
#include <string>
#include <type_traits>
#include <tuple>
#include <sstream>
using namespace std;
template<int N, class tuple_type>
struct fill_tuple {
static void write(std::vector<std::string>& container, tuple_type& tuple)
{
// use operator >> to fill the N-1'th member of the tuple
std::stringstream(container[N - 1]) >> std::get<N - 1>(tuple);
if constexpr(N > 1){ // Continue if there are till fields to read
fill_tuple<N - 1, tuple_type>::write(container, tuple);
}
}
};
template<class tuple_type>
void read (std::vector<std::string>& container, tuple_type obj){
fill_tuple<std::tuple_size<tuple_type>::value, tuple_type>::write(container, obj);
}
struct some_data {
char a;
char b;
char c;
char d;
auto content() {
return std::tie(a,b,c,d);
}
};
int main()
{
std::vector<std::string> some_strings = {"a","b","c","d"};
// Read some_strings into some_data
some_data foo;
read(some_strings, foo.content());
}
For the sake of simplicity, any bound checks (such as tuple_size <= container size) are omitted.
If i wanted to parse a struct that only has members a,b and d using a container with a size of 4, my intuition was to simply rewrite std::tie(a,b,c,d) to std::tie(a,b,std::ignore,d).
This, however, fails as std::ignore (or gcc's implementation) does not seem to have a operator>> function.
I have already tried checking against std::ignore using std::is_same: std::is_same<typename std::remove_reference<typename std::tuple_element<N - 1,tuple_type>::type>::type, std::ignore>::value, but this also fails.
My question is: Is there a way to check against std::ignore, or even better, replace it entirely without relying prior modifications to the container vector?

Answer 1

replace it entirely without relying prior modifications to the container vector?
instead of using is_same, you may just overload against decltype(ignore); in C++17:
template<typename T>
void read_element( std::string const& s, T& t ) { std::stringstream{s} >> t; }
void read_element( std::string const&, decltype(std::ignore) const& ) { /*do nothing*/ }
std::apply( [&](auto&... args)
{
auto it = some_vector_of_strings.begin();
( read_element( *it++, args ), ... );
}, tuple );
the same idea applies to your C++11 code as well.

Answer 2

As state in comment, std::ignore is not a type, but an object, you have to use decltype(std::ignore) to get the type.
template <typename T>
void read_simple(const std::string& s, T& obj)
{
std::stringstream(s) >> obj;
}
void read_simple(const std::string&, const decltype(std::ignore)&) {}
template <std::size_t ... Is, typename Tuple>
void read(const std::vector<std::string>& container,
Tuple&& obj,
std::index_sequence<Is...>)
{
(read_simple(container[Is], std::get<Is>(obj)), ...);
}
template <typename Tuple>
void read(const std::vector<std::string>& container, Tuple&& obj)
{
read(container,
obj,
std::make_index_sequence<std::tuple_size<std::decay_t<Tuple>>::value>());
}
Demo