mirror of
https://github.com/tristanpenman/valijson.git
synced 2024-12-12 18:20:27 +01:00
133 lines
3.6 KiB
C++
133 lines
3.6 KiB
C++
/**
|
|
* @file
|
|
*
|
|
* @brief Demonstrates iteration over an array and type check functions
|
|
*
|
|
*/
|
|
|
|
#include <exception>
|
|
#include <iostream>
|
|
|
|
// jsoncpp
|
|
#include <json/json.h>
|
|
#include <valijson/adapters/jsoncpp_adapter.hpp>
|
|
#include <valijson/utils/jsoncpp_utils.hpp>
|
|
|
|
// RapidJSON
|
|
#include <rapidjson/document.h>
|
|
#include <valijson/adapters/rapidjson_adapter.hpp>
|
|
#include <valijson/utils/rapidjson_utils.hpp>
|
|
|
|
using std::cerr;
|
|
using std::cout;
|
|
using std::endl;
|
|
using std::runtime_error;
|
|
|
|
// The first example uses RapidJson to load a JSON document. If the document
|
|
// contains an array, this function will print any array values that have a
|
|
// valid string representation.
|
|
void usingRapidJson(const char *filename);
|
|
|
|
// The second example uses JsonCpp to perform the same task, but unlike the
|
|
// RapidJson example, we see how to use strict type checks and exception
|
|
// handling.
|
|
void usingJsonCpp(const char *filename);
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
if (argc != 2) {
|
|
cerr << "Usage: " << endl;
|
|
cerr << " " << argv[0] << " <filename>" << endl;
|
|
return 1;
|
|
}
|
|
|
|
// Load the document using rapidjson
|
|
cout << "-- Iteration using RapidJSON --" << endl;
|
|
usingRapidJson(argv[1]);
|
|
cout << endl;
|
|
|
|
// Load the document using jsoncpp
|
|
cout << "-- Iteration using jsoncpp --" << endl;
|
|
usingJsonCpp(argv[1]);
|
|
cout << endl;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void usingRapidJson(const char *filename)
|
|
{
|
|
using valijson::adapters::RapidJsonAdapter;
|
|
|
|
rapidjson::Document document;
|
|
if (!valijson::utils::loadDocument(filename, document)) {
|
|
return;
|
|
}
|
|
|
|
RapidJsonAdapter adapter(document);
|
|
if (!adapter.isArray()) {
|
|
cout << "Not an array." << endl;
|
|
return;
|
|
}
|
|
|
|
cout << "Array values:" << endl;
|
|
int index = 0;
|
|
|
|
// We support the old way of doing things...
|
|
const RapidJsonAdapter::Array array = adapter.asArray();
|
|
for (RapidJsonAdapter::Array::const_iterator itr = array.begin();
|
|
itr != array.end(); ++itr) {
|
|
cout << " " << index++ << ": ";
|
|
|
|
// Each element of the array is just another RapidJsonAdapter
|
|
const RapidJsonAdapter &value = *itr;
|
|
|
|
// maybeString is a loose type check
|
|
if (value.maybeString()) {
|
|
// If a value may be a string, we are allowed to get a string
|
|
// representation of the value using asString
|
|
cout << value.asString();
|
|
}
|
|
|
|
cout << endl;
|
|
}
|
|
}
|
|
|
|
void usingJsonCpp(const char *filename)
|
|
{
|
|
Json::Value value;
|
|
if (!valijson::utils::loadDocument(filename, value)) {
|
|
return;
|
|
}
|
|
|
|
valijson::adapters::JsonCppAdapter adapter(value);
|
|
|
|
// isArray is a strict type check
|
|
if (!adapter.isArray()) {
|
|
cout << "Not an array." << endl;
|
|
return;
|
|
}
|
|
|
|
cout << "Array values:" << endl;
|
|
int index = 0;
|
|
|
|
// If a value is not an array, then calling getArray will cause a runtime
|
|
// exception to be raised.
|
|
for (auto value : adapter.getArray()) {
|
|
cout << " " << index++ << ": ";
|
|
|
|
// isString is another strict type check. Valijson uses the convention
|
|
// that strict type check functions are prefixed with 'is'.
|
|
if (!value.isString()) {
|
|
cout << "Not a string. ";
|
|
}
|
|
|
|
try {
|
|
// Also by convention, functions prefixed with 'get' will raise a
|
|
// runtime exception if the value is not of the correct type.
|
|
cout << value.getString() << endl;
|
|
} catch (runtime_error &e) {
|
|
cout << "Caught exception: " << e.what() << endl;
|
|
}
|
|
}
|
|
}
|