6 files changed, 107 insertions, 41 deletions

diff --git a/src/support/error/error_capacitor.cc b/src/support/error/error_capacitor.cc
index 58cfb81..cc7dd01 100644
--- a/src/support/error/error_capacitor.cc
+++ b/src/support/error/error_capacitor.cc
@@ -3,14 +3,8 @@
 namespace InputXSLT {
 
 ErrorCapacitor::ErrorCapacitor(ErrorMultiplexer* multiplexer):
-	multiplexer_(multiplexer),
-	error_cache_(new error_cache()) {
-	this->multiplexer_->connectReceiver(this);
-}
-
-ErrorCapacitor::~ErrorCapacitor() {
-	this->multiplexer_->disconnectReceiver(this);
-}
+	ErrorMultiplexer::receiver(multiplexer),
+	error_cache_(new error_cache()) { }
 
 void ErrorCapacitor::discharge() {
 	if ( !this->error_cache_->empty() ) {
@@ -19,10 +13,10 @@ void ErrorCapacitor::discharge() {
 }
 
 void ErrorCapacitor::receive(
-	const ErrorMultiplexer::ErrorType type,
+	const ErrorMultiplexer::error_type type,
 	const std::string& message
 ) {
-	if ( type == ErrorMultiplexer::ErrorType::Error ) {
+	if ( type == ErrorMultiplexer::error_type::error ) {
 		this->error_cache_->emplace_back(message);
 	}
 }
@@ -30,8 +24,8 @@ void ErrorCapacitor::receive(
 ErrorCapacitor::exception::exception(error_cache_ptr ptr):
 	error_cache_(std::move(ptr)) { }
 
-auto ErrorCapacitor::exception::getCachedErrors() const -> const error_cache* {
-	return this->error_cache_.get();
+auto ErrorCapacitor::exception::operator*() const -> const error_cache& {
+	return *(this->error_cache_.get());
 }
 
 }
diff --git a/src/support/error/error_capacitor.h b/src/support/error/error_capacitor.h
index 6017cb4..1c225e9 100644
--- a/src/support/error/error_capacitor.h
+++ b/src/support/error/error_capacitor.h
@@ -7,7 +7,7 @@
 
 namespace InputXSLT {
 
-class ErrorCapacitor : public ErrorMultiplexer::Receiver {
+class ErrorCapacitor : public ErrorMultiplexer::receiver {
 	public:
 		class exception;
 
@@ -15,17 +15,15 @@ class ErrorCapacitor : public ErrorMultiplexer::Receiver {
 		typedef std::unique_ptr<error_cache> error_cache_ptr;
 
 		ErrorCapacitor(ErrorMultiplexer*);
-		~ErrorCapacitor();
 
 		void discharge();
 
 		virtual void receive(
-			const ErrorMultiplexer::ErrorType,
+			const ErrorMultiplexer::error_type,
 			const std::string&
 		);
 
 	private:
-		ErrorMultiplexer* const multiplexer_;
 		error_cache_ptr error_cache_;
 
 };
@@ -34,7 +32,7 @@ class ErrorCapacitor::exception {
 	public:
 		exception(error_cache_ptr);
 
-		const error_cache* getCachedErrors() const;
+		const error_cache& operator*() const;
 
 	private:
 		error_cache_ptr error_cache_;
diff --git a/src/support/error/error_multiplexer.cc b/src/support/error/error_multiplexer.cc
index f5d4e0f..bbf0e71 100644
--- a/src/support/error/error_multiplexer.cc
+++ b/src/support/error/error_multiplexer.cc
@@ -27,15 +27,15 @@ inline std::string getMessage(const xercesc::SAXParseException& exception) {
 	);
 }
 
-inline ErrorMultiplexer::ErrorType toErrorType(
+inline ErrorMultiplexer::error_type toErrorType(
 	const xalan::ProblemListenerBase::eClassification classification) {
 	switch ( classification ) {
 		case xalan::ProblemListenerBase::eClassification::eMessage ||
 		     xalan::ProblemListenerBase::eClassification::eWarning: {
-			return ErrorMultiplexer::ErrorType::Warning;
+			return ErrorMultiplexer::error_type::warning;
 		}
 		default: {
-			return ErrorMultiplexer::ErrorType::Error;
+			return ErrorMultiplexer::error_type::error;
 		}
 	}
 }
@@ -56,11 +56,11 @@ ErrorMultiplexer::~ErrorMultiplexer() {
 	this->transformer_->setProblemListener(nullptr);
 }
 
-void ErrorMultiplexer::connectReceiver(Receiver* receiver) {
+void ErrorMultiplexer::connectReceiver(receiver* receiver) {
 	this->receivers_.push_back(receiver);
 }
 
-void ErrorMultiplexer::disconnectReceiver(Receiver* receiver) {
+void ErrorMultiplexer::disconnectReceiver(receiver* receiver) {
 	this->receivers_.erase(
 		std::remove(
 			this->receivers_.begin(),
@@ -72,21 +72,21 @@ void ErrorMultiplexer::disconnectReceiver(Receiver* receiver) {
 
 void ErrorMultiplexer::warning(const xercesc::SAXParseException& exception) {
 	this->multiplex(
-		ErrorType::Warning,
+		error_type::warning,
 		"Warning: " + getMessage(exception)
 	);
 }
 
 void ErrorMultiplexer::error(const xercesc::SAXParseException& exception) {
 	this->multiplex(
-		ErrorType::Error,
+		error_type::error,
 		"Error: " + getMessage(exception)
 	);
 }
 
 void ErrorMultiplexer::fatalError(const xercesc::SAXParseException& exception) {
 	this->multiplex(
-		ErrorType::Error,
+		error_type::error,
 		"Fatal error: " + getMessage(exception)
 	);
 }
@@ -155,16 +155,25 @@ void ErrorMultiplexer::problem(
 void ErrorMultiplexer::setPrintWriter(xalan::PrintWriter*) { }
 
 void ErrorMultiplexer::multiplex(
-	const ErrorType type,
+	const error_type type,
 	const std::string& message
 ) {
 	std::for_each(
 		this->receivers_.begin(),
 		this->receivers_.end(),
-		[&type, &message](Receiver* const receiver) -> void {
+		[&type, &message](receiver* const receiver) -> void {
 			receiver->receive(type, message);
 		}
 	);
 }
 
+ErrorMultiplexer::receiver::receiver(ErrorMultiplexer* multiplexer):
+	multiplexer_(multiplexer) {
+	this->multiplexer_->connectReceiver(this);
+}
+
+ErrorMultiplexer::receiver::~receiver() {
+	this->multiplexer_->disconnectReceiver(this);
+}
+
 }
diff --git a/src/support/error/error_multiplexer.h b/src/support/error/error_multiplexer.h
index 02cfaf8..7d8544a 100644
--- a/src/support/error/error_multiplexer.h
+++ b/src/support/error/error_multiplexer.h
@@ -16,14 +16,14 @@ namespace InputXSLT {
 class ErrorMultiplexer : public xercesc::ErrorHandler,
                          public xalan::ProblemListener {
 	public:
-		enum class ErrorType;
-		struct Receiver;
+		enum class error_type;
+		class receiver;
 
 		ErrorMultiplexer(xalan::XalanTransformer*);
 		~ErrorMultiplexer();
 
-		void connectReceiver(Receiver*);
-		void disconnectReceiver(Receiver*);
+		void connectReceiver(receiver*);
+		void disconnectReceiver(receiver*);
 
 		virtual void warning(const xercesc::SAXParseException&);
 		virtual void error(const xercesc::SAXParseException&);
@@ -61,22 +61,30 @@ class ErrorMultiplexer : public xercesc::ErrorHandler,
 	private:
 		xalan::XalanTransformer* const transformer_;
 
-		std::vector<Receiver*> receivers_;
+		std::vector<receiver*> receivers_;
 
-		void multiplex(const ErrorType, const std::string&);
+		void multiplex(const error_type, const std::string&);
 
 };
 
-enum class ErrorMultiplexer::ErrorType {
-	Warning,
-	Error
+enum class ErrorMultiplexer::error_type {
+	warning,
+	error
 };
 
-struct ErrorMultiplexer::Receiver {
-	virtual void receive(
-		const ErrorMultiplexer::ErrorType,
-		const std::string&
-	) = 0;
+class ErrorMultiplexer::receiver {
+	public:
+		receiver(ErrorMultiplexer*);
+		virtual ~receiver();
+
+		virtual void receive(
+			const ErrorMultiplexer::error_type,
+			const std::string&
+		) = 0;
+
+	private:
+		ErrorMultiplexer* const multiplexer_;
+
 };
 
 }
diff --git a/src/support/error/warning_capacitor.cc b/src/support/error/warning_capacitor.cc
new file mode 100644
index 0000000..f8d2b99
--- /dev/null
+++ b/src/support/error/warning_capacitor.cc
@@ -0,0 +1,26 @@
+#include "warning_capacitor.h"
+
+namespace InputXSLT {
+
+WarningCapacitor::WarningCapacitor(ErrorMultiplexer* multiplexer):
+	ErrorMultiplexer::receiver(multiplexer),
+	warning_cache_(new warning_cache()) { }
+
+auto WarningCapacitor::discharge() -> warning_cache_ptr {
+	warning_cache_ptr tmp(std::move(this->warning_cache_));
+
+	this->warning_cache_.reset(new warning_cache());
+
+	return std::move(tmp);
+}
+
+void WarningCapacitor::receive(
+	const ErrorMultiplexer::error_type type,
+	const std::string& message
+) {
+	if ( type == ErrorMultiplexer::error_type::warning ) {
+		this->warning_cache_->emplace_back(message);
+	}
+}
+
+}
diff --git a/src/support/error/warning_capacitor.h b/src/support/error/warning_capacitor.h
new file mode 100644
index 0000000..6b7058b
--- /dev/null
+++ b/src/support/error/warning_capacitor.h
@@ -0,0 +1,31 @@
+#ifndef INPUTXSLT_SRC_SUPPORT_ERROR_WARNING_CAPACITOR_H_
+#define INPUTXSLT_SRC_SUPPORT_ERROR_WARNING_CAPACITOR_H_
+
+#include <memory>
+
+#include "error_multiplexer.h"
+
+namespace InputXSLT {
+
+class WarningCapacitor : public ErrorMultiplexer::receiver {
+	public:
+		typedef std::vector<std::string> warning_cache;
+		typedef std::unique_ptr<warning_cache> warning_cache_ptr;
+
+		WarningCapacitor(ErrorMultiplexer*);
+
+		warning_cache_ptr discharge();
+
+		virtual void receive(
+			const ErrorMultiplexer::error_type,
+			const std::string&
+		);
+
+	private:
+		warning_cache_ptr warning_cache_;
+
+};
+
+}
+
+#endif  // INPUTXSLT_SRC_SUPPORT_ERROR_WARNING_CAPACITOR_H_