Replaced FunctionTransform by making the target of FunctionGenerate optional

* if the target parameter is not provided FunctionGenerate now performs exactly the same functionality as FunctionTransform
* added "boost::optional<boost::filesystem::path>" specialization to the XObjectValue class
* modified test cases accordingly
* modified README.md accordingly

6 files changed, 58 insertions, 125 deletions

diff --git a/src/function/generate.cc b/src/function/generate.cc
index f9cd449..b93c2f1 100644
--- a/src/function/generate.cc
+++ b/src/function/generate.cc
@@ -2,6 +2,7 @@
 
 #include <xalanc/PlatformSupport/XalanOutputStreamPrintWriter.hpp>
 #include <xalanc/PlatformSupport/XalanStdOutputStream.hpp>
+#include <xalanc/XercesParserLiaison/FormatterToXercesDOM.hpp>
 #include <xalanc/XMLSupport/FormatterToXML.hpp>
 
 #include <boost/filesystem.hpp>
@@ -16,53 +17,69 @@ namespace InputXSLT {
 
 DomDocumentCache::document_ptr FunctionGenerate::constructDocument(
 	const FilesystemContext&,
-	xalan::XSLTInputSource   inputSource,
-	xalan::XSLTInputSource   transformationSource,
-	boost::filesystem::path  targetPath
+	xalan::XSLTInputSource                   inputSource,
+	xalan::XSLTInputSource                   transformationSource,
+	boost::optional<boost::filesystem::path> targetPath
 ) const {
 	DomDocumentCache::document_ptr domDocument(
 		DomDocumentCache::createDocument("content")
 	);
 
-	ResultNodeFacade result(domDocument.get(), "generation");
-	result.setAttribute("path", targetPath.string());
+	ResultNodeFacade  result(domDocument.get(), "generation");
+	TransformerFacade transformer(this->include_resolver_);
 
-	boost::filesystem::create_directories(targetPath.parent_path());
-	boost::filesystem::ofstream file(targetPath);
+	try {
+		if ( targetPath ) {
+			result.setAttribute("path", (*targetPath).string());
 
-	if ( file.is_open() ) {
-		TransformerFacade transformer(this->include_resolver_);
+			boost::filesystem::create_directories(
+				(*targetPath).parent_path()
+			);
+
+			boost::filesystem::ofstream file(*targetPath);
 
-		try {
-			xalan::XalanStdOutputStream         output(file);
-			xalan::XalanOutputStreamPrintWriter writer(output);
-			xalan::FormatterToXML               targetFormatter(writer);
+			if ( file.is_open() ) {
+				xalan::XalanStdOutputStream         output(file);
+				xalan::XalanOutputStreamPrintWriter writer(output);
+				xalan::FormatterToXML               targetFormatter(writer);
+
+				transformer.generate(
+					inputSource,
+					transformationSource,
+					targetFormatter
+				);
+			} else {
+				result.setAttribute("result", "error");
+			}
+		} else {
+			xalan::FormatterToXercesDOM targetFormatter(
+				domDocument.get(),
+				result.getResultElement()
+			);
 
 			transformer.generate(
 				inputSource,
 				transformationSource,
 				targetFormatter
 			);
-
-			result.setAttribute("result", "success");
 		}
-		catch (const ErrorCapacitor::exception& exception) {
-			result.setAttribute("result", "error");
 
-			for ( auto&& error : *exception ) {
-				result.setValueNode("error", error);
-			}
+		result.setAttribute("result", "success");
+	}
+	catch (const ErrorCapacitor::exception& exception) {
+		result.setAttribute("result", "error");
+
+		for ( auto&& error : *exception ) {
+			result.setValueNode("error", error);
 		}
+	}
 
-		WarningCapacitor::warning_cache_ptr warnings(
-			transformer.getCachedWarnings()
-		);
+	WarningCapacitor::warning_cache_ptr warnings(
+		transformer.getCachedWarnings()
+	);
 
-		for ( auto&& warning : *warnings ) {
-			result.setValueNode("warning", warning);
-		}
-	} else {
-		result.setAttribute("result", "error");
+	for ( auto&& warning : *warnings ) {
+		result.setValueNode("warning", warning);
 	}
 
 	return domDocument;
diff --git a/src/function/generate.h b/src/function/generate.h
index 333ed37..fa38e3f 100644
--- a/src/function/generate.h
+++ b/src/function/generate.h
@@ -11,7 +11,7 @@ class FunctionGenerate : public FunctionBase<
 	FunctionGenerate,
 	xalan::XSLTInputSource,
 	xalan::XSLTInputSource,
-	boost::filesystem::path
+	boost::optional<boost::filesystem::path>
 > {
 	public:
 		using FunctionBase::FunctionBase;
@@ -23,7 +23,7 @@ class FunctionGenerate : public FunctionBase<
 			const FilesystemContext&,
 			xalan::XSLTInputSource,
 			xalan::XSLTInputSource,
-			boost::filesystem::path
+			boost::optional<boost::filesystem::path>
 		) const;
 
 };
diff --git a/src/function/transform.cc b/src/function/transform.cc
deleted file mode 100644
index 9bd2dae..0000000
--- a/src/function/transform.cc
+++ /dev/null
@@ -1,57 +0,0 @@
-#include "transform.h"
-
-#include <xalanc/XercesParserLiaison/FormatterToXercesDOM.hpp>
-
-#include "transformer_facade.h"
-#include "support/xerces_string_guard.h"
-#include "support/dom/result_node_facade.h"
-#include "support/error/error_capacitor.h"
-
-namespace InputXSLT {
-
-DomDocumentCache::document_ptr FunctionTransform::constructDocument(
-	const FilesystemContext&,
-	xalan::XSLTInputSource   inputSource,
-	xalan::XSLTInputSource   transformationSource
-) const {
-	DomDocumentCache::document_ptr domDocument(
-		DomDocumentCache::createDocument("content")
-	);
-
-	ResultNodeFacade result(domDocument.get(), "transformation");
-	TransformerFacade transformer(this->include_resolver_);
-
-	try {
-		xalan::FormatterToXercesDOM targetFormatter(
-			domDocument.get(),
-			result.getResultElement()
-		);
-
-		transformer.generate(
-			inputSource,
-			transformationSource,
-			targetFormatter
-		);
-
-		result.setAttribute("result", "success");
-	}
-	catch (const ErrorCapacitor::exception& exception) {
-		result.setAttribute("result", "error");
-
-		for ( auto&& error : *exception ) {
-			result.setValueNode("error", error);
-		}
-	}
-
-	WarningCapacitor::warning_cache_ptr warnings(
-		transformer.getCachedWarnings()
-	);
-
-	for ( auto&& warning : *warnings ) {
-		result.setValueNode("warning", warning);
-	}
-
-	return domDocument;
-}
-
-}
diff --git a/src/function/transform.h b/src/function/transform.h
deleted file mode 100644
index 6c8c05d..0000000
--- a/src/function/transform.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#ifndef INPUTXSLT_SRC_FUNCTION_TRANSFORM_H_
-#define INPUTXSLT_SRC_FUNCTION_TRANSFORM_H_
-
-#include <xalanc/XSLT/XSLTInputSource.hpp>
-
-#include "base.h"
-
-namespace InputXSLT {
-
-class FunctionTransform : public FunctionBase<
-	FunctionTransform,
-	xalan::XSLTInputSource,
-	xalan::XSLTInputSource
-> {
-	public:
-		using FunctionBase::FunctionBase;
-
-	protected:
-		friend FunctionBase;
-
-		DomDocumentCache::document_ptr constructDocument(
-			const FilesystemContext&,
-			xalan::XSLTInputSource,
-			xalan::XSLTInputSource
-		) const;
-
-};
-
-}
-
-#endif  // INPUTXSLT_SRC_FUNCTION_TRANSFORM_H_
diff --git a/src/platform_guard.cc b/src/platform_guard.cc
index f50d976..1449678 100644
--- a/src/platform_guard.cc
+++ b/src/platform_guard.cc
@@ -9,7 +9,6 @@
 #include "function/read_file.h"
 #include "function/write_file.h"
 #include "function/read_directory.h"
-#include "function/transform.h"
 #include "function/generate.h"
 #include "function/external_command.h"
 
@@ -44,12 +43,6 @@ PlatformGuard::PlatformGuard(const std::vector<std::string>& path):
 
 	xalan::XalanTransformer::installExternalFunctionGlobal(
 		customNamespace,
-		xalan::XalanDOMString("transform"),
-		InputXSLT::FunctionTransform(&this->include_resolver_)
-	);
-
-	xalan::XalanTransformer::installExternalFunctionGlobal(
-		customNamespace,
 		xalan::XalanDOMString("generate"),
 		InputXSLT::FunctionGenerate(&this->include_resolver_)
 	);
diff --git a/src/support/type/xobject_value.cc b/src/support/type/xobject_value.cc
index 2fe4f9f..959da94 100644
--- a/src/support/type/xobject_value.cc
+++ b/src/support/type/xobject_value.cc
@@ -52,6 +52,17 @@ boost::filesystem::path XObjectValue::get<boost::filesystem::path>(
 }
 
 template <>
+boost::optional<boost::filesystem::path>
+XObjectValue::get<boost::optional<boost::filesystem::path>>(
+	const xalan::XObjectPtr& ptr) const {
+	if ( ptr.null() ) {
+		return boost::optional<boost::filesystem::path>();
+	} else {
+		return this->get<boost::filesystem::path>(ptr);
+	}
+}
+
+template <>
 xalan::XObjectPtr XObjectValue::get<xalan::XObjectPtr>(
 	const xalan::XObjectPtr& ptr) const {
 	return ptr;