L’exemple suivant montre comment parser un fichier jsonlines en utilisant boost::json. Puisqu’un fichier jsonlines est juste une séquence de lignes, chacune avec un objet JSON, nous pouvons utiliser la fonction boost::json::parse pour parser chaque ligne sans aucune action spéciale.
Ce code peut parser un fichier jsonlines de 4,5 Go avec 4442720 lignes en 42 secondes sur mon Desktop i7-6700 (l’affichage de la sortie a été désactivé pour ce benchmark).
#include <iostream>
#include <fstream>
#include <string>
#include <boost/json.hpp>
class JSONLineProcessor {
public:
JSONLineProcessor(const std::string& filename) : file(filename) {
if (!file.is_open()) {
throw std::runtime_error("Error: Could not open file.");
}
}
void process_lines() {
std::string line;
while (std::getline(file, line)) {
process_line(line);
}
}
private:
std::ifstream file;
void process_line(const std::string& line) {
try {
// Parse the JSON line
boost::json::value json_value = boost::json::parse(line);
// Check if it's a JSON object
if (json_value.is_object()) {
process_json(json_value.as_object());
} else {
std::cerr << "Error: Parsed value is not a JSON object." << std::endl;
}
} catch (const boost::json::system_error& e) {
// Handle parsing errors
std::cerr << "Error parsing JSON line: " << e.what() << std::endl;
}
}
void process_json(const boost::json::object& obj) {
// For the sake of example, just print the JSON object
std::cout << "Processing JSON object: " << boost::json::serialize(obj) << std::endl;
}
};
int main(int argc, char** argv) {
if(argc <= 1) {
std::cerr << "Usage: " << argv[0] << std::endl;
return 1;
}
try {
JSONLineProcessor processor(argv[1]);
processor.process_lines();
} catch (const std::exception& e) {
std::cerr << e.what() << std::endl;
return 1;
}
return 0;
}Compilez comme ceci :
g++ -std=c++17 -march=native -O3 -o jsonlines_parser jsonlines_parser.cpp -lboost_json-march=native et -O3 sont optionnels, mais ils peuvent accélérer le processus de parsing. Notez que -march=native rendra le binaire non portable puisqu’il est compilé pour s’exécuter sur des processeurs avec la même architecture que celui sur lequel vous compilez. Voir la documentation -march pour plus d’informations.