Rewrote error handling based on exceptions

* ErrorHandler is replaced by ErrorCapacitor
** temporarily registers itself as both the ProblemListener and ErrorHandler of a given XalanTransformer instance
** deregisters itself on destruction
** collects all problems and errors during its lifetime inside a internal std::vector<std::string> instance
** if this instance is not empty it is thrown contained within a ErrorCapacitor::exception by the member method ErrorCapacitor::discharge
* this enables using the same code for handling transformation compilation and generation errors and problems
* updated test frontend accordingly

2 files changed, 51 insertions, 37 deletions

diff --git a/src/support/error_handler.cc b/src/support/error_capacitor.cc
index 2ca721d..e83ba9a 100644
--- a/src/support/error_handler.cc
+++ b/src/support/error_capacitor.cc
@@ -1,4 +1,4 @@
-#include "error_handler.h"
+#include "error_capacitor.h"
 
 #include <xercesc/sax/SAXParseException.hpp>
 
@@ -19,50 +19,57 @@ inline std::string getMessage(const xercesc::SAXParseException& exception) {
 
 namespace InputXSLT {
 
-ErrorHandler::ErrorHandler():
-	error_cache_{} { }
+ErrorCapacitor::ErrorCapacitor(xalan::XalanTransformer* transformer):
+	transformer_(transformer),
+	error_cache_(new error_cache()) {
+	this->transformer_->setErrorHandler(this);
+	this->transformer_->setProblemListener(this);
+}
+
+ErrorCapacitor::~ErrorCapacitor() {
+	this->transformer_->setErrorHandler(nullptr);
+	this->transformer_->setProblemListener(nullptr);
+}
 
-void ErrorHandler::warning(const xercesc::SAXParseException& exception) {
-	this->constructErrorCache();
+void ErrorCapacitor::discharge() {
+	if ( !this->error_cache_->empty() ) {
+		throw exception(std::move(this->error_cache_));
+	}
+}
 
+void ErrorCapacitor::warning(const xercesc::SAXParseException& exception) {
 	this->error_cache_->emplace_back(
 		"Warning: " + getMessage(exception)
 	);
 }
 
-void ErrorHandler::error(const xercesc::SAXParseException& exception) {
-	this->constructErrorCache();
-
+void ErrorCapacitor::error(const xercesc::SAXParseException& exception) {
 	this->error_cache_->emplace_back(
 		"Error: " + getMessage(exception)
 	);
 }
 
-void ErrorHandler::fatalError(const xercesc::SAXParseException& exception) {
-	this->constructErrorCache();
-
+void ErrorCapacitor::fatalError(const xercesc::SAXParseException& exception) {
 	this->error_cache_->emplace_back(
 		"Fatal error: " + getMessage(exception)
 	);
 }
 
-void ErrorHandler::resetErrors() { }
+void ErrorCapacitor::resetErrors() { }
 
-void ErrorHandler::problem(
+void ErrorCapacitor::problem(
 	xalan::ProblemListenerBase::eSource,
 	xalan::ProblemListenerBase::eClassification,
 	const xalan::XalanDOMString& message,
 	const xalan::Locator*,
 	const xalan::XalanNode*
 ) {
-	this->constructErrorCache();
-
 	this->error_cache_->emplace_back(
 		"XSLT problem: " + toString(message)
 	);
 }
 
-void ErrorHandler::problem(
+void ErrorCapacitor::problem(
 	xalan::ProblemListenerBase::eSource,
 	xalan::ProblemListenerBase::eClassification,
 	const xalan::XalanNode*,
@@ -72,36 +79,29 @@ void ErrorHandler::problem(
 	xalan::XalanFileLoc,
 	xalan::XalanFileLoc
 ) {
-	this->constructErrorCache();
-
 	this->error_cache_->emplace_back(
 		"XSLT problem: " + toString(message)
 	);
 }
 
-void ErrorHandler::problem(
+void ErrorCapacitor::problem(
 	xalan::ProblemListenerBase::eSource,
 	xalan::ProblemListenerBase::eClassification,
 	const xalan::XalanDOMString& message,
 	const xalan::XalanNode*
 ) {
-	this->constructErrorCache();
-
 	this->error_cache_->emplace_back(
 		"XSLT problem: " + toString(message)
 	);
 }
 
-void ErrorHandler::setPrintWriter(xalan::PrintWriter*) { }
+void ErrorCapacitor::setPrintWriter(xalan::PrintWriter*) { }
 
-auto ErrorHandler::getCachedErrors() -> error_cache_ptr {
-	return error_cache_ptr(this->error_cache_.release());
-}
+ErrorCapacitor::exception::exception(error_cache_ptr ptr):
+	error_cache_(std::move(ptr)) { }
 
-void ErrorHandler::constructErrorCache() {
-	if ( !this->error_cache_ ) {
-		this->error_cache_.reset(new error_cache());
-	}
+auto ErrorCapacitor::exception::getCachedErrors() const -> const error_cache* {
+	return this->error_cache_.get();
 }
 
 }
diff --git a/src/support/error_handler.h b/src/support/error_capacitor.h
index 02d741e..d89b5ae 100644
--- a/src/support/error_handler.h
+++ b/src/support/error_capacitor.h
@@ -1,8 +1,9 @@
-#ifndef INPUTXSLT_SRC_SUPPORT_ERROR_HANDLER_H_
-#define INPUTXSLT_SRC_SUPPORT_ERROR_HANDLER_H_
+#ifndef INPUTXSLT_SRC_SUPPORT_ERROR_CAPACITOR_H_
+#define INPUTXSLT_SRC_SUPPORT_ERROR_CAPACITOR_H_
 
 #include <xercesc/sax/ErrorHandler.hpp>
 #include <xalanc/XSLT/ProblemListener.hpp>
+#include <xalanc/XalanTransformer/XalanTransformer.hpp>
 
 #include <memory>
 #include <vector>
@@ -12,13 +13,18 @@
 
 namespace InputXSLT {
 
-class ErrorHandler : public xercesc::ErrorHandler,
+class ErrorCapacitor : public xercesc::ErrorHandler,
                      public xalan::ProblemListener {
 	public:
+		class exception;
+
 		typedef std::vector<std::string> error_cache;
 		typedef std::unique_ptr<error_cache> error_cache_ptr;
 
-		ErrorHandler();
+		ErrorCapacitor(xalan::XalanTransformer*);
+		~ErrorCapacitor();
+
+		void discharge();
 
 		virtual void warning(const xercesc::SAXParseException&);
 		virtual void error(const xercesc::SAXParseException&);
@@ -53,15 +59,23 @@ class ErrorHandler : public xercesc::ErrorHandler,
 
 		virtual void setPrintWriter(xalan::PrintWriter*);
 
-		error_cache_ptr getCachedErrors();
-
 	private:
+		xalan::XalanTransformer* const transformer_;
 		error_cache_ptr error_cache_;
 
-		void constructErrorCache();
+};
+
+class ErrorCapacitor::exception {
+	public:
+		exception(error_cache_ptr);
+
+		const error_cache* getCachedErrors() const;
+
+	private:
+		error_cache_ptr error_cache_;
 
 };
 
 }
 
-#endif  // INPUTXSLT_SRC_SUPPORT_ERROR_HANDLER_H_
+#endif  // INPUTXSLT_SRC_SUPPORT_ERROR_CAPACITOR_H_