Machine readable progress with -q and --log-format json

src/ifcparse/IfcLogger.cpp

@@ -23,13 +23,47 @@
 #include <boost/algorithm/string/replace.hpp>
 #include <boost/optional.hpp>
 
+#include <boost/property_tree/ptree.hpp>
+#include <boost/property_tree/json_parser.hpp>
+#include <boost/version.hpp>
+
 #include <iostream>
 #include <algorithm>
 
+using boost::property_tree::ptree;
+
+namespace {
+	static const char* severity_strings[] = {"Notice", "Warning", "Error"};
+
+	void plain_text_message(std::ostream& os, const boost::optional<IfcSchema::IfcProduct*>& current_product, Logger::Severity type, const std::string& message, IfcEntityInstanceData* entity) {
+		os << "[" << severity_strings[type] << "] ";
+		if (current_product) {
+			os << "{" << (*current_product)->GlobalId() << "} ";
+		}
+		os << message << std::endl;
+		if (entity) {
+			os << entity->toString() << std::endl;
+		}
+	}
+
+	void json_message(std::ostream& os, const boost::optional<IfcSchema::IfcProduct*>& current_product, Logger::Severity type, const std::string& message, IfcEntityInstanceData* entity) {
+		ptree pt;
+		pt.put("level", severity_strings[type]);
+		if (current_product) {
+			pt.put("product", (**current_product).entity->toString());
+		}
+		pt.put("message", message);
+		if (entity) {
+			pt.put("instance", entity);
+		}
+		boost::property_tree::write_json(os, pt, false);
+	}
+}
 
 void Logger::SetProduct(boost::optional<IfcSchema::IfcProduct*> product) {
 	current_product = product;
 }
+
 void Logger::SetOutput(std::ostream* l1, std::ostream* l2) { 
 	log1 = l1; 
 	log2 = l2; 
@@ -39,13 +73,12 @@ void Logger::SetOutput(std::ostream* l1, std::ostream* l2) {
 }
 
 void Logger::Message(Logger::Severity type, const std::string& message, IfcEntityInstanceData* entity) {
-	if ( log2 && type >= verbosity ) {
-		(*log2) << "[" << severity_strings[type] << "] ";
-		if ( current_product ) {
-		    (*log2) << "{" << (*current_product)->GlobalId() << "} ";
+	if (log2 && type >= verbosity) {
+		if (format == FMT_PLAIN) {
+			plain_text_message(*log2, current_product, type, message, entity);
+		} else if (format == FMT_JSON) {
+			json_message(*log2, current_product, type, message, entity);
 		}
-		(*log2) << message << std::endl;
-		if ( entity ) (*log2) << entity->toString() << std::endl;
 	}
 }
 
@@ -54,26 +87,32 @@ void Logger::Message(Logger::Severity type, const std::exception& exception, Ifc
 }
 
 void Logger::Status(const std::string& message, bool new_line) {
-	if ( log1 ) {
+	if (log1) {
 		(*log1) << message;
 		if ( new_line ) (*log1) << std::endl;
 		else (*log1) << std::flush;
 	}
 }
+
 void Logger::ProgressBar(int progress) {
-	if ( log1 ) {
+	if (log1) {
 		Status("\r[" + std::string(progress,'#') + std::string(50 - progress,' ') + "]", false);
 	}
 }
+
 std::string Logger::GetLog() {
 	return log_stream.str();
 }
+
 void Logger::Verbosity(Logger::Severity v) { verbosity = v; }
 Logger::Severity Logger::Verbosity() { return verbosity; }
 
+void Logger::OutputFormat(Format f) { format = f; }
+Logger::Format Logger::OutputFormat() { return format; }
+
 std::ostream* Logger::log1 = 0;
 std::ostream* Logger::log2 = 0;
 std::stringstream Logger::log_stream;
 Logger::Severity Logger::verbosity = Logger::LOG_NOTICE;
-const char* Logger::severity_strings[] = { "Notice","Warning","Error" };
+Logger::Format Logger::format = Logger::FMT_PLAIN;
 boost::optional<IfcSchema::IfcProduct*> Logger::current_product;

src/ifcparse/IfcLogger.h

@@ -40,20 +40,26 @@
 class IFC_PARSE_API Logger {
 public:
 	typedef enum { LOG_NOTICE, LOG_WARNING, LOG_ERROR } Severity;
+	typedef enum { FMT_PLAIN, FMT_JSON } Format;
 private:
 	static std::ostream* log1;
 	static std::ostream* log2;
 	static std::stringstream log_stream;
 	static Severity verbosity;
-	static const char* severity_strings[];
+	static Format format;
 	static boost::optional<IfcSchema::IfcProduct*> current_product;
 public:
 	static void SetProduct(boost::optional<IfcSchema::IfcProduct*> product);
 	/// Determines to what stream respectively progress and errors are logged
 	static void SetOutput(std::ostream* l1, std::ostream* l2);
+
 	/// Determines the types of log messages to get logged
 	static void Verbosity(Severity v);
 	static Severity Verbosity();
+
+	/// Determines output format: plain text or sequence of JSON objects
+	static void OutputFormat(Format f);
+	static Format OutputFormat();
 	
 	/// Log a message to the output stream
 	static void Message(Severity type, const std::string& message, IfcEntityInstanceData* entity=0);