Help with creatng a templated function to accept JSON arrays?

[DylanPerez04]

I'm currently trying to create a function within a namespace that allows me to convert a passed in nlohmann/json.hpp object that is an array to a C++ array of typename T.

Here is what I have done so far in my own JsonConvertible.cpp:

`
#include "nlohmann/json.hpp"
#include <"iostream">

using json = nlohmann::json;

// namespace JsonConvertible
namespace jc {

template <typename T, typename std::enable_if<std::is_base_of<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::string, bool, int64_t,
    uint64_t, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<uint8_t, std::allocator<uint8_t>>, void>, T>::value>::type* = nullptr>
static T* jsonToArray(json& j) {
    T* arr = nullptr;
    if (j.is_array()) {
        arr = new T;
        for (json::iterator i = j.begin(); i != j.end(); i++) {
            std::cout << *i << std::endl;
        }
        return arr;
    }

    return nullptr;
}

};
`

When I attempt to use the namespace in my main.cpp, I get an error "no instance of function template "jc::jsonToArray" matches the argument list..." then gives me a list of everything in nlohmann::json_abi_v3_all_3::basic_json.

Here is some sample code:

`#include <"iostream">
#include <"fstream">
#include "JsonConvertible.cpp"
#include "nlohmann/json.hpp"
using json = nlohmann::json;

int main() {

json fileData = {
    {"numbers", {1, 2, 3, 4} }
};


jc::jsonToArray(fileData["numbers"]);

return 0;

}`

I will admit my understanding of templates is pretty basic. I'm just trying to use this library with a simple program of mine, and I've just been spending some time on what I can do with it.

Any help would be greatly appreciated!

[gregmarr]

Your major problem is that you aren't doing anything to specify the type of the array you're reading in jsonToArray. Since you are not taking in any parameters that have anything to do with the type T, you need to specify it as in jc::jsonToArray<int>(....

You have a variety of other errors that may just be that you haven't finished filling things in, such as allocating a single element of type T rather than an array of T, you aren't filling in the array, and you aren't doing anything with the returned array.

Some of those are fixed here:
https://www.godbolt.org/z/9d3qPTbWW

[DylanPerez04]

Your major problem is that you aren't doing anything to specify the type of the array you're reading in jsonToArray. Since you are not taking in any parameters that have anything to do with the type T, you need to specify it as in jc::jsonToArray<int>(....

You have a variety of other errors that may just be that you haven't finished filling things in, such as allocating a single element of type T rather than an array of T, you aren't filling in the array, and you aren't doing anything with the returned array.

Some of those are fixed here: https://www.godbolt.org/z/9d3qPTbWW

Thank you! Yes the solution was quite literally just explicitly defining the type like you mentioned in the first half. I'm more familiar with Java Generics, so I naively assumed that my C++ compiler automatically type-checked the method return.

Here is my working code:

#include "nlohmann/json.hpp"
#include <iostream>
using json = nlohmann::json;

// namespace JsonConvertible
namespace jc {

    template <typename T> T* jsonToArray(json& j) {
        T* arr;
        if (j.is_array()) {
            arr = new T[j.size()];
            int index = 0;
            for (json::iterator i = j.begin(); i != j.end(); i++) {
                std::cout << "reading... " << i.value() << std::endl;
                *(arr + index++) = i.value();
            }
            return arr;
        }

        return nullptr;
    }

};

#include <iostream>
#include "JsonConvertible.cpp"
#include "nlohmann/json.hpp"
using json = nlohmann::json;

int main() {
    json fileData = {
        {"numbers", {1, 2, 3, 4}}
    };
    size_t size = fileData["numbers"].size();
    int* nums = jc::jsonToArray<int>(fileData["numbers"]);
    for (size_t i = 0; i < size; i++) {
        std::cout << nums[i] << " ";
    } std::cout << std::endl;

    return 0;
}