Converted external read-file function output into a node set

* A call to _read-file_ now returns a _content_ and _status_ node
** this enables XSL transformations to easily react to io related errors
* fixed bug in path resolution
** boost::filesystem _canonical_ method is throwing and exception when the given path does not exist, this pulled down the whole stack
** replaced call to _canonical_ with call to _absolute_ which does not have this requirement

3 files changed, 80 insertions, 13 deletions

diff --git a/src/function/read_file.cc b/src/function/read_file.cc
index ac6225a..6f02702 100644
--- a/src/function/read_file.cc
+++ b/src/function/read_file.cc
@@ -1,13 +1,23 @@
 #include "read_file.h"
 
+#include <xercesc/dom/DOMDocument.hpp>
+#include <xercesc/dom/DOMImplementation.hpp>
+#include <xercesc/dom/DOMElement.hpp>
+#include <xercesc/dom/DOMText.hpp>
+#include <xercesc/util/XMLString.hpp>
+
 #include "boost/filesystem/fstream.hpp"
 
 #include <fstream>
 
+#include "support/xerces_string_guard.h"
+#include "support/utility.h"
+
 namespace InputXSLT {
 
 FunctionReadFile::FunctionReadFile(const FilesystemContext& context):
-	fs_context_(context) { }
+	fs_context_(context),
+	document_cache_(std::make_shared<DomDocumentCache>()) { }
 
 xalan::XObjectPtr FunctionReadFile::execute(
 	xalan::XPathExecutionContext& executionContext,
@@ -19,22 +29,77 @@ xalan::XObjectPtr FunctionReadFile::execute(
 		this->fs_context_.resolve(argument->str())
 	);
 
-	if ( boost::filesystem::is_regular_file(filePath) ) {
-		boost::filesystem::ifstream file(filePath);
+	DomDocumentCache::item* const cachedDocument(
+		this->document_cache_->get(xalanToString(argument->str()))
+	);
 
-		const std::string fileContent(
-			(std::istreambuf_iterator<char>(file)),
-			(std::istreambuf_iterator<char>())
+	if ( !cachedDocument->isFinalized() ) {
+		xercesc::DOMDocument* const domDocument(
+			cachedDocument->getXercesDocument()
 		);
 
-		return executionContext.getXObjectFactory().createString(
-			xalan::XalanDOMString(fileContent.data())
-		);
-	} else {
-		return executionContext.getXObjectFactory().createString(
-			xalan::XalanDOMString("io error")
+		xercesc::DOMNode* const rootNode(
+			domDocument->getDocumentElement()
 		);
+
+		if ( boost::filesystem::is_regular_file(filePath) ) {
+			boost::filesystem::ifstream file(filePath);
+
+			const std::string fileContent(
+				(std::istreambuf_iterator<char>(file)),
+				(std::istreambuf_iterator<char>())
+			);
+
+			xercesc::DOMElement* const contentNode(
+				domDocument->createElement(*XercesStringGuard("content"))
+			);
+
+			xercesc::DOMText* const contentTextNode(
+				domDocument->createTextNode(
+					*XercesStringGuard(fileContent)
+				)
+			);
+
+			xercesc::DOMElement* const resultNode(
+				domDocument->createElement(*XercesStringGuard("status"))
+			);
+
+			xercesc::DOMText* const resultTextNode(
+				domDocument->createTextNode(
+					*XercesStringGuard("successful")
+				)
+			);
+
+			contentNode->appendChild(contentTextNode);
+			resultNode->appendChild(resultTextNode);
+
+			rootNode->appendChild(contentNode);
+			rootNode->appendChild(resultNode);
+		} else {
+			xercesc::DOMElement* const resultNode(
+				domDocument->createElement(*XercesStringGuard("status"))
+			);
+
+			xercesc::DOMText* const resultTextNode(
+				domDocument->createTextNode(
+					*XercesStringGuard("error")
+				)
+			);
+
+			resultNode->appendChild(resultTextNode);
+			rootNode->appendChild(resultNode);
+		}
 	}
+
+	xalan::XPathExecutionContext::BorrowReturnMutableNodeRefList nodeList(
+		executionContext
+	);
+
+	nodeList->addNodes(
+		*cachedDocument->getXalanDocument()->getDocumentElement()->getChildNodes()
+	);
+
+	return executionContext.getXObjectFactory().createNodeSet(nodeList);
 }
 
 FunctionReadFile* FunctionReadFile::clone(
diff --git a/src/function/read_file.h b/src/function/read_file.h
index 2d1dedf..6f38e95 100644
--- a/src/function/read_file.h
+++ b/src/function/read_file.h
@@ -10,6 +10,7 @@
 
 #include "common.h"
 #include "support/filesystem_context.h"
+#include "support/dom/document_cache.h"
 
 namespace InputXSLT {
 
@@ -31,6 +32,7 @@ class FunctionReadFile : public xalan::Function {
 
 	private:
 		const FilesystemContext& fs_context_;
+		std::shared_ptr<DomDocumentCache> document_cache_;
 
 		const xalan::XalanDOMString& getError(xalan::XalanDOMString&) const;
 
diff --git a/src/support/filesystem_context.cc b/src/support/filesystem_context.cc
index 9ed9bbf..34b8950 100644
--- a/src/support/filesystem_context.cc
+++ b/src/support/filesystem_context.cc
@@ -9,7 +9,7 @@ FilesystemContext::FilesystemContext(const std::string& path):
 
 boost::filesystem::path FilesystemContext::resolve(
 	const std::string& path) const {
-	return canonical(this->path_ / path);
+	return absolute(this->path_ / path);
 }
 
 boost::filesystem::path FilesystemContext::resolve(