I use the following methods to write objects in json format:
#include <array>
#include <vector>
#include <jsoncpp/json/json.h>
//// Write json SFINAE
template <typename T>
struct has_write_json_method {
template <typename U>
static constexpr decltype(std::declval<U>().write_json(), bool()) test(int) { return true; };
template <typename U>
static constexpr bool test(...) { return false; }
static constexpr bool value = test<T>(int());
};
template <class T>
typename std::enable_if<has_write_json_method<T>::value, Json::Value>::type write_json(const T& object) { return object.write_json(); };
template <class T>
typename std::enable_if<!has_write_json_method<T>::value, Json::Value>::type write_json(const T& object);
//// Write json vector
template <class T>
Json::Value write_json(const std::vector<T>& object_v) {
Json::Value output;
for (int i = 0; i < object_v.size(); ++i) { output[i] = write_json<T>(object_v.at(i)); };
return output;
};
//// Write json array
template <class T, std::size_t N>
Json::Value write_json(const std::array<T, N>& object_v) {
Json::Value output;
for (int i = 0; i < object_v.size(); ++i) { output[i] = write_json<T>(object_v.at(i)); };
return output;
};
//// Write json basic
template <class T>
Json::Value write_json_basic(const T& object) {
Json::Value output;
output = object;
return output;
};
template<>
Json::Value write_json<Json::Value>(const Json::Value& object) { return write_json_basic(object); };
template<>
Json::Value write_json<double>(const double& object) { return write_json_basic(object); };
However, when I try to write a std::array
of std::vector
:
std::array<std::vector<double>, 4> foo_av;
Json::Value output = write_json(foo_av);
It doesn't compile in C++11:
undefined reference to `std::enable_if<!has_write_json_method<std::vector<double, std::allocator<double> > >::value, Json::Value>::type write_json<std::vector<double, std::allocator<double> > >(std::vector<double, std::allocator<double> > const&)'
Update
A reproducible example using std::string instead of Json::value:
#include <array>
#include <vector>
#include <string>
//// Write string SFINAE
template <typename T>
struct has_write_string_method {
template <typename U>
static constexpr decltype(std::declval<U>().write_string(), bool()) test(int) { return true; };
template <typename U>
static constexpr bool test(...) { return false; }
static constexpr bool value = test<T>(int());
};
template <class T>
typename std::enable_if<has_write_string_method<T>::value, std::string>::type write_string(const T& object) { return object.write_string(); };
template <class T>
typename std::enable_if<!has_write_string_method<T>::value, std::string>::type write_string(const T& object);
//// Write string vector
template <class T>
std::string write_string(const std::vector<T>& object_v) {
std::string output;
for (int i = 0; i < object_v.size(); ++i) { output += write_string<T>(object_v.at(i)); };
return output;
};
//// Write string array
template <class T, std::size_t N>
std::string write_string(const std::array<T, N>& object_v) {
std::string output;
for (int i = 0; i < object_v.size(); ++i) { output += write_string<T>(object_v.at(i)); };
return output;
};
//// Write string basic
template <class T>
std::string write_string_basic(const T& object) {
std::string output;
output = object;
return output;
};
template<>
std::string write_string<double>(const double& object) { return write_string_basic(object); };
int main () {
std::array<std::vector<double>, 4> foo_av;
std::string output = write_string(foo_av);
return 0;
}
Compiling with Godbolt.org, it fails with x86-64 gcc 10.2:
/opt/compiler-explorer/gcc-10.2.0/bin/../lib/gcc/x86_64-linux-gnu/10.2.0/../../../../x86_64-linux-gnu/bin/ld: /tmp/ccAR3MdL.o: in function `std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > write_string<std::vector<double, std::allocator<double> >, 4ul>(std::array<std::vector<double, std::allocator<double> >, 4ul> const&)':
/home/ce/<source>:35: undefined reference to `std::enable_if<!has_write_string_method<std::vector<double, std::allocator<double> > >::value, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >::type write_string<std::vector<double, std::allocator<double> > >(std::vector<double, std::allocator<double> > const&)'
collect2: error: ld returned 1 exit status
This is because you send T
to the write string method, but the arguments you pass don't match T
:
for (int i = 0; i < object_v.size(); ++i) {
// here --------v
output += write_string<T>(object_v.at(i));
}
Here the T
you send is correctly std::vector<double>
, but there is no write_string<std::vector<double>>()
that takes a std::vector<double>
.
What you intended to was the compiler to choose this function:
template <class T>
std::string write_string(const std::vector<T>& object_v) {
// ...
};
But it does not match. You see, the T
here is the vector's template argument. So as a result, write_string<std::vector<T>>
receive a std::vector<std::vector<T>>
.
What can you do to fix the problem? The solution would be to let the compiler deduce the arguments, and not specialize function and overload instead:
for (int i = 0; i < object_v.size(); ++i) {
// no template args --v
output += write_string(object_v.at(i));
}