Issues with obtaining a callback with jsonObject from Poco JSON parser in items array

[toraviskumar]

I have implemented a JSON parser class derived from Poco::JSON::ParseHandler, and I am trying to obtain a d2cCallback for every JSON object in the items array, as well as a nextPageTokenCallback for the nextPageToken string. While the nextPageTokenCallback method is working as expected, I am unable to get the d2cCallback to work properly.

Below are the sample code:

#include <iostream>
#include <string>
#include <Poco/JSON/Parser.h>
#include <functional>

class MyParseHandler : public Poco::JSON::ParseHandler {
public:
     MyParseHandler(std::function<void(Poco::JSON::Object::Ptr&)> d2cCallback, std::function<void(const std::string&)> nextPageTokenCallback)
        : m_d2cCallback(d2cCallback), m_nextPageTokenCallback(nextPageTokenCallback) 
     {}
        
    void startObject()
	{
		Poco::JSON::ParseHandler::startObject();

		if (!_stack.empty())
		{
			const Poco::Dynamic::Var& var = _stack.top();
			if (Poco::JSON::Object::Ptr pObj = var.extract<Poco::JSON::Object::Ptr>())
			{
			    const Poco::JSON::Object& obj = *pObj;
	                    if (obj.has("items") && obj.get("items").isArray())
			    {
			        m_extractingObject = true;
			        Poco::JSON::Object::Ptr newObj = new Poco::JSON::Object;
			        _result = newObj;
			    }
			}
		}
	}

    virtual void key(const std::string& k) 
    {
        m_key = k;
    }

    virtual void value(const std::string& v) 
    {
		std::cout<<"value m_key = "<<m_key<<"--"<<v<<"--"<<std::endl;
		if (m_key == "nextPageToken" && m_nextPageTokenCallback) {
			m_nextPageTokenCallback(v);
	         }
    }

	void endObject()
	{
	  if (m_extractingObject)
	  {
		  Poco::JSON::ParseHandler::endObject();
		  if (!_stack.empty())
		  {

		      Poco::JSON::Object::Ptr extractedObject = _result.extract<Poco::JSON::Object::Ptr>();
		      std::ostringstream ss;
		      extractedObject->stringify(ss, 2);
		      std::string jsonString = ss.str();
	
		      m_d2cCallback(extractedObject);
		      _result.clear();

		      m_extractingObject = false;
		  }
	  }
}
     
private:
	bool m_extractingObject = false;
    std::string m_key;
    std::string m_value;
    std::function<void(Poco::JSON::Object::Ptr& )> m_d2cCallback;
    std::function<void(const std::string&)> m_nextPageTokenCallback;
};

void d2cCallback(Poco::JSON::Object::Ptr &obj) {
    std::cout << "d2cCallback " << std::endl;
}

void nextPageTokenCallback(const std::string& token) {
    std::cout << "nextPageTokenCallback Next page token: " << token << std::endl;
}

int main() {
    std::string jsonData = R"({
        "items": [
            {
                "key": "filename1.json",
                "size": 1100
            },
            {
                "key": "filename2.json",
                "size": 1145
            },
            {
                "key": "filename3.json",
                "size": 1146
            }
        ],
        "nextPageToken": "1000azdklj-afdad-adsfdsf-dsfdds"
    })";

    Poco::JSON::Parser parser;
    Poco::SharedPtr<MyParseHandler> handler = new MyParseHandler(d2cCallback, nextPageTokenCallback);


    try {
    	parser.setHandler(handler);
        parser.parse(jsonData);
    }
    catch (Poco::JSON::JSONException& e) {
        std::cerr << e.displayText() << std::endl;
    }

    return 0;
}

In my JSON data, the 'items' array contains two JSON objects. Therefore, I expect to receive 'd2cCallback' twice, each time with the JSON object data from the 'items' array.