Clang format and tidy

40 files changed, 1199 insertions, 1198 deletions

diff --git a/Jamroot.jam b/Jamroot.jam
index 7c80214..da57267 100644
--- a/Jamroot.jam
+++ b/Jamroot.jam
@@ -22,10 +22,17 @@ project
 			<toolset>tidy:<checkxx>bugprone-*
 			<toolset>tidy:<checkxx>clang-*
 			<toolset>tidy:<checkxx>misc-*
+			<toolset>tidy:<xcheckxx>misc-non-private-member-variables-in-classes
 			<toolset>tidy:<checkxx>modernize-*
 			<toolset>tidy:<xcheckxx>modernize-use-trailing-return-type
 			<toolset>tidy:<checkxx>hicpp-*
 			<toolset>tidy:<checkxx>performance-*
+			<toolset>tidy:<exclude>common/bin/http.h
+			<toolset>tidy:<exclude>common/bin/session.h
+			<toolset>tidy:<exclude>compile/bin/tidy/debug/cxxstd-17-iso/routes.h
+			<toolset>tidy:<exclude>core/bin/routeOptions.h
+			<toolset>tidy:<exclude>unittests/bin/test-api.h
+			<toolset>tidy:<exclude>unittests/bin/test-fcgi.h
 	;
 
 build-project icespider ;
diff --git a/icespider/common/formatters.h b/icespider/common/formatters.h
index e42717e..2b36b08 100644
--- a/icespider/common/formatters.h
+++ b/icespider/common/formatters.h
@@ -10,4 +10,3 @@ namespace IceSpider {
 }
 
 #endif
-
diff --git a/icespider/common/pathparts.cpp b/icespider/common/pathparts.cpp
index aabdd13..905e4d5 100644
--- a/icespider/common/pathparts.cpp
+++ b/icespider/common/pathparts.cpp
@@ -6,8 +6,7 @@ namespace ba = boost::algorithm;
 
 namespace IceSpider {
 	const auto slash = ba::first_finder("/", ba::is_equal());
-	Path::Path(const std::string_view & p) :
-		path(p)
+	Path::Path(const std::string_view & p) : path(p)
 	{
 		auto relp = p.substr(1);
 		if (relp.empty()) {
@@ -30,10 +29,7 @@ namespace IceSpider {
 		return parts.size();
 	}
 
-	PathLiteral::PathLiteral(const std::string_view & p) :
-		value(p)
-	{
-	}
+	PathLiteral::PathLiteral(const std::string_view & p) : value(p) { }
 
 	bool
 	PathLiteral::matches(const std::string_view & v) const
@@ -41,10 +37,7 @@ namespace IceSpider {
 		return value == v;
 	}
 
-	PathParameter::PathParameter(const std::string_view & s) :
-		name(s.substr(1, s.length() - 2))
-	{
-	}
+	PathParameter::PathParameter(const std::string_view & s) : name(s.substr(1, s.length() - 2)) { }
 
 	bool
 	PathParameter::matches(const std::string_view &) const
@@ -52,4 +45,3 @@ namespace IceSpider {
 		return true;
 	}
 }
-
diff --git a/icespider/common/pathparts.h b/icespider/common/pathparts.h
index 7626873..4aaf926 100644
--- a/icespider/common/pathparts.h
+++ b/icespider/common/pathparts.h
@@ -1,51 +1,53 @@
 #ifndef ICESPIDER_CORE_PATHS_H
 #define ICESPIDER_CORE_PATHS_H
 
-#include <vector>
-#include <string_view>
+#include <c++11Helpers.h>
 #include <memory>
+#include <string_view>
+#include <vector>
 #include <visibility.h>
 
 namespace IceSpider {
 	class DLL_PUBLIC PathPart {
-		public:
-			virtual ~PathPart() = default;
+	public:
+		PathPart() = default;
+		virtual ~PathPart() = default;
+		SPECIAL_MEMBERS_DEFAULT(PathPart);
 
-			virtual bool matches(const std::string_view &) const = 0;
+		[[nodiscard]] virtual bool matches(const std::string_view &) const = 0;
 	};
-	typedef std::unique_ptr<PathPart> PathPartPtr;
+	using PathPartPtr = std::unique_ptr<PathPart>;
 
 	class DLL_PUBLIC PathLiteral : public PathPart {
-		public:
-			PathLiteral(const std::string_view & v);
+	public:
+		explicit PathLiteral(const std::string_view & v);
 
-			bool matches(const std::string_view &) const;
+		[[nodiscard]] bool matches(const std::string_view &) const override;
 
-			const std::string_view value;
+		const std::string_view value;
 	};
 
 	class DLL_PUBLIC PathParameter : public PathPart {
-		public:
-			PathParameter(const std::string_view &);
+	public:
+		explicit PathParameter(const std::string_view &);
 
-			bool matches(const std::string_view &) const;
+		[[nodiscard]] bool matches(const std::string_view &) const override;
 
-			const std::string_view name;
+		const std::string_view name;
 	};
 
 	class DLL_PUBLIC Path {
-		public:
-			typedef std::vector<PathPartPtr> PathParts;
+	public:
+		using PathParts = std::vector<PathPartPtr>;
 
-			Path(const std::string_view &);
+		explicit Path(const std::string_view &);
 
-			const std::string_view path;
+		std::string_view path;
 
-			unsigned int pathElementCount() const;
+		[[nodiscard]] unsigned int pathElementCount() const;
 
-			PathParts parts;
+		PathParts parts;
 	};
 }
 
 #endif
-
diff --git a/icespider/compile/main.cpp b/icespider/compile/main.cpp
index a6bc226..804141b 100644
--- a/icespider/compile/main.cpp
+++ b/icespider/compile/main.cpp
@@ -1,5 +1,5 @@
-#include <boost/program_options.hpp>
 #include "routeCompiler.h"
+#include <boost/program_options.hpp>
 
 namespace po = boost::program_options;
 
@@ -10,12 +10,9 @@ main(int c, char ** v)
 	IceSpider::Compile::RouteCompiler rc;
 	std::filesystem::path input, output;
 	po::options_description opts("IceSpider compile options");
-	opts.add_options()
-		("input", po::value(&input), "Input .json file")
-		("output", po::value(&output), "Output .cpp file")
-		("include,I", po::value(&rc.searchPath)->composing(), "Search path")
-		("help,h", po::value(&showHelp)->default_value(false)->zero_tokens(), "Help")
-		;
+	opts.add_options()("input", po::value(&input), "Input .json file")("output", po::value(&output),
+			"Output .cpp file")("include,I", po::value(&rc.searchPath)->composing(), "Search path")(
+			"help,h", po::value(&showHelp)->default_value(false)->zero_tokens(), "Help");
 	po::positional_options_description pod;
 	pod.add("input", 1).add("output", 2);
 	po::variables_map vm;
@@ -34,4 +31,3 @@ main(int c, char ** v)
 
 	return 0;
 }
-
diff --git a/icespider/compile/routeCompiler.cpp b/icespider/compile/routeCompiler.cpp
index b94606c..8b357ba 100644
--- a/icespider/compile/routeCompiler.cpp
+++ b/icespider/compile/routeCompiler.cpp
@@ -1,16 +1,15 @@
 #include "routeCompiler.h"
-#include <pathparts.h>
-#include <slicer/slicer.h>
-#include <slicer/modelPartsTypes.h>
+#include <Slice/CPlusPlusUtil.h>
 #include <Slice/Preprocessor.h>
-#include <scopeExit.h>
-#include <fprintbf.h>
-#include <filesystem>
-#include <boost/algorithm/string/replace.hpp>
 #include <boost/algorithm/string/join.hpp>
-#include <Slice/CPlusPlusUtil.h>
+#include <boost/algorithm/string/replace.hpp>
 #include <compileTimeFormatter.h>
-
+#include <filesystem>
+#include <fprintbf.h>
+#include <pathparts.h>
+#include <scopeExit.h>
+#include <slicer/modelPartsTypes.h>
+#include <slicer/slicer.h>
 
 namespace IceSpider {
 	using namespace AdHoc::literals;
@@ -23,11 +22,13 @@ namespace IceSpider {
 		RouteConfigurationPtr
 		RouteCompiler::loadConfiguration(const std::filesystem::path & input) const
 		{
-			auto deserializer = Slicer::DeserializerPtr(Slicer::FileDeserializerFactory::createNew(input.extension().string(), input));
+			auto deserializer = Slicer::DeserializerPtr(
+					Slicer::FileDeserializerFactory::createNew(input.extension().string(), input));
 			return Slicer::DeserializeAnyWith<RouteConfigurationPtr>(deserializer);
 		}
 
-		Ice::StringSeq operator+(Ice::StringSeq ss, const std::string & s)
+		Ice::StringSeq
+		operator+(Ice::StringSeq ss, const std::string & s)
 		{
 			ss.push_back(s);
 			return ss;
@@ -66,45 +67,39 @@ namespace IceSpider {
 			throw std::runtime_error("Find operation " + on + " failed.");
 		}
 
-		RouteCompiler::Type
+		std::optional<RouteCompiler::Type>
 		RouteCompiler::findType(const std::string & tn, const Slice::ContainerPtr & c, const Ice::StringSeq & ns)
 		{
 			for (const auto & strct : c->structs()) {
 				auto fqon = boost::algorithm::join(ns + strct->name(), ".");
 				if (fqon == tn) {
-					return { strct, nullptr };	
+					return {{Slice::typeToString(strct), {}, strct->dataMembers()}};
 				}
 				auto t = findType(tn, strct, ns + strct->name());
 			}
 			for (const auto & cls : c->classes()) {
 				auto fqon = boost::algorithm::join(ns + cls->name(), ".");
 				if (fqon == tn) {
-					return { nullptr, cls->declaration() };
+					return {{Slice::typeToString(cls->declaration()), cls->scoped(), cls->dataMembers()}};
 				}
-				auto t = findType(tn, cls, ns + cls->name());
-				// NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDelete)
-				if (t.first || t.second) {
+				if (auto t = findType(tn, cls, ns + cls->name())) {
 					return t;
 				}
 			}
 			for (const auto & m : c->modules()) {
-				auto t = findType(tn, m, ns + m->name());
-				// NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDelete)
-				if (t.first || t.second) {
+				if (auto t = findType(tn, m, ns + m->name())) {
 					return t;
 				}
 			}
-			return { nullptr, nullptr };
+			return {};
 		}
 
 		RouteCompiler::Type
 		RouteCompiler::findType(const std::string & tn, const Units & us)
 		{
 			for (const auto & u : us) {
-				// NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDelete)
-				auto t = findType(tn, u.second);
-				if (t.first || t.second) {
-					return t;
+				if (auto t = findType(tn, u.second)) {
+					return *t;
 				}
 			}
 			throw std::runtime_error("Find type " + tn + " failed.");
@@ -137,7 +132,8 @@ namespace IceSpider {
 		{
 			for (const auto & r : c->routes) {
 				if (r.second->operation) {
-					r.second->operations[std::string()] = std::make_shared<Operation>(*r.second->operation, StringMap());
+					r.second->operations[std::string()]
+							= std::make_shared<Operation>(*r.second->operation, StringMap());
 				}
 				auto ps = findParameters(r.second, u);
 				for (const auto & p : ps) {
@@ -148,7 +144,12 @@ namespace IceSpider {
 						}
 					}
 					else {
-						defined = r.second->params.insert({ p.first, std::make_shared<Parameter>(ParameterSource::URL, p.first, false, Ice::optional<std::string>(), Ice::optional<std::string>(), false) }).first;
+						defined = r.second->params
+										  .insert({p.first,
+												  std::make_shared<Parameter>(ParameterSource::URL, p.first, false,
+														  Ice::optional<std::string>(), Ice::optional<std::string>(),
+														  false)})
+										  .first;
 					}
 					auto d = defined->second;
 					if (d->source == ParameterSource::URL) {
@@ -184,15 +185,15 @@ namespace IceSpider {
 				throw std::runtime_error("Failed to open output files");
 			}
 			AdHoc::ScopeExit outClose(
-				[out,outh]() {
-					fclose(out);
-					fclose(outh);
-				},
-				nullptr,
-				[&output,&outputh]() {
-					std::filesystem::remove(output);
-					std::filesystem::remove(outputh);
-				});
+					[out, outh]() {
+						fclose(out);
+						fclose(outh);
+					},
+					nullptr,
+					[&output, &outputh]() {
+						std::filesystem::remove(output);
+						std::filesystem::remove(outputh);
+					});
 			processConfiguration(out, outh, output.stem().string(), configuration, units);
 		}
 
@@ -225,7 +226,9 @@ namespace IceSpider {
 				}
 
 				Slice::UnitPtr u = Slice::Unit::createUnit(false, false, false, false);
-				uDestroy.onFailure.emplace_back([u]() { u->destroy(); });
+				uDestroy.onFailure.emplace_back([u]() {
+					u->destroy();
+				});
 
 				int parseStatus = u->parse(realSlice.string(), cppHandle, false);
 
@@ -242,9 +245,9 @@ namespace IceSpider {
 			return units;
 		}
 
-		template<typename ... X>
+		template<typename... X>
 		void
-		fprintbf(unsigned int indent, FILE * output, const X & ... x)
+		fprintbf(unsigned int indent, FILE * output, const X &... x)
 		{
 			for (; indent > 0; --indent) {
 				fputc('\t', output);
@@ -254,36 +257,32 @@ namespace IceSpider {
 		}
 
 		template<typename Enum>
-		std::string getEnumString(Enum & e)
+		std::string
+		getEnumString(Enum & e)
 		{
 			return Slicer::ModelPartForEnum<Enum>::lookup(e);
 		}
 
-		static
-		std::string
+		static std::string
 		outputSerializerClass(const IceSpider::OutputSerializers::value_type & os)
 		{
 			return boost::algorithm::replace_all_copy(os.second->serializer, ".", "::");
 		}
 
 		AdHocFormatter(MimePair, R"C({ "%?", "%?" })C");
-		static
-		std::string
+		static std::string
 		outputSerializerMime(const IceSpider::OutputSerializers::value_type & os)
 		{
 			auto slash = os.first.find('/');
-			return MimePair::get(
-					os.first.substr(0, slash), os.first.substr(slash + 1));
+			return MimePair::get(os.first.substr(0, slash), os.first.substr(slash + 1));
 		}
 
 		void
 		RouteCompiler::registerOutputSerializers(FILE * output, const RoutePtr & r) const
 		{
 			for (const auto & os : r->outputSerializers) {
-				fprintbf(4, output, "addRouteSerializer(%s,\n",
-						outputSerializerMime(os));
-				fprintbf(6, output, "std::make_shared<%s::IceSpiderFactory>(",
-						outputSerializerClass(os));
+				fprintbf(4, output, "addRouteSerializer(%s,\n", outputSerializerMime(os));
+				fprintbf(6, output, "std::make_shared<%s::IceSpiderFactory>(", outputSerializerClass(os));
 				for (auto p = os.second->params.begin(); p != os.second->params.end(); ++p) {
 					if (p != os.second->params.begin()) {
 						fputs(", ", output);
@@ -295,7 +294,8 @@ namespace IceSpider {
 		}
 
 		void
-		RouteCompiler::processConfiguration(FILE * output, FILE * outputh, const std::string & name, const RouteConfigurationPtr & c, const Units & units) const
+		RouteCompiler::processConfiguration(FILE * output, FILE * outputh, const std::string & name,
+				const RouteConfigurationPtr & c, const Units & units) const
 		{
 			fputs("// This source files was generated by IceSpider.\n", output);
 			fprintbf(output, "// Configuration name: %s\n\n", c->name);
@@ -332,7 +332,8 @@ namespace IceSpider {
 		}
 
 		void
-		RouteCompiler::processBases(FILE * output, FILE * outputh, const RouteConfigurationPtr & c, const Units & u) const
+		RouteCompiler::processBases(
+				FILE * output, FILE * outputh, const RouteConfigurationPtr & c, const Units & u) const
 		{
 			fputs("\n", outputh);
 			fprintbf(outputh, "namespace %s {\n", c->name);
@@ -353,7 +354,7 @@ namespace IceSpider {
 			fprintbf(1, outputh, "class %s {\n", b.first);
 			fprintbf(2, outputh, "protected:\n");
 			fprintbf(3, outputh, "explicit %s(const IceSpider::Core * core);\n\n", b.first);
-			for (const auto & f: b.second->functions) {
+			for (const auto & f : b.second->functions) {
 				fprintbf(3, outputh, "%s;\n", f);
 			}
 			fprintbf(1, output, "%s::%s(const IceSpider::Core * core)", b.first, b.first);
@@ -363,10 +364,9 @@ namespace IceSpider {
 			fputs("\n", output);
 			unsigned int pn = 0;
 			for (const auto & p : b.second->proxies) {
-				fprintbf(3, outputh, "const %sPrxPtr prx%u;\n",
-						boost::algorithm::replace_all_copy(p, ".", "::"), pn);
-				fprintbf(3, output, "prx%u(core->getProxy<%s>())",
-						pn, boost::algorithm::replace_all_copy(p, ".", "::"));
+				fprintbf(3, outputh, "const %sPrxPtr prx%u;\n", boost::algorithm::replace_all_copy(p, ".", "::"), pn);
+				fprintbf(
+						3, output, "prx%u(core->getProxy<%s>())", pn, boost::algorithm::replace_all_copy(p, ".", "::"));
 				if (++pn < b.second->proxies.size()) {
 					fputs(",", output);
 				}
@@ -407,7 +407,8 @@ namespace IceSpider {
 			fputs(" {\n", output);
 			fprintbf(2, output, "public:\n");
 			fprintbf(3, output, "explicit %s(const IceSpider::Core * core) :\n", r.first);
-			fprintbf(4, output, "IceSpider::IRouteHandler(IceSpider::HttpMethod::%s, \"%s\")", methodName, r.second->path);
+			fprintbf(4, output, "IceSpider::IRouteHandler(IceSpider::HttpMethod::%s, \"%s\")", methodName,
+					r.second->path);
 			for (const auto & b : r.second->bases) {
 				fputs(",\n", output);
 				fprintbf(4, output, "%s(core)", b);
@@ -437,8 +438,7 @@ namespace IceSpider {
 				}
 				if (p.second->defaultExpr) {
 					fputs(",\n", output);
-					fprintbf(4, output, "_pd_%s(%s)",
-							p.first, *p.second->defaultExpr);
+					fprintbf(4, output, "_pd_%s(%s)", p.first, *p.second->defaultExpr);
 				}
 			}
 			fputs("\n", output);
@@ -453,24 +453,23 @@ namespace IceSpider {
 				if (p.second->hasUserSource) {
 					auto ip = ps.find(p.first)->second;
 					const auto paramType = "std::remove_cvref<%?>::type"_fmt(
-						Slice::inputTypeToString(ip->type(), false, "", ip->getMetaData()));
+							Slice::inputTypeToString(ip->type(), false, "", ip->getMetaData()));
 					// This shouldn't be needed... the warning is ignored elsewhere to no effect
-					fprintbf(4, output, "// NOLINTNEXTLINE(clang-analyzer-optin.cplusplus.VirtualCall)\n");
 					if (p.second->source == ParameterSource::Body) {
 						if (p.second->key) {
 							if (!doneBody) {
 								if (p.second->type) {
-									fprintbf(4, output, "const auto _pbody(request->getBody<%s>());\n",
-											*p.second->type);
+									fprintbf(
+											4, output, "const auto _pbody(request->getBody<%s>());\n", *p.second->type);
 								}
 								else {
-									fprintbf(4, output, "const auto _pbody(request->getBody<IceSpider::StringMap>());\n");
+									fprintbf(4, output,
+											"const auto _pbody(request->getBody<IceSpider::StringMap>());\n");
 								}
 								doneBody = true;
 							}
 							if (p.second->type) {
-								fprintbf(4, output, "const auto _p_%s(_pbody->%s",
-										p.first, p.first);
+								fprintbf(4, output, "const auto _p_%s(_pbody->%s", p.first, p.first);
 							}
 							else {
 								fprintbf(4, output, "const auto _p_%s(request->getBodyParam<%s>(_pbody, _pn_%s)",
@@ -478,25 +477,25 @@ namespace IceSpider {
 							}
 						}
 						else {
-							fprintbf(4, output, "const auto _p_%s(request->getBody<%s>()",
-									p.first, paramType);
+							fprintbf(4, output, "const auto _p_%s(request->getBody<%s>()", p.first, paramType);
 						}
 					}
 					else {
-						fprintbf(4, output, "const auto _p_%s(request->get%sParam<%s>(_p%c_%s)",
-								p.first, getEnumString(p.second->source), paramType,
-								p.second->source == ParameterSource::URL ? 'i' : 'n',
-								p.first);
+						fprintbf(4, output, "const auto _p_%s(request->get%sParam<%s>(_p%c_%s)", p.first,
+								getEnumString(p.second->source), paramType,
+								p.second->source == ParameterSource::URL ? 'i' : 'n', p.first);
 					}
 					if (!p.second->isOptional && p.second->source != ParameterSource::URL) {
 						fprintbf(0, output, " /\n");
 						if (p.second->defaultExpr) {
-							fprintbf(5, output, " [this]() { return _pd_%s; }",
-									p.first);
+							fprintbf(5, output, " [this]() { return _pd_%s; }", p.first);
 						}
 						else {
-							fprintbf(5, output, " [this]() { return requiredParameterNotFound<std::remove_reference<%s>::type>(\"%s\", _pn_%s); }",
-									Slice::inputTypeToString(ip->type(), false, "", ip->getMetaData()), getEnumString(p.second->source), p.first);
+							fprintbf(5, output,
+									" [this]() { return "
+									"requiredParameterNotFound<std::remove_reference<%s>::type>(\"%s\", _pn_%s); }",
+									Slice::inputTypeToString(ip->type(), false, "", ip->getMetaData()),
+									getEnumString(p.second->source), p.first);
 						}
 					}
 					fprintbf(0, output, ");\n");
@@ -522,9 +521,7 @@ namespace IceSpider {
 				}
 				if (p.second->defaultExpr) {
 					auto ip = ps.find(p.first)->second;
-					fprintbf(3, output, "const %s _pd_%s;\n",
-							Slice::typeToString(ip->type()), p.first);
-
+					fprintbf(3, output, "const %s _pd_%s;\n", Slice::typeToString(ip->type()), p.first);
 				}
 			}
 			fprintbf(1, output, "};\n\n");
@@ -540,7 +537,8 @@ namespace IceSpider {
 				if (proxies.find(proxyName) == proxies.end()) {
 					proxies[proxyName] = n;
 					fputs(",\n", output);
-					fprintbf(4, output, "prx%d(core->getProxy<%s>())", n, boost::algorithm::replace_all_copy(proxyName, ".", "::"));
+					fprintbf(4, output, "prx%d(core->getProxy<%s>())", n,
+							boost::algorithm::replace_all_copy(proxyName, ".", "::"));
 					n += 1;
 				}
 			}
@@ -551,7 +549,8 @@ namespace IceSpider {
 		RouteCompiler::declareProxies(FILE * output, const Proxies & proxies) const
 		{
 			for (const auto & p : proxies) {
-				fprintbf(3, output, "const %sPrxPtr prx%d;\n", boost::algorithm::replace_all_copy(p.first, ".", "::"), p.second);
+				fprintbf(3, output, "const %sPrxPtr prx%d;\n", boost::algorithm::replace_all_copy(p.first, ".", "::"),
+						p.second);
 			}
 		}
 
@@ -575,7 +574,7 @@ namespace IceSpider {
 				}
 			}
 			fprintbf(output, "request->getContext());\n");
-			for(const auto & mutator : r->mutators) {
+			for (const auto & mutator : r->mutators) {
 				fprintbf(4, output, "%s(request, _responseModel);\n", mutator);
 			}
 			if (o->returnType()) {
@@ -587,12 +586,14 @@ namespace IceSpider {
 		}
 
 		void
-		RouteCompiler::addMashupOperations(FILE * output, const RoutePtr & r, const Proxies & proxies, const Units & us) const
+		RouteCompiler::addMashupOperations(
+				FILE * output, const RoutePtr & r, const Proxies & proxies, const Units & us) const
 		{
 			for (const auto & o : r->operations) {
 				auto proxyName = o.second->operation.substr(0, o.second->operation.find_last_of('.'));
 				auto operation = o.second->operation.substr(o.second->operation.find_last_of('.') + 1);
-				fprintbf(4, output, "auto _ar_%s = prx%s->%sAsync(", o.first, proxies.find(proxyName)->second, operation);
+				fprintbf(4, output, "auto _ar_%s = prx%s->%sAsync(", o.first, proxies.find(proxyName)->second,
+						operation);
 				auto so = findOperation(o.second->operation, us);
 				for (const auto & p : so->parameters()) {
 					auto po = o.second->paramOverrides.find(p->name());
@@ -607,23 +608,14 @@ namespace IceSpider {
 				fprintbf(output, "request->getContext());\n");
 			}
 			auto t = findType(r->type, us);
-			Slice::DataMemberList members;
-			if (t.second) {
-				fprintbf(4, output, "%s _responseModel = std::make_shared<%s>();\n",
-						Slice::typeToString(t.second),
-						t.second->scoped());
-				members = t.second->definition()->dataMembers();
+			fprintbf(4, output, "%s _responseModel", t.type);
+			if (t.scoped) {
+				fprintbf(4, output, " = std::make_shared<%s>()", *t.scoped);
 			}
-			else {
-				fprintbf(4, output, "%s _responseModel;\n",
-						Slice::typeToString(t.first));
-				members = t.first->dataMembers();
-			}
-			for (const auto & mi : members) {
+			fprintbf(4, output, ";\n");
+			for (const auto & mi : t.members) {
 				bool isOp = false;
-				fprintbf(4, output, "_responseModel%s%s = ",
-						t.second ? "->" : ".",
-						mi->name());
+				fprintbf(4, output, "_responseModel%s%s = ", t.scoped ? "->" : ".", mi->name());
 				for (const auto & o : r->operations) {
 					auto proxyName = o.second->operation.substr(0, o.second->operation.find_last_of('.'));
 					auto operation = o.second->operation.substr(o.second->operation.find_last_of('.') + 1);
@@ -645,4 +637,3 @@ namespace IceSpider {
 		}
 	}
 }
-
diff --git a/icespider/compile/routeCompiler.h b/icespider/compile/routeCompiler.h
index fef7648..7549d2b 100644
--- a/icespider/compile/routeCompiler.h
+++ b/icespider/compile/routeCompiler.h
@@ -1,54 +1,61 @@
 #ifndef ICESPIDER_COMPILE_ROURTECOMPILER_H
 #define ICESPIDER_COMPILE_ROURTECOMPILER_H
 
+#include <Ice/BuiltinSequences.h>
+#include <Slice/Parser.h>
 #include <filesystem>
-#include <visibility.h>
-#include <vector>
 #include <routes.h>
-#include <Slice/Parser.h>
-#include <Ice/BuiltinSequences.h>
+#include <vector>
+#include <visibility.h>
 
 namespace IceSpider {
 	namespace Compile {
 		class DLL_PUBLIC RouteCompiler {
-			public:
-				typedef std::map<std::string, Slice::UnitPtr> Units;
+		public:
+			using Units = std::map<std::string, Slice::UnitPtr>;
 
-				RouteCompiler();
+			RouteCompiler();
 
-				RouteConfigurationPtr loadConfiguration(const std::filesystem::path &) const;
-				Units loadUnits(const RouteConfigurationPtr &) const;
+			[[nodiscard]] RouteConfigurationPtr loadConfiguration(const std::filesystem::path &) const;
+			[[nodiscard]] Units loadUnits(const RouteConfigurationPtr &) const;
 
-				void applyDefaults(const RouteConfigurationPtr &, const Units & u) const;
-				void compile(const std::filesystem::path & input, const std::filesystem::path & output) const;
+			void applyDefaults(const RouteConfigurationPtr &, const Units & u) const;
+			void compile(const std::filesystem::path & input, const std::filesystem::path & output) const;
 
-				std::vector<std::filesystem::path> searchPath;
+			std::vector<std::filesystem::path> searchPath;
 
-			private:
-				typedef std::map<std::string, int> Proxies;
+		private:
+			using Proxies = std::map<std::string, int>;
 
 #pragma GCC visibility push(hidden)
-				void processConfiguration(FILE * output, FILE * outputh, const std::string & name, const RouteConfigurationPtr &, const Units &) const;
-				void processBases(FILE * output, FILE * outputh, const RouteConfigurationPtr &, const Units &) const;
-				void processBase(FILE * output, FILE * outputh, const RouteBases::value_type &, const Units &) const;
-				void processRoutes(FILE * output, const RouteConfigurationPtr &, const Units &) const;
-				void processRoute(FILE * output, const Routes::value_type &, const Units &) const;
-				void registerOutputSerializers(FILE * output, const RoutePtr &) const;
-				Proxies initializeProxies(FILE * output, const RoutePtr &) const;
-				void declareProxies(FILE * output, const Proxies &) const;
-				void addSingleOperation(FILE * output, const RoutePtr &, const Slice::OperationPtr &) const;
-				void addMashupOperations(FILE * output, const RoutePtr &, const Proxies &, const Units &) const;
-				using ParameterMap = std::map<std::string, Slice::ParamDeclPtr>;
-				static ParameterMap findParameters(const RoutePtr &, const Units &);
-				static Slice::OperationPtr findOperation(const std::string &, const Units &);
-				static Slice::OperationPtr findOperation(const std::string &, const Slice::ContainerPtr &, const Ice::StringSeq & = Ice::StringSeq());
-				using Type = std::pair<Slice::StructPtr, Slice::ClassDeclPtr>;
-				static Type findType(const std::string &, const Units &);
-				static Type findType(const std::string &, const Slice::ContainerPtr &, const Ice::StringSeq & = Ice::StringSeq());
+			void processConfiguration(FILE * output, FILE * outputh, const std::string & name,
+					const RouteConfigurationPtr &, const Units &) const;
+			void processBases(FILE * output, FILE * outputh, const RouteConfigurationPtr &, const Units &) const;
+			void processBase(FILE * output, FILE * outputh, const RouteBases::value_type &, const Units &) const;
+			void processRoutes(FILE * output, const RouteConfigurationPtr &, const Units &) const;
+			void processRoute(FILE * output, const Routes::value_type &, const Units &) const;
+			void registerOutputSerializers(FILE * output, const RoutePtr &) const;
+			[[nodiscard]] Proxies initializeProxies(FILE * output, const RoutePtr &) const;
+			void declareProxies(FILE * output, const Proxies &) const;
+			void addSingleOperation(FILE * output, const RoutePtr &, const Slice::OperationPtr &) const;
+			void addMashupOperations(FILE * output, const RoutePtr &, const Proxies &, const Units &) const;
+			using ParameterMap = std::map<std::string, Slice::ParamDeclPtr>;
+			static ParameterMap findParameters(const RoutePtr &, const Units &);
+			static Slice::OperationPtr findOperation(const std::string &, const Units &);
+			static Slice::OperationPtr findOperation(
+					const std::string &, const Slice::ContainerPtr &, const Ice::StringSeq & = Ice::StringSeq());
+			// using Type = std::pair<Slice::StructPtr, Slice::ClassDeclPtr>;
+			struct Type {
+				std::string type;
+				std::optional<std::string> scoped;
+				Slice::DataMemberList members;
+			};
+			static Type findType(const std::string &, const Units &);
+			static std::optional<Type> findType(
+					const std::string &, const Slice::ContainerPtr &, const Ice::StringSeq & = Ice::StringSeq());
 #pragma GCC visibility pop
 		};
 	}
 }
 
 #endif
-
diff --git a/icespider/core/core.cpp b/icespider/core/core.cpp
index 98ad99c..6bf8ad3 100644
--- a/icespider/core/core.cpp
+++ b/icespider/core/core.cpp
@@ -2,10 +2,10 @@
 #include "exceptions.h"
 #include <Ice/Initialize.h>
 #include <Ice/ObjectAdapter.h>
-#include <filesystem>
+#include <compileTimeFormatter.h>
 #include <cxxabi.h>
 #include <factory.impl.h>
-#include <compileTimeFormatter.h>
+#include <filesystem>
 
 INSTANTIATEFACTORY(IceSpider::Plugin, Ice::CommunicatorPtr, Ice::PropertiesPtr);
 INSTANTIATEPLUGINOF(IceSpider::ErrorHandler);
@@ -105,7 +105,8 @@ namespace IceSpider {
 		defaultErrorReport(request, exception);
 	}
 
-	auto demangle(const char * const name)
+	auto
+	demangle(const char * const name)
 	{
 		return std::unique_ptr<char, decltype(&std::free)>(
 				__cxxabiv1::__cxa_demangle(name, nullptr, nullptr, nullptr), std::free);
@@ -143,8 +144,7 @@ namespace IceSpider {
 		return i;
 	}
 
-	static
-	bool
+	static bool
 	operator/=(const PathElements & pathparts, const IRouteHandler * r)
 	{
 		auto rpi = r->parts.begin();
@@ -156,8 +156,7 @@ namespace IceSpider {
 		return true;
 	}
 
-	CoreWithDefaultRouter::CoreWithDefaultRouter(const Ice::StringSeq & opts) :
-		Core(opts)
+	CoreWithDefaultRouter::CoreWithDefaultRouter(const Ice::StringSeq & opts) : Core(opts)
 	{
 		for (const auto & r : allRoutes) {
 			if (routes.size() <= r->pathElementCount()) {
@@ -193,4 +192,3 @@ namespace IceSpider {
 	}
 
 }
-
diff --git a/icespider/core/core.h b/icespider/core/core.h
index 08b649e..d60b20f 100644
--- a/icespider/core/core.h
+++ b/icespider/core/core.h
@@ -1,58 +1,61 @@
 #ifndef ICESPIDER_CORE_CORE_H
 #define ICESPIDER_CORE_CORE_H
 
-#include <visibility.h>
-#include <vector>
 #include "irouteHandler.h"
 #include <Ice/Communicator.h>
+#include <c++11Helpers.h>
 #include <filesystem>
 #include <plugins.h>
+#include <vector>
+#include <visibility.h>
 
 namespace IceSpider {
 	class DLL_PUBLIC Core {
-		public:
-			typedef std::vector<IRouteHandlerCPtr> AllRoutes;
+	public:
+		using AllRoutes = std::vector<IRouteHandlerCPtr>;
 
-			Core(const Ice::StringSeq & = {});
-			virtual ~Core();
+		explicit Core(const Ice::StringSeq & = {});
+		SPECIAL_MEMBERS_MOVE_RO(Core);
+		virtual ~Core();
 
-			virtual const IRouteHandler * findRoute(const IHttpRequest *) const = 0;
-			void process(IHttpRequest *, const IRouteHandler * = nullptr) const;
-			void handleError(IHttpRequest *, const std::exception &) const;
+		virtual const IRouteHandler * findRoute(const IHttpRequest *) const = 0;
+		void process(IHttpRequest *, const IRouteHandler * = nullptr) const;
+		void handleError(IHttpRequest *, const std::exception &) const;
 
-			Ice::ObjectPrxPtr getProxy(const char * type) const;
+		[[nodiscard]] Ice::ObjectPrxPtr getProxy(const char * type) const;
 
-			template<typename Interface>
-			auto getProxy() const
-			{
-				return Ice::uncheckedCast<typename Interface::ProxyType>(getProxy(typeid(Interface).name()));
-			}
+		template<typename Interface>
+		[[nodiscard]] auto
+		getProxy() const
+		{
+			return Ice::uncheckedCast<typename Interface::ProxyType>(getProxy(typeid(Interface).name()));
+		}
 
-			AllRoutes allRoutes;
-			Ice::CommunicatorPtr communicator;
-			Ice::ObjectAdapterPtr pluginAdapter;
+		AllRoutes allRoutes;
+		Ice::CommunicatorPtr communicator;
+		Ice::ObjectAdapterPtr pluginAdapter;
 
-			static const std::filesystem::path defaultConfig;
+		static const std::filesystem::path defaultConfig;
 
-		private:
-			void defaultErrorReport(IHttpRequest * request, const std::exception & ex) const;
+	private:
+		void defaultErrorReport(IHttpRequest * request, const std::exception & ex) const;
 	};
 
 	class DLL_PUBLIC CoreWithDefaultRouter : public Core {
-		public:
-			typedef std::vector<IRouteHandlerCPtr> LengthRoutes;
-			typedef std::vector<LengthRoutes> Routes;
+	public:
+		using LengthRoutes = std::vector<IRouteHandlerCPtr>;
+		using Routes = std::vector<LengthRoutes>;
 
-			CoreWithDefaultRouter(const Ice::StringSeq & = {});
+		explicit CoreWithDefaultRouter(const Ice::StringSeq & = {});
 
-			const IRouteHandler * findRoute(const IHttpRequest *) const override;
+		const IRouteHandler * findRoute(const IHttpRequest *) const override;
 
-			Routes routes;
+		Routes routes;
 	};
 
 	class DLL_PUBLIC Plugin : public virtual Ice::Object {
 	};
-	typedef AdHoc::Factory<Plugin, Ice::CommunicatorPtr, Ice::PropertiesPtr> PluginFactory;
+	using PluginFactory = AdHoc::Factory<Plugin, Ice::CommunicatorPtr, Ice::PropertiesPtr>;
 
 	enum ErrorHandlerResult {
 		ErrorHandlerResult_Unhandled,
@@ -60,11 +63,10 @@ namespace IceSpider {
 		ErrorHandlerResult_Modified,
 	};
 	class DLL_PUBLIC ErrorHandler : public AdHoc::AbstractPluginImplementation {
-		public:
-			virtual ErrorHandlerResult handleError(IHttpRequest * IHttpRequest, const std::exception &) const = 0;
+	public:
+		virtual ErrorHandlerResult handleError(IHttpRequest * IHttpRequest, const std::exception &) const = 0;
 	};
-	typedef AdHoc::PluginOf<ErrorHandler> ErrorHandlerPlugin;
+	using ErrorHandlerPlugin = AdHoc::PluginOf<ErrorHandler>;
 }
 
 #endif
-
diff --git a/icespider/core/exceptions.cpp b/icespider/core/exceptions.cpp
index d249fcc..83ab13a 100644
--- a/icespider/core/exceptions.cpp
+++ b/icespider/core/exceptions.cpp
@@ -7,4 +7,3 @@ namespace IceSpider {
 	DefineHttpEx(Http406_NotAcceptable, 406, "Not Acceptable");
 	DefineHttpEx(Http415_UnsupportedMediaType, 415, "Unsupported Media Type");
 }
-
diff --git a/icespider/core/exceptions.h b/icespider/core/exceptions.h
index a11ea45..8e3466d 100644
--- a/icespider/core/exceptions.h
+++ b/icespider/core/exceptions.h
@@ -6,10 +6,10 @@
 
 #define DeclareHttpEx(Name) \
 	class DLL_PUBLIC Name : public ::IceSpider::HttpException { \
-		public: \
-			Name(); \
-			static const short code; \
-			static const std::string message; \
+	public: \
+		Name(); \
+		static const short code; \
+		static const std::string message; \
 	}
 #define DefineHttpEx(Name, Code, Message) \
 	Name::Name() : ::IceSpider::HttpException(__FILE__, __LINE__, code, message) { } \
@@ -25,4 +25,3 @@ namespace IceSpider {
 }
 
 #endif
-
diff --git a/icespider/core/ihttpRequest.cpp b/icespider/core/ihttpRequest.cpp
index bb0b7af..75b050a 100644
--- a/icespider/core/ihttpRequest.cpp
+++ b/icespider/core/ihttpRequest.cpp
@@ -1,20 +1,17 @@
 #include "ihttpRequest.h"
+#include "exceptions.h"
 #include "irouteHandler.h"
 #include "util.h"
-#include "exceptions.h"
 #include "xwwwFormUrlEncoded.h"
 #include <boost/lexical_cast.hpp>
-#include <ctime>
 #include <cstdio>
+#include <ctime>
 #include <formatters.h>
 
 namespace IceSpider {
 	using namespace AdHoc::literals;
 
-	IHttpRequest::IHttpRequest(const Core * c) :
-		core(c)
-	{
-	}
+	IHttpRequest::IHttpRequest(const Core * c) : core(c) { }
 
 	Ice::Context
 	IHttpRequest::getContext() const
@@ -27,9 +24,10 @@ namespace IceSpider {
 	{
 		try {
 			return Slicer::StreamDeserializerFactory::createNew(
-				getEnv(E::CONTENT_TYPE) / []() -> std::string_view {
-					throw Http400_BadRequest();
-				}, getInputStream());
+					getEnv(E::CONTENT_TYPE) / []() -> std::string_view {
+						throw Http400_BadRequest();
+					},
+					getInputStream());
 		}
 		catch (const AdHoc::NoSuchPluginException &) {
 			throw Http415_UnsupportedMediaType();
@@ -82,7 +80,9 @@ namespace IceSpider {
 		if (accepts.empty()) {
 			throw Http400_BadRequest();
 		}
-		std::stable_sort(accepts.begin(), accepts.end(), [](const auto & a, const auto & b) { return a->q > b->q; });
+		std::stable_sort(accepts.begin(), accepts.end(), [](const auto & a, const auto & b) {
+			return a->q > b->q;
+		});
 		return accepts;
 	}
 
@@ -93,7 +93,7 @@ namespace IceSpider {
 		if (acceptHdr) {
 			auto accepts = parseAccept(*acceptHdr);
 			auto & strm = getOutputStream();
-			for(auto & a : accepts) {
+			for (auto & a : accepts) {
 				ContentTypeSerializer serializer = handler->getSerializer(a, strm);
 				if (serializer.second) {
 					return serializer;
@@ -116,8 +116,9 @@ namespace IceSpider {
 		return url[idx];
 	}
 
-	template <typename T, typename Y>
-	inline T wrapLexicalCast(const Y & y)
+	template<typename T, typename Y>
+	inline T
+	wrapLexicalCast(const Y & y)
 	{
 		try {
 			return boost::lexical_cast<T>(y);
@@ -129,9 +130,9 @@ namespace IceSpider {
 
 	// Set-Cookie: value[; expires=date][; domain=domain][; path=path][; secure]
 	// Sat, 02 May 2009 23:38:25 GMT
-	void IHttpRequest::setCookie(const std::string_view & name, const std::string_view & value,
-			const OptionalString & d, const OptionalString & p, bool s,
-			std::optional<time_t> e)
+	void
+	IHttpRequest::setCookie(const std::string_view & name, const std::string_view & value, const OptionalString & d,
+			const OptionalString & p, bool s, std::optional<time_t> e)
 	{
 		std::stringstream o;
 		XWwwFormUrlEncoded::urlencodeto(o, name.begin(), name.end());
@@ -139,7 +140,8 @@ namespace IceSpider {
 		XWwwFormUrlEncoded::urlencodeto(o, value.begin(), value.end());
 		if (e) {
 			std::string buf(45, 0);
-			struct tm tm { };
+			struct tm tm {
+			};
 			gmtime_r(&*e, &tm);
 			buf.resize(strftime(buf.data(), buf.length(), "; expires=%a, %d %b %Y %T %Z", &tm));
 			o << buf;
@@ -150,15 +152,16 @@ namespace IceSpider {
 		if (p) {
 			"; path=%?"_fmt(o, *p);
 		}
-		if (s){
+		if (s) {
 			"; secure"_fmt(o);
 		}
 		"; samesite=strict"_fmt(o);
 		setHeader(H::SET_COOKIE, o.str());
 	}
 
-	template <typename T>
-	inline std::optional<T> optionalLexicalCast(const OptionalString & p)
+	template<typename T>
+	inline std::optional<T>
+	optionalLexicalCast(const OptionalString & p)
 	{
 		if (p) {
 			return wrapLexicalCast<T>(*p);
@@ -166,7 +169,8 @@ namespace IceSpider {
 		return {};
 	}
 
-	void IHttpRequest::responseRedirect(const std::string_view & url, const OptionalString & statusMsg) const
+	void
+	IHttpRequest::responseRedirect(const std::string_view & url, const OptionalString & statusMsg) const
 	{
 		setHeader(H::LOCATION, url);
 		response(303, (statusMsg ? *statusMsg : S::MOVED));
@@ -185,5 +189,3 @@ namespace IceSpider {
 	static_assert(!std::is_convertible<OptionalString::value_type, std::string>::value);
 	static_assert(std::is_constructible<OptionalString::value_type, std::string>::value);
 }
-
-
diff --git a/icespider/core/ihttpRequest.h b/icespider/core/ihttpRequest.h
index a8eee28..b4bab30 100644
--- a/icespider/core/ihttpRequest.h
+++ b/icespider/core/ihttpRequest.h
@@ -1,143 +1,147 @@
 #ifndef ICESPIDER_IHTTPREQUEST_H
 #define ICESPIDER_IHTTPREQUEST_H
 
+#include "exceptions.h"
+#include <Ice/Current.h>
+#include <Ice/Optional.h>
 #include <IceUtil/Exception.h>
 #include <IceUtil/Optional.h>
-#include <Ice/Current.h>
-#include <visibility.h>
+#include <boost/lexical_cast.hpp>
 #include <http.h>
 #include <slicer/slicer.h>
-#include <Ice/Optional.h>
-#include <boost/lexical_cast.hpp>
-#include "exceptions.h"
+#include <visibility.h>
 
 namespace IceSpider {
 	class Core;
 	class IRouteHandler;
 
-	typedef std::vector<std::string> PathElements;
-	typedef std::optional<std::string_view> OptionalString;
-	typedef std::pair<MimeType, Slicer::SerializerPtr> ContentTypeSerializer;
+	using PathElements = std::vector<std::string>;
+	using OptionalString = std::optional<std::string_view>;
+	using ContentTypeSerializer = std::pair<MimeType, Slicer::SerializerPtr>;
 
 	class DLL_PUBLIC IHttpRequest {
-		public:
-			IHttpRequest(const Core *);
+	public:
+		explicit IHttpRequest(const Core *);
 
-			Ice::Context getContext() const;
-			virtual const PathElements & getRequestPath() const = 0;
-			virtual PathElements & getRequestPath() = 0;
-			virtual HttpMethod getRequestMethod() const = 0;
+		[[nodiscard]] Ice::Context getContext() const;
+		[[nodiscard]] virtual const PathElements & getRequestPath() const = 0;
+		[[nodiscard]] virtual PathElements & getRequestPath() = 0;
+		[[nodiscard]] virtual HttpMethod getRequestMethod() const = 0;
 
-			OptionalString getURLParam(const unsigned int &) const;
-			virtual OptionalString getQueryStringParam(const std::string_view &) const = 0;
-			virtual OptionalString getHeaderParam(const std::string_view &) const = 0;
-			virtual OptionalString getCookieParam(const std::string_view &) const = 0;
-			virtual OptionalString getEnv(const std::string_view &) const = 0;
-			virtual bool isSecure() const = 0;
-			static Accepted parseAccept(const std::string_view &);
-			virtual Slicer::DeserializerPtr getDeserializer() const;
-			virtual ContentTypeSerializer getSerializer(const IRouteHandler *) const;
-			virtual std::istream & getInputStream() const = 0;
-			virtual std::ostream & getOutputStream() const = 0;
-			virtual void setHeader(const std::string_view &, const std::string_view &) const = 0;
+		[[nodiscard]] OptionalString getURLParam(const unsigned int &) const;
+		[[nodiscard]] virtual OptionalString getQueryStringParam(const std::string_view &) const = 0;
+		[[nodiscard]] virtual OptionalString getHeaderParam(const std::string_view &) const = 0;
+		[[nodiscard]] virtual OptionalString getCookieParam(const std::string_view &) const = 0;
+		[[nodiscard]] virtual OptionalString getEnv(const std::string_view &) const = 0;
+		[[nodiscard]] virtual bool isSecure() const = 0;
+		[[nodiscard]] static Accepted parseAccept(const std::string_view &);
+		[[nodiscard]] virtual Slicer::DeserializerPtr getDeserializer() const;
+		[[nodiscard]] virtual ContentTypeSerializer getSerializer(const IRouteHandler *) const;
+		[[nodiscard]] virtual std::istream & getInputStream() const = 0;
+		[[nodiscard]] virtual std::ostream & getOutputStream() const = 0;
+		virtual void setHeader(const std::string_view &, const std::string_view &) const = 0;
 
-			virtual std::ostream & dump(std::ostream & s) const = 0;
+		virtual std::ostream & dump(std::ostream & s) const = 0;
 
-			template<typename T, typename K>
-			inline
-			std::optional<T> getFrom(const K & key, OptionalString (IHttpRequest::*src)(const K &) const) const
-			{
-				if (auto v = (this->*src)(key)) {
-					if constexpr (std::is_convertible<std::string_view, T>::value) {
-						return *v;
-					}
-					else if constexpr (std::is_constructible<std::string_view, T>::value) {
-						return T(*v);
-					}
-					else if constexpr (std::is_same<std::string, T>::value) {
-						return std::to_string(*v);
-					}
-					else {
-						try {
-							// NOLINTNEXTLINE(clang-analyzer-optin.cplusplus.VirtualCall)
-							return boost::lexical_cast<T>(*v);
-						}
-						catch (const boost::bad_lexical_cast & e) {
-							throw Http400_BadRequest();
-						}
-					}
+		template<typename T, typename K>
+		[[nodiscard]] inline std::optional<T>
+		getFrom(const K & key, OptionalString (IHttpRequest::*src)(const K &) const) const
+		{
+			if (auto v = (this->*src)(key)) {
+				if constexpr (std::is_convertible<std::string_view, T>::value) {
+					return *v;
 				}
-				else {
-					return std::nullopt;
+				else if constexpr (std::is_constructible<std::string_view, T>::value) {
+					return T(*v);
 				}
-			}
-			template<typename T>
-			T getURLParam(unsigned int n) const
-			{
-				// NOLINTNEXTLINE(clang-analyzer-optin.cplusplus.VirtualCall)
-				return *getFrom<T, unsigned int>(n, &IHttpRequest::getURLParam);
-			}
-			template<typename T>
-			std::optional<T> getBody() const
-			{
-				return Slicer::DeserializeAnyWith<T>(getDeserializer());
-			}
-			template<typename T>
-			std::optional<T> getBodyParam(const std::optional<IceSpider::StringMap> & map, const std::string_view & key) const
-			{
-				if (!map) {
-					return {};
-				}
-				auto i = map->find(key);
-				if (i == map->end()) {
-					return {};
+				else if constexpr (std::is_same<std::string, T>::value) {
+					return std::to_string(*v);
 				}
 				else {
-					return boost::lexical_cast<T>(i->second);
+					try {
+						return boost::lexical_cast<T>(*v);
+					}
+					catch (const boost::bad_lexical_cast & e) {
+						throw Http400_BadRequest();
+					}
 				}
 			}
-			void responseRedirect(const std::string_view & url, const OptionalString & = {}) const;
-			void setCookie(const std::string_view &, const std::string_view &,
-					const OptionalString & = {}, const OptionalString & = {},
-					bool = false, std::optional<time_t> = {});
-			template<typename T>
-			void setCookie(const std::string_view & n, const T & v,
-					const OptionalString & d, const OptionalString & p,
-					bool s, std::optional<time_t> e) {
-				if constexpr (std::is_constructible<std::string_view, T>::value) {
-					setCookie(n, std::string_view(v), d, p, s, e);
-				}
-				else {
-					auto vs = boost::lexical_cast<std::string>(v);
-					setCookie(n, std::string_view(vs), d, p, s, e);
-				}
+			else {
+				return std::nullopt;
+			}
+		}
+		template<typename T>
+		[[nodiscard]] T
+		getURLParam(unsigned int n) const
+		{
+			return *getFrom<T, unsigned int>(n, &IHttpRequest::getURLParam);
+		}
+		template<typename T>
+		[[nodiscard]] std::optional<T>
+		getBody() const
+		{
+			return Slicer::DeserializeAnyWith<T>(getDeserializer());
+		}
+		template<typename T>
+		[[nodiscard]] std::optional<T>
+		getBodyParam(const std::optional<IceSpider::StringMap> & map, const std::string_view & key) const
+		{
+			if (!map) {
+				return {};
 			}
-			template<typename T>
-			std::optional<T> getQueryStringParam(const std::string_view & key) const
-			{
-				return getFrom<T, std::string_view>(key, &IHttpRequest::getQueryStringParam);
+			auto i = map->find(key);
+			if (i == map->end()) {
+				return {};
 			}
-			template<typename T>
-			std::optional<T> getHeaderParam(const std::string_view & key) const
-			{
-				return getFrom<T, std::string_view>(key, &IHttpRequest::getHeaderParam);
+			else {
+				return boost::lexical_cast<T>(i->second);
 			}
-			template<typename T>
-			std::optional<T> getCookieParam(const std::string_view & key) const
-			{
-				return getFrom<T, std::string_view>(key, &IHttpRequest::getCookieParam);
+		}
+		void responseRedirect(const std::string_view & url, const OptionalString & = {}) const;
+		void setCookie(const std::string_view &, const std::string_view &, const OptionalString & = {},
+				const OptionalString & = {}, bool = false, std::optional<time_t> = {});
+		template<typename T>
+		void
+		setCookie(const std::string_view & n, const T & v, const OptionalString & d, const OptionalString & p, bool s,
+				std::optional<time_t> e)
+		{
+			if constexpr (std::is_constructible<std::string_view, T>::value) {
+				setCookie(n, std::string_view(v), d, p, s, e);
 			}
-			virtual void response(short, const std::string_view &) const = 0;
-			template<typename T>
-			void response(const IRouteHandler * route, const T & t) const
-			{
-				modelPartResponse(route, Slicer::ModelPart::CreateRootFor(t));
+			else {
+				auto vs = boost::lexical_cast<std::string>(v);
+				setCookie(n, std::string_view(vs), d, p, s, e);
 			}
-			void modelPartResponse(const IRouteHandler * route, const Slicer::ModelPartForRootPtr &) const;
+		}
+		template<typename T>
+		[[nodiscard]] std::optional<T>
+		getQueryStringParam(const std::string_view & key) const
+		{
+			return getFrom<T, std::string_view>(key, &IHttpRequest::getQueryStringParam);
+		}
+		template<typename T>
+		[[nodiscard]] std::optional<T>
+		getHeaderParam(const std::string_view & key) const
+		{
+			return getFrom<T, std::string_view>(key, &IHttpRequest::getHeaderParam);
+		}
+		template<typename T>
+		[[nodiscard]] std::optional<T>
+		getCookieParam(const std::string_view & key) const
+		{
+			return getFrom<T, std::string_view>(key, &IHttpRequest::getCookieParam);
+		}
+		virtual void response(short, const std::string_view &) const = 0;
+		template<typename T>
+		void
+		response(const IRouteHandler * route, const T & t) const
+		{
+			modelPartResponse(route, Slicer::ModelPart::CreateRootFor(t));
+		}
+		void modelPartResponse(const IRouteHandler * route, const Slicer::ModelPartForRootPtr &) const;
 
-			const Core * core;
+		const Core * core;
 	};
 }
 
 #endif
-
diff --git a/icespider/core/irouteHandler.cpp b/icespider/core/irouteHandler.cpp
index 244f660..b968397 100644
--- a/icespider/core/irouteHandler.cpp
+++ b/icespider/core/irouteHandler.cpp
@@ -10,22 +10,18 @@ namespace IceSpider {
 	static const std::string JSON = "json";
 	static const std::string APPLICATION_JSON = MimeTypeFmt::get(APPLICATION, JSON);
 
-	const RouteOptions IRouteHandler::defaultRouteOptions {
-	};
+	const RouteOptions IRouteHandler::defaultRouteOptions {};
 	IRouteHandler::IRouteHandler(HttpMethod m, const std::string_view & p) :
-		IRouteHandler(m, p, defaultRouteOptions)
-	{
-	}
+		IRouteHandler(m, p, defaultRouteOptions) { }
 
-	IRouteHandler::IRouteHandler(HttpMethod m, const std::string_view & p, const RouteOptions & ro) :
-		Path(p),
-		method(m)
+	IRouteHandler::IRouteHandler(HttpMethod m, const std::string_view & p, const RouteOptions & ro) : Path(p), method(m)
 	{
 		if (ro.addDefaultSerializers) {
 			auto globalSerializers = AdHoc::PluginManager::getDefault()->getAll<Slicer::StreamSerializerFactory>();
 			for (const auto & gs : globalSerializers) {
 				auto slash = gs->name.find('/');
-				routeSerializers.insert({ { gs->name.substr(0, slash), gs->name.substr(slash + 1) }, gs->implementation() });
+				routeSerializers.insert(
+						{{gs->name.substr(0, slash), gs->name.substr(slash + 1)}, gs->implementation()});
 			}
 		}
 	}
@@ -35,7 +31,7 @@ namespace IceSpider {
 	{
 		for (const auto & rs : routeSerializers) {
 			if ((!a->group || rs.first.group == a->group) && (!a->type || rs.first.type == a->type)) {
-				return { rs.first, rs.second->create(strm) };
+				return {rs.first, rs.second->create(strm)};
 			}
 		}
 		return ContentTypeSerializer();
@@ -44,10 +40,7 @@ namespace IceSpider {
 	ContentTypeSerializer
 	IRouteHandler::defaultSerializer(std::ostream & strm) const
 	{
-		return {
-			{ APPLICATION, JSON },
-			Slicer::StreamSerializerFactory::createNew(APPLICATION_JSON, strm)
-		};
+		return {{APPLICATION, JSON}, Slicer::StreamSerializerFactory::createNew(APPLICATION_JSON, strm)};
 	}
 
 	void
@@ -60,7 +53,6 @@ namespace IceSpider {
 	IRouteHandler::addRouteSerializer(const MimeType & ct, const StreamSerializerFactoryPtr & ssfp)
 	{
 		routeSerializers.erase(ct);
-		routeSerializers.insert({ ct, ssfp });
+		routeSerializers.insert({ct, ssfp});
 	}
 }
-
diff --git a/icespider/core/irouteHandler.h b/icespider/core/irouteHandler.h
index 168008e..7889031 100644
--- a/icespider/core/irouteHandler.h
+++ b/icespider/core/irouteHandler.h
@@ -1,60 +1,61 @@
 #ifndef ICESPIDER_IROUTEHANDLER_H
 #define ICESPIDER_IROUTEHANDLER_H
 
+#include "exceptions.h"
 #include "ihttpRequest.h"
+#include "routeOptions.h"
 #include "util.h"
-#include "exceptions.h"
-#include <pathparts.h>
+#include <c++11Helpers.h>
 #include <factory.h>
+#include <pathparts.h>
 #include <visibility.h>
-#include "routeOptions.h"
 
 namespace IceSpider {
 	class Core;
 
 	class DLL_PUBLIC IRouteHandler : public Path {
-		public:
-			const static RouteOptions defaultRouteOptions;
-
-			IRouteHandler(HttpMethod, const std::string_view & path);
-			IRouteHandler(HttpMethod, const std::string_view & path, const RouteOptions &);
-			virtual ~IRouteHandler() = default;
-
-			virtual void execute(IHttpRequest * request) const = 0;
-			virtual ContentTypeSerializer getSerializer(const AcceptPtr &, std::ostream &) const;
-			virtual ContentTypeSerializer defaultSerializer(std::ostream &) const;
-
-			const HttpMethod method;
-
-		protected:
-			typedef std::shared_ptr<Slicer::StreamSerializerFactory> StreamSerializerFactoryPtr;
-			typedef std::map<MimeType, StreamSerializerFactoryPtr> RouteSerializers;
-			RouteSerializers routeSerializers;
-
-			void requiredParameterNotFound(const char *, const std::string_view & key) const;
-
-			template <typename T, typename K>
-			inline T requiredParameterNotFound(const char * s, const K & key) const
-			{
-				requiredParameterNotFound(s, key);
-				// LCOV_EXCL_START unreachable, requiredParameterNotFound always throws
-				return T();
-				// LCOV_EXCL_STOP
-			}
-
-			void addRouteSerializer(const MimeType &, const StreamSerializerFactoryPtr &);
+	public:
+		const static RouteOptions defaultRouteOptions;
+
+		IRouteHandler(HttpMethod, const std::string_view & path);
+		IRouteHandler(HttpMethod, const std::string_view & path, const RouteOptions &);
+		SPECIAL_MEMBERS_MOVE_RO(IRouteHandler);
+		virtual ~IRouteHandler() = default;
+
+		virtual void execute(IHttpRequest * request) const = 0;
+		virtual ContentTypeSerializer getSerializer(const AcceptPtr &, std::ostream &) const;
+		virtual ContentTypeSerializer defaultSerializer(std::ostream &) const;
+
+		const HttpMethod method;
+
+	protected:
+		using StreamSerializerFactoryPtr = std::shared_ptr<Slicer::StreamSerializerFactory>;
+		using RouteSerializers = std::map<MimeType, StreamSerializerFactoryPtr>;
+		RouteSerializers routeSerializers;
+
+		void requiredParameterNotFound(const char *, const std::string_view & key) const;
+
+		template<typename T, typename K>
+		inline T
+		requiredParameterNotFound(const char * s, const K & key) const
+		{
+			requiredParameterNotFound(s, key);
+			// LCOV_EXCL_START unreachable, requiredParameterNotFound always throws
+			return T();
+			// LCOV_EXCL_STOP
+		}
+
+		void addRouteSerializer(const MimeType &, const StreamSerializerFactoryPtr &);
 	};
-	typedef std::shared_ptr<IRouteHandler> IRouteHandlerPtr;
-	typedef std::shared_ptr<const IRouteHandler> IRouteHandlerCPtr;
-	typedef AdHoc::Factory<IRouteHandler, const Core *> RouteHandlerFactory;
+	using IRouteHandlerPtr = std::shared_ptr<IRouteHandler>;
+	using IRouteHandlerCPtr = std::shared_ptr<const IRouteHandler>;
+	using RouteHandlerFactory = AdHoc::Factory<IRouteHandler, const Core *>;
 }
 
 #if __cplusplus < 201709
 namespace std {
-	template <typename T> using remove_cvref = typename std::remove_cv<typename std::remove_reference<T>::type>;
+	template<typename T> using remove_cvref = typename std::remove_cv<typename std::remove_reference<T>::type>;
 }
 #endif
 
 #endif
-
-
diff --git a/icespider/core/util.h b/icespider/core/util.h
index 0edc3d2..e320523 100644
--- a/icespider/core/util.h
+++ b/icespider/core/util.h
@@ -5,30 +5,37 @@
 #include <IceUtil/Optional.h>
 
 namespace std::experimental::Ice {
-	template <typename T, typename TF>
-	auto operator/(const Ice::optional<T> & o, const TF & tf) -> decltype(tf())
+	template<typename T, typename TF>
+	auto
+	operator/(const Ice::optional<T> & o, const TF & tf) -> decltype(tf())
 	{
-		if (o) return *o;
+		if (o) {
+			return *o;
+		}
 		return tf();
 	}
 }
 
 namespace std {
-	template <typename T, typename TF>
-	auto operator/(const std::optional<T> & o, const TF & tf) -> decltype(tf())
+	template<typename T, typename TF>
+	auto
+	operator/(const std::optional<T> & o, const TF & tf) -> decltype(tf())
 	{
-		if (o) return *o;
+		if (o) {
+			return *o;
+		}
 		return tf();
 	}
 }
 
-template <typename T>
-T orelse(const T & a, const T & b)
+template<typename T>
+T
+orelse(const T & a, const T & b)
 {
-	if (a) return a;
+	if (a) {
+		return a;
+	}
 	return b;
 }
 
-
 #endif
-
diff --git a/icespider/core/xwwwFormUrlEncoded.cpp b/icespider/core/xwwwFormUrlEncoded.cpp
index 3de39c3..6137d97 100644
--- a/icespider/core/xwwwFormUrlEncoded.cpp
+++ b/icespider/core/xwwwFormUrlEncoded.cpp
@@ -1,25 +1,24 @@
-#include "xwwwFormUrlEncoded.h"
 #include "exceptions.h"
-#include <boost/lexical_cast.hpp>
+#include "xwwwFormUrlEncoded.h"
 #include <Ice/BuiltinSequences.h>
 #include <array>
+#include <boost/lexical_cast.hpp>
 
 namespace ba = boost::algorithm;
 using namespace std::literals;
 
-constexpr std::array<char, 255> hextable = []()
-{
-    std::array<char, 255> hextable{};
-    for (int n = 0; n < 255; n++) {
-        hextable[n] = -1;
-    }
-    for (int n = '0'; n <= '9'; n++) {
-        hextable[n] = n - '0';
-    }
-    for (int n = 'a'; n <= 'f'; n++) {
-        hextable[n] = hextable[n - 32] = n - 'a' + 10;
-    }
-    return hextable;
+constexpr std::array<char, 255> hextable = []() {
+	std::array<char, 255> hextable {};
+	for (int n = 0; n < 255; n++) {
+		hextable[n] = -1;
+	}
+	for (int n = '0'; n <= '9'; n++) {
+		hextable[n] = n - '0';
+	}
+	for (int n = 'a'; n <= 'f'; n++) {
+		hextable[n] = hextable[n - 32] = n - 'a' + 10;
+	}
+	return hextable;
 }();
 
 static_assert(hextable['~'] == -1);
@@ -69,46 +68,45 @@ namespace IceSpider {
 	}
 
 	class SetFromString : public Slicer::ValueSource {
-		public:
-			explicit SetFromString(const std::string & v) : s(v)
-			{
+	public:
+		explicit SetFromString(const std::string & v) : s(v) { }
+
+		void
+		set(bool & t) const override
+		{
+			if (s == TRUE) {
+				t = true;
 			}
-
-			void set(bool & t) const override
-			{
-				if (s == TRUE) {
-					t = true;
-				}
-				else if (s == FALSE) {
-					t = false;
-				}
-				else {
-					throw Http400_BadRequest();
-				}
+			else if (s == FALSE) {
+				t = false;
 			}
-
-			void set(std::string & t) const override
-			{
-				t = s;
+			else {
+				throw Http400_BadRequest();
 			}
+		}
+
+		void
+		set(std::string & t) const override
+		{
+			t = s;
+		}
 
 #define SET(T) \
-			/* NOLINTNEXTLINE(bugprone-macro-parentheses) */ \
-			void set(T & t) const override \
-			{ \
-				t = boost::lexical_cast<T>(s); \
-			}
+	/* NOLINTNEXTLINE(bugprone-macro-parentheses) */ \
+	void set(T & t) const override \
+	{ \
+		t = boost::lexical_cast<T>(s); \
+	}
 
-			SET(Ice::Byte);
-			SET(Ice::Short);
-			SET(Ice::Int);
-			SET(Ice::Long);
-			SET(Ice::Float);
-			// NOLINTNEXTLINE(clang-analyzer-optin.cplusplus.VirtualCall)
-			SET(Ice::Double);
+		SET(Ice::Byte);
+		SET(Ice::Short);
+		SET(Ice::Int);
+		SET(Ice::Long);
+		SET(Ice::Float);
+		SET(Ice::Double);
 
-		private:
-			const std::string & s;
+	private:
+		const std::string & s;
 	};
 
 	std::string
@@ -117,9 +115,17 @@ namespace IceSpider {
 		return urlencode(s.begin(), s.end());
 	}
 
-	inline auto hexchar(int c) { return c < 10 ? '0' + c : 'a' - 10 + c; }
+	inline auto
+	hexchar(int c)
+	{
+		return c < 10 ? '0' + c : 'a' - 10 + c;
+	}
 	template<typename T>
-	inline char hexlookup(const T & i) { return hextable[(int)*i]; }
+	inline char
+	hexlookup(const T & i)
+	{
+		return hextable[(int)*i];
+	}
 
 	std::string
 	XWwwFormUrlEncoded::urlencode(std::string_view::const_iterator i, std::string_view::const_iterator e)
@@ -130,7 +136,8 @@ namespace IceSpider {
 	}
 
 	void
-	XWwwFormUrlEncoded::urlencodeto(std::ostream & o, std::string_view::const_iterator i, std::string_view::const_iterator e)
+	XWwwFormUrlEncoded::urlencodeto(
+			std::ostream & o, std::string_view::const_iterator i, std::string_view::const_iterator e)
 	{
 		while (i != e) {
 			if (*i == ' ') {
@@ -231,4 +238,3 @@ namespace IceSpider {
 }
 
 NAMEDFACTORY("application/x-www-form-urlencoded", IceSpider::XWwwFormUrlEncoded, Slicer::StreamDeserializerFactory);
-
diff --git a/icespider/core/xwwwFormUrlEncoded.h b/icespider/core/xwwwFormUrlEncoded.h
index d09b0c4..e0f8053 100644
--- a/icespider/core/xwwwFormUrlEncoded.h
+++ b/icespider/core/xwwwFormUrlEncoded.h
@@ -1,38 +1,40 @@
 #ifndef ICESPIDER_CGI_XWWWFORMURLENCODED_H
 #define ICESPIDER_CGI_XWWWFORMURLENCODED_H
 
-#include <visibility.h>
-#include <slicer/serializer.h>
 #include <boost/algorithm/string/split.hpp>
+#include <slicer/serializer.h>
+#include <visibility.h>
 
 namespace IceSpider {
 	class XWwwFormUrlEncoded : public Slicer::Deserializer {
-		public:
-			typedef std::function<void(std::string &&, std::string &&)> KVh;
+	public:
+		using KVh = std::function<void(std::string &&, std::string &&)>;
 
-			XWwwFormUrlEncoded(std::istream & in);
+		explicit XWwwFormUrlEncoded(std::istream & in);
 
-			void Deserialize(Slicer::ModelPartForRootPtr mp) override;
-			DLL_PUBLIC static void iterateVars(const std::string_view & input, const KVh & h, const std::string_view & split);
+		void Deserialize(Slicer::ModelPartForRootPtr mp) override;
+		DLL_PUBLIC static void iterateVars(
+				const std::string_view & input, const KVh & h, const std::string_view & split);
 
-			DLL_PUBLIC static std::string urldecode(std::string_view::const_iterator s, std::string_view::const_iterator);
-			DLL_PUBLIC static std::string urlencode(std::string_view::const_iterator s, std::string_view::const_iterator);
-			DLL_PUBLIC static void urlencodeto(std::ostream &, std::string_view::const_iterator s, std::string_view::const_iterator);
-			DLL_PUBLIC static std::string urlencode(const std::string_view & s);
+		DLL_PUBLIC static std::string urldecode(std::string_view::const_iterator s, std::string_view::const_iterator);
+		DLL_PUBLIC static std::string urlencode(std::string_view::const_iterator s, std::string_view::const_iterator);
+		DLL_PUBLIC static void urlencodeto(
+				std::ostream &, std::string_view::const_iterator s, std::string_view::const_iterator);
+		DLL_PUBLIC static std::string urlencode(const std::string_view & s);
 
-		private:
-			static inline void iterateVars(const KVh & h, boost::algorithm::split_iterator<std::string_view::const_iterator> pi);
+	private:
+		static inline void iterateVars(
+				const KVh & h, boost::algorithm::split_iterator<std::string_view::const_iterator> pi);
 
-			void iterateVars(const KVh & h);
+		void iterateVars(const KVh & h);
 
-			void DeserializeSimple(const Slicer::ModelPartPtr & mp);
-			void DeserializeComplex(const Slicer::ModelPartPtr & mp);
-			void DeserializeDictionary(const Slicer::ModelPartPtr & mp);
+		void DeserializeSimple(const Slicer::ModelPartPtr & mp);
+		void DeserializeComplex(const Slicer::ModelPartPtr & mp);
+		void DeserializeDictionary(const Slicer::ModelPartPtr & mp);
 
-			const std::string input;
+		const std::string input;
 	};
 
 };
 
 #endif
-
diff --git a/icespider/fcgi/cgiRequest.cpp b/icespider/fcgi/cgiRequest.cpp
index d0c4c83..2158956 100644
--- a/icespider/fcgi/cgiRequest.cpp
+++ b/icespider/fcgi/cgiRequest.cpp
@@ -1,8 +1,7 @@
 #include "cgiRequest.h"
 
 namespace IceSpider {
-	CgiRequest::CgiRequest(Core * c, int argc, char ** argv, char ** env) :
-		CgiRequestBase(c, env)
+	CgiRequest::CgiRequest(Core * c, int argc, char ** argv, char ** env) : CgiRequestBase(c, env)
 	{
 		for (; argc > 0;) {
 			addenv(argv[--argc]);
@@ -22,4 +21,3 @@ namespace IceSpider {
 		return std::cout;
 	}
 }
-
diff --git a/icespider/fcgi/cgiRequest.h b/icespider/fcgi/cgiRequest.h
index 1e48e98..c78f76e 100644
--- a/icespider/fcgi/cgiRequest.h
+++ b/icespider/fcgi/cgiRequest.h
@@ -5,13 +5,12 @@
 
 namespace IceSpider {
 	class CgiRequest : public CgiRequestBase {
-		public:
-			CgiRequest(Core * c, int argc, char ** argv, char ** env);
+	public:
+		CgiRequest(Core * c, int argc, char ** argv, char ** env);
 
-			std::istream & getInputStream() const override;
-			std::ostream & getOutputStream() const override;
+		std::istream & getInputStream() const override;
+		std::ostream & getOutputStream() const override;
 	};
 }
 
 #endif
-
diff --git a/icespider/fcgi/cgiRequestBase.cpp b/icespider/fcgi/cgiRequestBase.cpp
index 8e04c07..2b95abd 100644
--- a/icespider/fcgi/cgiRequestBase.cpp
+++ b/icespider/fcgi/cgiRequestBase.cpp
@@ -1,13 +1,13 @@
 #include "cgiRequestBase.h"
 #include "xwwwFormUrlEncoded.h"
 #include <boost/algorithm/string/case_conv.hpp>
-#include <boost/algorithm/string/split.hpp>
 #include <boost/algorithm/string/classification.hpp>
 #include <boost/algorithm/string/predicate.hpp>
-#include <util.h>
-#include <slicer/modelPartsTypes.h>
-#include <slicer/common.h>
+#include <boost/algorithm/string/split.hpp>
 #include <formatters.h>
+#include <slicer/common.h>
+#include <slicer/modelPartsTypes.h>
+#include <util.h>
 
 namespace ba = boost::algorithm;
 using namespace std::literals;
@@ -26,10 +26,9 @@ namespace IceSpider {
 	CGI_CONST(HTTP_COOKIE);
 	CGI_CONST(REQUEST_METHOD);
 
-	CgiRequestBase::CgiRequestBase(Core * c, const char * const * const env) :
-		IHttpRequest(c)
+	CgiRequestBase::CgiRequestBase(Core * c, const char * const * const env) : IHttpRequest(c)
 	{
-		for(const char * const * e = env; *e; ++e) {
+		for (const char * const * e = env; *e; ++e) {
 			addenv(*e);
 		}
 	}
@@ -38,25 +37,28 @@ namespace IceSpider {
 	CgiRequestBase::addenv(const char * const e)
 	{
 		if (auto eq = strchr(e, '=')) {
-			envmap.insert({ std::string_view(e, eq - e), eq + 1 });
+			envmap.insert({std::string_view(e, eq - e), eq + 1});
 		}
 	}
 
 	template<typename in, typename out>
-	inline
-	void
-	mapVars(const std::string_view & vn, const in & envmap, out & map, const std::string_view & sp) {
+	inline void
+	mapVars(const std::string_view & vn, const in & envmap, out & map, const std::string_view & sp)
+	{
 		auto qs = envmap.find(vn);
 		if (qs != envmap.end()) {
-			XWwwFormUrlEncoded::iterateVars(qs->second, [&map](auto && k, auto && v) {
-				map.emplace(std::move(k), std::move(v));
-			}, sp);
+			XWwwFormUrlEncoded::iterateVars(
+					qs->second,
+					[&map](auto && k, auto && v) {
+						map.emplace(std::forward<decltype(k)>(k), std::forward<decltype(v)>(v));
+					},
+					sp);
 		}
 	}
 
-	template<typename Ex, typename Map, typename ... Ks>
+	template<typename Ex, typename Map, typename... Ks>
 	const std::string_view &
-	findFirstOrElse(const Map & map, const std::string_view & k, const Ks & ... ks)
+	findFirstOrElse(const Map & map, const std::string_view & k, const Ks &... ks)
 	{
 		if (const auto i = map.find(k); i != map.end()) {
 			return i->second;
@@ -79,9 +81,8 @@ namespace IceSpider {
 		mapVars(QUERY_STRING, envmap, qsmap, amp);
 		mapVars(HTTP_COOKIE, envmap, cookiemap, semi);
 		for (auto header = envmap.lower_bound(HEADER_PREFIX);
-				header != envmap.end() && ba::starts_with(header->first, HEADER_PREFIX);
-				header++) {
-			hdrmap.insert({ header->first.substr(HEADER_PREFIX.length()), header->second });
+				header != envmap.end() && ba::starts_with(header->first, HEADER_PREFIX); header++) {
+			hdrmap.insert({header->first.substr(HEADER_PREFIX.length()), header->second});
 		}
 	}
 
@@ -178,7 +179,8 @@ namespace IceSpider {
 		return optionalLookup(key, hdrmap);
 	}
 
-	void CgiRequestBase::response(short statusCode, const std::string_view & statusMsg) const
+	void
+	CgiRequestBase::response(short statusCode, const std::string_view & statusMsg) const
 	{
 		StatusFmt::write(getOutputStream(), statusCode, statusMsg);
 	}
@@ -189,4 +191,3 @@ namespace IceSpider {
 		HdrFmt::write(getOutputStream(), header, value);
 	}
 }
-
diff --git a/icespider/fcgi/cgiRequestBase.h b/icespider/fcgi/cgiRequestBase.h
index f235acf..c0d6d81 100644
--- a/icespider/fcgi/cgiRequestBase.h
+++ b/icespider/fcgi/cgiRequestBase.h
@@ -8,40 +8,38 @@
 
 namespace IceSpider {
 	class CgiRequestBase : public IHttpRequest {
-		protected:
-			CgiRequestBase(Core * c, const char * const * const env);
-			void addenv(const char * const);
-			void initialize();
-
-		public:
-			typedef std::map<std::string_view, const std::string_view> VarMap;
-			typedef std::map<std::string_view, const std::string_view, Slicer::case_less> HdrMap;
-
-			const PathElements & getRequestPath() const override;
-			PathElements & getRequestPath() override;
-			HttpMethod getRequestMethod() const override;
-			OptionalString getQueryStringParam(const std::string_view & key) const override;
-			OptionalString getHeaderParam(const std::string_view & key) const override;
-			OptionalString getCookieParam(const std::string_view & key) const override;
-			OptionalString getEnv(const std::string_view & key) const override;
-			bool isSecure() const override;
-
-			void response(short, const std::string_view &) const override;
-			void setHeader(const std::string_view &, const std::string_view &) const override;
-
-			std::ostream & dump(std::ostream & s) const override;
-
-		private:
-			template<typename MapType>
-			static OptionalString optionalLookup(const std::string_view & key, const MapType &);
-
-			VarMap envmap;
-			StringMap qsmap;
-			StringMap cookiemap;
-			HdrMap hdrmap;
-			PathElements pathElements;
+	protected:
+		CgiRequestBase(Core * c, const char * const * const env);
+		void addenv(const char * const);
+		void initialize();
+
+	public:
+		using VarMap = std::map<std::string_view, const std::string_view>;
+		using HdrMap = std::map<std::string_view, const std::string_view, Slicer::case_less>;
+
+		[[nodiscard]] const PathElements & getRequestPath() const override;
+		[[nodiscard]] PathElements & getRequestPath() override;
+		[[nodiscard]] HttpMethod getRequestMethod() const override;
+		[[nodiscard]] OptionalString getQueryStringParam(const std::string_view & key) const override;
+		[[nodiscard]] OptionalString getHeaderParam(const std::string_view & key) const override;
+		[[nodiscard]] OptionalString getCookieParam(const std::string_view & key) const override;
+		[[nodiscard]] OptionalString getEnv(const std::string_view & key) const override;
+		[[nodiscard]] bool isSecure() const override;
+
+		void response(short, const std::string_view &) const override;
+		void setHeader(const std::string_view &, const std::string_view &) const override;
+
+		std::ostream & dump(std::ostream & s) const override;
+
+	private:
+		template<typename MapType> static OptionalString optionalLookup(const std::string_view & key, const MapType &);
+
+		VarMap envmap;
+		StringMap qsmap;
+		StringMap cookiemap;
+		HdrMap hdrmap;
+		PathElements pathElements;
 	};
 }
 
 #endif
-
diff --git a/icespider/fcgi/fcgiRequest.cpp b/icespider/fcgi/fcgiRequest.cpp
index 0d2ff75..5692c65 100644
--- a/icespider/fcgi/fcgiRequest.cpp
+++ b/icespider/fcgi/fcgiRequest.cpp
@@ -2,11 +2,7 @@
 
 namespace IceSpider {
 	FcgiRequest::FcgiRequest(Core * c, FCGX_Request * r) :
-		CgiRequestBase(c, r->envp),
-		inputbuf(r->in),
-		input(&inputbuf),
-		outputbuf(r->out),
-		output(&outputbuf)
+		CgiRequestBase(c, r->envp), inputbuf(r->in), input(&inputbuf), outputbuf(r->out), output(&outputbuf)
 	{
 		initialize();
 	}
@@ -23,4 +19,3 @@ namespace IceSpider {
 		return output;
 	}
 }
-
diff --git a/icespider/fcgi/fcgiRequest.h b/icespider/fcgi/fcgiRequest.h
index 0bc2e41..58ffc0a 100644
--- a/icespider/fcgi/fcgiRequest.h
+++ b/icespider/fcgi/fcgiRequest.h
@@ -6,18 +6,17 @@
 
 namespace IceSpider {
 	class FcgiRequest : public CgiRequestBase {
-		public:
-			FcgiRequest(Core * c, FCGX_Request * r);
+	public:
+		FcgiRequest(Core * c, FCGX_Request * r);
 
-			std::istream & getInputStream() const override;
-			std::ostream & getOutputStream() const override;
+		std::istream & getInputStream() const override;
+		std::ostream & getOutputStream() const override;
 
-			fcgi_streambuf inputbuf;
-			mutable std::istream input;
-			fcgi_streambuf outputbuf;
-			mutable std::ostream output;
+		fcgi_streambuf inputbuf;
+		mutable std::istream input;
+		fcgi_streambuf outputbuf;
+		mutable std::ostream output;
 	};
 }
 
 #endif
-
diff --git a/icespider/fcgi/main.cpp b/icespider/fcgi/main.cpp
index 7191310..8402501 100644
--- a/icespider/fcgi/main.cpp
+++ b/icespider/fcgi/main.cpp
@@ -1,7 +1,7 @@
-#include <visibility.h>
-#include "fcgiRequest.h"
 #include "cgiRequest.h"
 #include "core.h"
+#include "fcgiRequest.h"
+#include <visibility.h>
 
 using namespace IceSpider;
 
@@ -28,4 +28,3 @@ main(int argc, char ** argv, char ** env)
 	}
 	return 0;
 }
-
diff --git a/icespider/fileSessions/fileSessions.cpp b/icespider/fileSessions/fileSessions.cpp
index bee3f7c..2b1acbe 100644
--- a/icespider/fileSessions/fileSessions.cpp
+++ b/icespider/fileSessions/fileSessions.cpp
@@ -1,155 +1,162 @@
+#include "Ice/Initialize.h"
+#include <Ice/InputStream.h>
+#include <Ice/OutputStream.h>
+#include <boost/uuid/uuid_generators.hpp>
+#include <boost/uuid/uuid_io.hpp>
 #include <core.h>
-#include <session.h>
+#include <factory.impl.h>
 #include <fcntl.h>
 #include <fileUtils.h>
+#include <filesystem>
+#include <session.h>
 #include <sys.h>
 #include <sys/file.h>
-#include <sys/stat.h>
 #include <sys/mman.h>
-#include <factory.impl.h>
-#include <filesystem>
-#include <boost/uuid/uuid_generators.hpp>
-#include <boost/uuid/uuid_io.hpp>
-#include <Ice/OutputStream.h>
-#include <Ice/InputStream.h>
-#include "Ice/Initialize.h"
+#include <sys/stat.h>
 
 namespace IceSpider {
 	class FileSessions : public Plugin, public SessionManager {
-		public:
-			FileSessions(Ice::CommunicatorPtr c, const Ice::PropertiesPtr & p) :
-				ic(std::move(c)),
-				root(p->getProperty("IceSpider.FileSessions.Path")),
-				duration(p->getPropertyAsIntWithDefault("IceSpider.FileSessions.Duration", 3600))
-			{
-				if (!root.empty() && !std::filesystem::exists(root)) {
-					std::filesystem::create_directories(root);
-				}
+	public:
+		FileSessions(Ice::CommunicatorPtr c, const Ice::PropertiesPtr & p) :
+			ic(std::move(c)), root(p->getProperty("IceSpider.FileSessions.Path")),
+			duration(p->getPropertyAsIntWithDefault("IceSpider.FileSessions.Duration", 3600))
+		{
+			if (!root.empty() && !std::filesystem::exists(root)) {
+				std::filesystem::create_directories(root);
 			}
+		}
 
-			FileSessions(const FileSessions &) = delete;
-			FileSessions(FileSessions &&) = delete;
+		FileSessions(const FileSessions &) = delete;
+		FileSessions(FileSessions &&) = delete;
 
-			~FileSessions() override
-			{
-				try {
-					removeExpired();
-				}
-				catch (...) {
-					// Meh :)
-				}
+		~FileSessions() override
+		{
+			try {
+				removeExpired();
+			}
+			catch (...) {
+				// Meh :)
 			}
+		}
 
-			void operator=(const FileSessions &) = delete;
-			void operator=(FileSessions &&) = delete;
+		void operator=(const FileSessions &) = delete;
+		void operator=(FileSessions &&) = delete;
 
-			SessionPtr createSession(const ::Ice::Current &) override
-			{
-				auto s = std::make_shared<Session>();
-				// NOLINTNEXTLINE(clang-analyzer-optin.cplusplus.VirtualCall)
-				s->id = boost::lexical_cast<std::string>(boost::uuids::random_generator()());
-				s->duration = duration;
-				save(s);
-				return s;
-			}
+		SessionPtr
+		createSession(const ::Ice::Current &) override
+		{
+			auto s = std::make_shared<Session>();
+			// NOLINTNEXTLINE(clang-analyzer-optin.cplusplus.VirtualCall)
+			s->id = boost::lexical_cast<std::string>(boost::uuids::random_generator()());
+			s->duration = duration;
+			save(s);
+			return s;
+		}
 
-			SessionPtr getSession(const ::std::string id, const ::Ice::Current & current) override
-			{
-				auto s = load(id);
-				if (s && isExpired(s)) {
-					destroySession(id, current);
-					return nullptr;
-				}
-				return s;
+		SessionPtr
+		getSession(const ::std::string id, const ::Ice::Current & current) override
+		{
+			auto s = load(id);
+			if (s && isExpired(s)) {
+				destroySession(id, current);
+				return nullptr;
 			}
+			return s;
+		}
 
-			void updateSession(const SessionPtr s, const ::Ice::Current &) override
-			{
-				save(s);
-			}
+		void
+		updateSession(const SessionPtr s, const ::Ice::Current &) override
+		{
+			save(s);
+		}
 
-			void destroySession(const ::std::string id, const ::Ice::Current &) override
-			{
-				try {
-					std::filesystem::remove(root / id);
-				}
-				catch (const std::exception & e) {
-					throw SessionError(e.what());
-				}
+		void
+		destroySession(const ::std::string id, const ::Ice::Current &) override
+		{
+			try {
+				std::filesystem::remove(root / id);
 			}
+			catch (const std::exception & e) {
+				throw SessionError(e.what());
+			}
+		}
+
+	private:
+		void
+		save(const SessionPtr & s)
+		{
+			s->lastUsed = time(nullptr);
+			Ice::OutputStream buf(ic);
+			buf.write(s);
+			auto range = buf.finished();
+			// NOLINTNEXTLINE(hicpp-signed-bitwise)
+			AdHoc::FileUtils::FileHandle f(root / s->id, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);
+			sysassert(flock(f.fh, LOCK_EX), -1);
+			sysassert(pwrite(f.fh, range.first, range.second - range.first, 0), -1);
+			sysassert(ftruncate(f.fh, range.second - range.first), -1);
+			sysassert(flock(f.fh, LOCK_UN), -1);
+		}
 
-		private:
-			void save(const SessionPtr & s)
-			{
-				s->lastUsed = time(nullptr);
-				Ice::OutputStream buf(ic);
-				buf.write(s);
-				auto range = buf.finished();
-				// NOLINTNEXTLINE(hicpp-signed-bitwise)
-				AdHoc::FileUtils::FileHandle f(root / s->id, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);
-				sysassert(flock(f.fh, LOCK_EX), -1);
-				sysassert(pwrite(f.fh, range.first, range.second - range.first, 0), -1);
-				sysassert(ftruncate(f.fh, range.second - range.first), -1);
+		SessionPtr
+		load(const std::string & id)
+		{
+			auto path = root / id;
+			if (!std::filesystem::exists(path)) {
+				return nullptr;
+			}
+			try {
+				AdHoc::FileUtils::MemMap f(path);
+				sysassert(flock(f.fh, LOCK_SH), -1);
+				auto fbuf = (Ice::Byte *)f.data;
+				Ice::InputStream buf(ic, std::make_pair(fbuf, fbuf + f.getStat().st_size));
+				SessionPtr s;
+				buf.read(s);
 				sysassert(flock(f.fh, LOCK_UN), -1);
+				return s;
 			}
-
-			SessionPtr load(const std::string & id)
-			{
-				auto path = root / id;
-				if (!std::filesystem::exists(path)) {
+			catch (const AdHoc::SystemException & e) {
+				if (e.errNo == ENOENT) {
 					return nullptr;
 				}
-				try {
-					AdHoc::FileUtils::MemMap f(path);
-					sysassert(flock(f.fh, LOCK_SH), -1);
-					auto fbuf = (Ice::Byte *)f.data;
-					Ice::InputStream buf(ic, std::make_pair(fbuf, fbuf + f.getStat().st_size));
-					SessionPtr s;
-					buf.read(s);
-					sysassert(flock(f.fh, LOCK_UN), -1);
-					return s;
-				}
-				catch (const AdHoc::SystemException & e) {
-					if (e.errNo == ENOENT) {
-						return nullptr;
-					}
-					throw;
-				}
+				throw;
 			}
+		}
 
-			void removeExpired()
-			{
-				if (root.empty() || !std::filesystem::exists(root)) {
-					return;
-				}
-				std::filesystem::directory_iterator di(root);
-				while (di != std::filesystem::directory_iterator()) {
-					auto s = load(di->path());
-					if (s && isExpired(s)) {
-						FileSessions::destroySession(s->id, Ice::Current());
-					}
-					di++;
+		void
+		removeExpired()
+		{
+			if (root.empty() || !std::filesystem::exists(root)) {
+				return;
+			}
+			std::filesystem::directory_iterator di(root);
+			while (di != std::filesystem::directory_iterator()) {
+				auto s = load(di->path());
+				if (s && isExpired(s)) {
+					FileSessions::destroySession(s->id, Ice::Current());
 				}
+				di++;
 			}
+		}
 
-			bool isExpired(const SessionPtr & s)
-			{
-				return (s->lastUsed + s->duration < time(nullptr));
-			}
+		bool
+		isExpired(const SessionPtr & s)
+		{
+			return (s->lastUsed + s->duration < time(nullptr));
+		}
 
-			template<typename R, typename ER>
-			R sysassert(R rtn, ER ertn)
-			{
-				if (rtn == ertn) {
-					throw SessionError(strerror(errno));
-				}
-				return rtn;
+		template<typename R, typename ER>
+		R
+		sysassert(R rtn, ER ertn)
+		{
+			if (rtn == ertn) {
+				throw SessionError(strerror(errno));
 			}
+			return rtn;
+		}
 
-			Ice::CommunicatorPtr ic;
- 			const std::filesystem::path root;
-			const Ice::Int duration;
+		Ice::CommunicatorPtr ic;
+		const std::filesystem::path root;
+		const Ice::Int duration;
 	};
 }
 NAMEDFACTORY("IceSpider-FileSessions", IceSpider::FileSessions, IceSpider::PluginFactory);
-
diff --git a/icespider/testing/testRequest.cpp b/icespider/testing/testRequest.cpp
index fea77f2..c384b31 100644
--- a/icespider/testing/testRequest.cpp
+++ b/icespider/testing/testRequest.cpp
@@ -1,13 +1,11 @@
 #include "testRequest.h"
-#include <boost/algorithm/string/split.hpp>
 #include <boost/algorithm/string/classification.hpp>
+#include <boost/algorithm/string/split.hpp>
 #include <formatters.h>
 
 namespace IceSpider {
 	constexpr std::string_view slash("/");
-	TestRequest::TestRequest(const Core * c, HttpMethod m, const std::string_view & p) :
-		IHttpRequest(c),
-		method(m)
+	TestRequest::TestRequest(const Core * c, HttpMethod m, const std::string_view & p) : IHttpRequest(c), method(m)
 	{
 		namespace ba = boost::algorithm;
 		auto path = p.substr(1);
@@ -158,4 +156,3 @@ namespace IceSpider {
 		return responseHeaders;
 	}
 }
-
diff --git a/icespider/testing/testRequest.h b/icespider/testing/testRequest.h
index 31d3e4b..4d93197 100644
--- a/icespider/testing/testRequest.h
+++ b/icespider/testing/testRequest.h
@@ -6,48 +6,47 @@
 
 namespace IceSpider {
 	class DLL_PUBLIC TestRequest : public IHttpRequest {
-		public:
-			typedef std::map<std::string, std::string, std::less<>> MapVars;
-
-			TestRequest(const Core * c, HttpMethod m, const std::string_view & p);
-
-			const PathElements & getRequestPath() const override;
-			PathElements & getRequestPath() override;
-			HttpMethod getRequestMethod() const override;
-			OptionalString getEnv(const std::string_view & key) const override;
-			OptionalString getQueryStringParam(const std::string_view & key) const override;
-			OptionalString getCookieParam(const std::string_view & key) const override;
-			OptionalString getHeaderParam(const std::string_view & key) const override;
-			bool isSecure() const override;
-			void setQueryStringParam(const std::string_view &, const OptionalString &);
-			void setHeaderParam(const std::string_view &, const OptionalString &);
-			void setCookieParam(const std::string_view &, const OptionalString &);
-			void setEnv(const std::string_view &, const OptionalString &);
-			std::istream & getInputStream() const override;
-			std::ostream & getOutputStream() const override;
-			void response(short statusCode, const std::string_view & statusMsg) const override;
-			void setHeader(const std::string_view & header, const std::string_view & value) const override;
-			std::ostream & dump(std::ostream & s) const override;
-
-			const MapVars & getResponseHeaders();
-
-			PathElements url;
-			MapVars qs;
-			MapVars cookies;
-			MapVars hdr;
-			MapVars env;
-			mutable std::stringstream input;
-			mutable std::stringstream output;
-			const HttpMethod method;
-
-		protected:
-			OptionalString get(const std::string_view &, const MapVars &) const;
-			void set(const std::string_view &, const OptionalString &, MapVars &);
-
-		private:
-			MapVars responseHeaders;
+	public:
+		using MapVars = std::map<std::string, std::string, std::less<>>;
+
+		TestRequest(const Core * c, HttpMethod m, const std::string_view & p);
+
+		const PathElements & getRequestPath() const override;
+		PathElements & getRequestPath() override;
+		HttpMethod getRequestMethod() const override;
+		OptionalString getEnv(const std::string_view & key) const override;
+		OptionalString getQueryStringParam(const std::string_view & key) const override;
+		OptionalString getCookieParam(const std::string_view & key) const override;
+		OptionalString getHeaderParam(const std::string_view & key) const override;
+		bool isSecure() const override;
+		void setQueryStringParam(const std::string_view &, const OptionalString &);
+		void setHeaderParam(const std::string_view &, const OptionalString &);
+		void setCookieParam(const std::string_view &, const OptionalString &);
+		void setEnv(const std::string_view &, const OptionalString &);
+		std::istream & getInputStream() const override;
+		std::ostream & getOutputStream() const override;
+		void response(short statusCode, const std::string_view & statusMsg) const override;
+		void setHeader(const std::string_view & header, const std::string_view & value) const override;
+		std::ostream & dump(std::ostream & s) const override;
+
+		const MapVars & getResponseHeaders();
+
+		PathElements url;
+		MapVars qs;
+		MapVars cookies;
+		MapVars hdr;
+		MapVars env;
+		mutable std::stringstream input;
+		mutable std::stringstream output;
+		const HttpMethod method;
+
+	protected:
+		OptionalString get(const std::string_view &, const MapVars &) const;
+		void set(const std::string_view &, const OptionalString &, MapVars &);
+
+	private:
+		MapVars responseHeaders;
 	};
 }
 
 #endif
-
diff --git a/icespider/unittests/base2.cpp b/icespider/unittests/base2.cpp
index 4f6d8ef..a64d46b 100644
--- a/icespider/unittests/base2.cpp
+++ b/icespider/unittests/base2.cpp
@@ -1,13 +1,10 @@
 #include "base2.h"
 
 namespace common {
-	base2::base2(const IceSpider::Core *)
-	{
-	}
+	base2::base2(const IceSpider::Core *) { }
 
 	void
 	base2::testMutate(const IceSpider::IHttpRequest *, ::TestIceSpider::SomeModelPtr &) const
 	{
 	}
 }
-
diff --git a/icespider/unittests/base2.h b/icespider/unittests/base2.h
index d89cf85..d0ad75c 100644
--- a/icespider/unittests/base2.h
+++ b/icespider/unittests/base2.h
@@ -2,8 +2,8 @@
 #define ICESPIDER_TEST_BASE2_H
 
 // Standard headers.
-#include <irouteHandler.h>
 #include <core.h>
+#include <irouteHandler.h>
 
 // Interface headers.
 #include <test-api.h>
@@ -12,12 +12,11 @@ namespace common {
 	// Base classes.
 
 	class DLL_PUBLIC base2 {
-		protected:
-			base2(const IceSpider::Core * core);
+	protected:
+		explicit base2(const IceSpider::Core * core);
 
-			void testMutate(const IceSpider::IHttpRequest *, TestIceSpider::SomeModelPtr &) const;
+		void testMutate(const IceSpider::IHttpRequest *, TestIceSpider::SomeModelPtr &) const;
 	}; // base2
 } // namespace common
 
 #endif
-
diff --git a/icespider/unittests/string_view_support.h b/icespider/unittests/string_view_support.h
index ef9fb94..12d8077 100644
--- a/icespider/unittests/string_view_support.h
+++ b/icespider/unittests/string_view_support.h
@@ -1,32 +1,30 @@
 #ifndef ICETRAY_STRING_VIEW_SUPPORT_H
 #define ICETRAY_STRING_VIEW_SUPPORT_H
 
-#include <string_view>
 #include <Ice/OutputStream.h>
 #include <Ice/StreamHelpers.h>
+#include <string_view>
 
-namespace Ice
-{
-	template<>
-	struct StreamableTraits<std::string_view>
-	{
+namespace Ice {
+	template<> struct StreamableTraits<std::string_view> {
 		static const StreamHelperCategory helper = StreamHelperCategoryBuiltin;
 		static const int minWireSize = 1;
 		static const bool fixedLength = false;
 	};
 
-	template<>
-	struct StreamHelper<std::string_view, StreamHelperCategoryBuiltin> {
-		template<class S> static inline void
-		write(S * stream, const std::string_view& v)
+	template<> struct StreamHelper<std::string_view, StreamHelperCategoryBuiltin> {
+		template<class S>
+		static inline void
+		write(S * stream, const std::string_view & v)
 		{
 			stream->write(v.data(), v.size());
 		}
 
-		template<class S> static inline void
-		read(S * stream, std::string_view& v)
+		template<class S>
+		static inline void
+		read(S * stream, std::string_view & v)
 		{
-			const char* vdata = 0;
+			const char * vdata = nullptr;
 			size_t vsize = 0;
 
 			stream->read(vdata, vsize);
@@ -42,4 +40,3 @@ namespace Ice
 }
 
 #endif
-
diff --git a/icespider/unittests/test-api-impl.cpp b/icespider/unittests/test-api-impl.cpp
index 7d5b556..bcf32ed 100644
--- a/icespider/unittests/test-api-impl.cpp
+++ b/icespider/unittests/test-api-impl.cpp
@@ -5,4 +5,3 @@ TestIceSpider::Ex::ice_print(std::ostream & s) const
 {
 	s << message;
 }
-
diff --git a/icespider/unittests/testAccept.cpp b/icespider/unittests/testAccept.cpp
index 2cabe5e..cc08f0a 100644
--- a/icespider/unittests/testAccept.cpp
+++ b/icespider/unittests/testAccept.cpp
@@ -1,46 +1,48 @@
 #define BOOST_TEST_MODULE TestAccept
-#include <boost/test/included/unit_test.hpp>
 #include <boost/test/data/test_case.hpp>
+#include <boost/test/included/unit_test.hpp>
 
-#include <ihttpRequest.h>
 #include <exceptions.h>
+#include <ihttpRequest.h>
 
 auto parse = IceSpider::IHttpRequest::parseAccept;
 using namespace boost::unit_test::data;
 
 namespace std {
-	ostream & operator<<(ostream & s, const IceSpider::Accept & a)
+	ostream &
+	operator<<(ostream & s, const IceSpider::Accept & a)
 	{
-		s << (a.group ? *a.group : "*")
-			<< "/"
-			<< (a.type ? *a.type : "*")
-			<< ";q=" << a.q;
+		s << (a.group ? *a.group : "*") << "/" << (a.type ? *a.type : "*") << ";q=" << a.q;
 		return s;
 	}
 }
 
-BOOST_TEST_DECORATOR(* boost::unit_test::timeout(1))
-BOOST_DATA_TEST_CASE(bad_requests, make({
-	"", // Can't specify nothing
-	"  ", // This is still nothing
-	" group ",
-	" ; ",
-	" / ",
-	" ^ ",
-	" * / plain ",
-	" text / plain ; q = 0.0 ",
-	" text / plain ; q = 1.1 ",
-}), a)
+BOOST_TEST_DECORATOR(*boost::unit_test::timeout(1))
+BOOST_DATA_TEST_CASE(bad_requests,
+		make({
+				"", // Can't specify nothing
+				"  ", // This is still nothing
+				" group ",
+				" ; ",
+				" / ",
+				" ^ ",
+				" * / plain ",
+				" text / plain ; q = 0.0 ",
+				" text / plain ; q = 1.1 ",
+		}),
+		a)
 {
 	BOOST_CHECK_THROW(parse(a), IceSpider::Http400_BadRequest);
 }
 
-BOOST_DATA_TEST_CASE(texthtml, make({
-	"text/html",
-	"image/png;q=0.1, text/html",
-	"image/png;q=0.9, text/html;q=1.0",
-	"image/png;q=0.9, text/html;q=1.0, something/else;q=1.0",
-}), a)
+BOOST_DATA_TEST_CASE(texthtml,
+		make({
+				"text/html",
+				"image/png;q=0.1, text/html",
+				"image/png;q=0.9, text/html;q=1.0",
+				"image/png;q=0.9, text/html;q=1.0, something/else;q=1.0",
+		}),
+		a)
 {
 	auto front = parse(a).front();
 	BOOST_REQUIRE(front->group);
@@ -49,12 +51,14 @@ BOOST_DATA_TEST_CASE(texthtml, make({
 	BOOST_REQUIRE_EQUAL(*front->type, "html");
 }
 
-BOOST_DATA_TEST_CASE(textany, make({
-	"text/*",
-	"image/png;q=0.1, text/*",
-	"image/png;q=0.9, text/*;q=1.0",
-	"image/png;q=0.9, text/*;q=1.0, something/else;q=1.0",
-}), a)
+BOOST_DATA_TEST_CASE(textany,
+		make({
+				"text/*",
+				"image/png;q=0.1, text/*",
+				"image/png;q=0.9, text/*;q=1.0",
+				"image/png;q=0.9, text/*;q=1.0, something/else;q=1.0",
+		}),
+		a)
 {
 	auto front = parse(a).front();
 	BOOST_REQUIRE(front->group);
@@ -62,13 +66,15 @@ BOOST_DATA_TEST_CASE(textany, make({
 	BOOST_REQUIRE(!front->type);
 }
 
-BOOST_DATA_TEST_CASE(anyhtml, make({
-	"any/html",
-	"image/png;q=0.1, any/html",
-	"image/png;q=0.9, any/html;q=1.0",
-	"image/png;q=0.9, any/html;q=1.0, something/else;q=1.0",
-	" image / png ; q = 0.9 , any / html ; q = 1.0 , something / else ; q = 1.0",
-}), a)
+BOOST_DATA_TEST_CASE(anyhtml,
+		make({
+				"any/html",
+				"image/png;q=0.1, any/html",
+				"image/png;q=0.9, any/html;q=1.0",
+				"image/png;q=0.9, any/html;q=1.0, something/else;q=1.0",
+				" image / png ; q = 0.9 , any / html ; q = 1.0 , something / else ; q = 1.0",
+		}),
+		a)
 {
 	auto front = parse(a).front();
 	BOOST_REQUIRE(front->group);
@@ -76,29 +82,32 @@ BOOST_DATA_TEST_CASE(anyhtml, make({
 	BOOST_REQUIRE_EQUAL(*front->type, "html");
 }
 
-BOOST_DATA_TEST_CASE(anyany, make({
-	"*/*",
-	"image/png;q=0.1, */*",
-	"image/png;q=0.9, */*;q=1.0",
-	"image/png;q=0.9, */*;q=1.0, something/else;q=1.0",
-}), a)
+BOOST_DATA_TEST_CASE(anyany,
+		make({
+				"*/*",
+				"image/png;q=0.1, */*",
+				"image/png;q=0.9, */*;q=1.0",
+				"image/png;q=0.9, */*;q=1.0, something/else;q=1.0",
+		}),
+		a)
 {
 	auto front = parse(a).front();
 	BOOST_REQUIRE(!front->group);
 	BOOST_REQUIRE(!front->type);
 }
 
-BOOST_DATA_TEST_CASE(q1, make({
-	"*/*",
-	"image/png, */*",
-	"image/png;q=1.0, */*",
-}), a)
+BOOST_DATA_TEST_CASE(q1,
+		make({
+				"*/*",
+				"image/png, */*",
+				"image/png;q=1.0, */*",
+		}),
+		a)
 {
 	auto all = parse(a);
-	for(const auto & accept : all) {
+	for (const auto & accept : all) {
 		BOOST_TEST_CONTEXT(*accept) {
 			BOOST_CHECK_CLOSE(accept->q, 1.0, 0.1);
 		}
 	}
 }
-
diff --git a/icespider/unittests/testApp.cpp b/icespider/unittests/testApp.cpp
index cabcd0c..46fda40 100644
--- a/icespider/unittests/testApp.cpp
+++ b/icespider/unittests/testApp.cpp
@@ -1,88 +1,75 @@
 #define BOOST_TEST_MODULE TestApp
 #include <boost/test/unit_test.hpp>
 
-#include <safeMapFind.h>
-#include <irouteHandler.h>
-#include <core.h>
-#include <exceptions.h>
-#include <test-api.h>
-#include <Ice/ObjectAdapter.h>
 #include <Ice/Initialize.h>
-#include <boost/algorithm/string/split.hpp>
+#include <Ice/ObjectAdapter.h>
 #include <boost/algorithm/string/classification.hpp>
 #include <boost/algorithm/string/predicate.hpp>
-#include <filesystem>
+#include <boost/algorithm/string/split.hpp>
+#include <core.h>
 #include <definedDirs.h>
-#include <slicer/slicer.h>
-#include <xml/serializer.h>
+#include <exceptions.h>
+#include <factory.impl.h>
+#include <filesystem>
+#include <irouteHandler.h>
 #include <json/serializer.h>
 #include <libxml++/parsers/domparser.h>
-#include <factory.impl.h>
+#include <safeMapFind.h>
+#include <slicer/slicer.h>
+#include <test-api.h>
 #include <testRequest.h>
+#include <xml/serializer.h>
 
 using namespace IceSpider;
 
 static void forceEarlyChangeDir() __attribute__((constructor(101)));
-void forceEarlyChangeDir()
+void
+forceEarlyChangeDir()
 {
 	std::filesystem::current_path(XSTR(ROOT));
 }
 
-BOOST_AUTO_TEST_CASE( testLoadConfiguration )
+BOOST_AUTO_TEST_CASE(testLoadConfiguration)
 {
 	BOOST_REQUIRE_EQUAL(13, AdHoc::PluginManager::getDefault()->getAll<IceSpider::RouteHandlerFactory>().size());
 }
 
 class CoreWithProps : public CoreWithDefaultRouter {
-	public:
-		CoreWithProps() :
-			CoreWithDefaultRouter({
-				"--Custom.Prop=value"
-			})
-		{
-		}
+public:
+	CoreWithProps() : CoreWithDefaultRouter({"--Custom.Prop=value"}) { }
 };
 
 BOOST_FIXTURE_TEST_SUITE(props, CoreWithProps);
 
-BOOST_AUTO_TEST_CASE( properties )
+BOOST_AUTO_TEST_CASE(properties)
 {
-	BOOST_REQUIRE_EQUAL("Test",
-			this->communicator->getProperties()->getProperty("TestIceSpider.TestApi"));
-	BOOST_REQUIRE_EQUAL("value",
-			this->communicator->getProperties()->getProperty("Custom.Prop"));
+	BOOST_REQUIRE_EQUAL("Test", this->communicator->getProperties()->getProperty("TestIceSpider.TestApi"));
+	BOOST_REQUIRE_EQUAL("value", this->communicator->getProperties()->getProperty("Custom.Prop"));
 }
 
 BOOST_AUTO_TEST_SUITE_END();
 
 class CoreWithFileProps : public CoreWithDefaultRouter {
-	public:
-		CoreWithFileProps() :
-			CoreWithDefaultRouter({
-				"--IceSpider.Config=config/custom.properties",
-				"--Custom.Prop=value"
-			})
-		{
-		}
+public:
+	CoreWithFileProps() : CoreWithDefaultRouter({"--IceSpider.Config=config/custom.properties", "--Custom.Prop=value"})
+	{
+	}
 };
 
 BOOST_FIXTURE_TEST_SUITE(fileProps, CoreWithFileProps);
 
-BOOST_AUTO_TEST_CASE( properties )
+BOOST_AUTO_TEST_CASE(properties)
 {
-	BOOST_REQUIRE_EQUAL("",
-			this->communicator->getProperties()->getProperty("TestIceSpider.TestApi"));
-	BOOST_REQUIRE_EQUAL("something",
-			this->communicator->getProperties()->getProperty("InFile"));
-	BOOST_REQUIRE_EQUAL("value",
-			this->communicator->getProperties()->getProperty("Custom.Prop"));
+	BOOST_REQUIRE_EQUAL("", this->communicator->getProperties()->getProperty("TestIceSpider.TestApi"));
+	BOOST_REQUIRE_EQUAL("something", this->communicator->getProperties()->getProperty("InFile"));
+	BOOST_REQUIRE_EQUAL("value", this->communicator->getProperties()->getProperty("Custom.Prop"));
 }
 
 BOOST_AUTO_TEST_SUITE_END();
 
 BOOST_FIXTURE_TEST_SUITE(defaultProps, CoreWithDefaultRouter);
 
-BOOST_AUTO_TEST_CASE( testCoreSettings )
+BOOST_AUTO_TEST_CASE(testCoreSettings)
 {
 	BOOST_REQUIRE_EQUAL(5, routes.size());
 	BOOST_REQUIRE_EQUAL(1, routes[0].size());
@@ -92,7 +79,7 @@ BOOST_AUTO_TEST_CASE( testCoreSettings )
 	BOOST_REQUIRE_EQUAL(2, routes[4].size());
 }
 
-BOOST_AUTO_TEST_CASE( testFindRoutes )
+BOOST_AUTO_TEST_CASE(testFindRoutes)
 {
 	TestRequest requestGetIndex(this, HttpMethod::GET, "/");
 	BOOST_REQUIRE(findRoute(&requestGetIndex));
@@ -115,7 +102,8 @@ BOOST_AUTO_TEST_CASE( testFindRoutes )
 	TestRequest requestGetItemDefault(this, HttpMethod::GET, "/item/something");
 	BOOST_REQUIRE(findRoute(&requestGetItemDefault));
 
-	TestRequest requestGetItemLong(this, HttpMethod::GET, "/view/something/something/extra/many/things/longer/than/longest/route");
+	TestRequest requestGetItemLong(
+			this, HttpMethod::GET, "/view/something/something/extra/many/things/longer/than/longest/route");
 	BOOST_REQUIRE_THROW(findRoute(&requestGetItemLong), IceSpider::Http404_NotFound);
 
 	TestRequest requestGetItemShort(this, HttpMethod::GET, "/view/missingSomething");
@@ -137,96 +125,102 @@ BOOST_AUTO_TEST_CASE( testFindRoutes )
 BOOST_AUTO_TEST_SUITE_END();
 
 class TestSerice : public TestIceSpider::TestApi {
-	public:
-		TestIceSpider::SomeModelPtr index(const Ice::Current &) override
-		{
-			return std::make_shared<TestIceSpider::SomeModel>("index");
+public:
+	TestIceSpider::SomeModelPtr
+	index(const Ice::Current &) override
+	{
+		return std::make_shared<TestIceSpider::SomeModel>("index");
+	}
+
+	TestIceSpider::SomeModelPtr
+	withParams(const std::string s, Ice::Int i, const Ice::Current &) override
+	{
+		BOOST_REQUIRE_EQUAL(s, "something");
+		BOOST_REQUIRE_EQUAL(i, 1234);
+		return std::make_shared<TestIceSpider::SomeModel>("withParams");
+	}
+
+	void
+	returnNothing(const std::string_view s, const Ice::Current &) override
+	{
+		if (s == "error") {
+			throw TestIceSpider::Ex("test error");
 		}
-
-		TestIceSpider::SomeModelPtr withParams(const std::string s, Ice::Int i, const Ice::Current &) override
-		{
-			BOOST_REQUIRE_EQUAL(s, "something");
-			BOOST_REQUIRE_EQUAL(i, 1234);
-			return std::make_shared<TestIceSpider::SomeModel>("withParams");
-		}
-
-		void returnNothing(const std::string_view s, const Ice::Current &) override
-		{
-			if (s == "error") {
-				throw TestIceSpider::Ex("test error");
-			}
-			else if (s.length() == 3) {
-				throw TestIceSpider::Ex(std::string(s));
-			}
-			BOOST_REQUIRE_EQUAL(s, "some value");
-		}
-
-		void complexParam(const Ice::optional<std::string> s, const TestIceSpider::SomeModelPtr m, const Ice::Current &) override
-		{
-			BOOST_REQUIRE(s);
-			BOOST_REQUIRE_EQUAL("1234", *s);
-			BOOST_REQUIRE(m);
-			BOOST_REQUIRE_EQUAL("some value", m->value);
-		}
-
-		Ice::Int simple(const Ice::Current &) override
-		{
-			return 1;
-		}
-
-		std::string simplei(Ice::Int n, const Ice::Current &) override
-		{
-			return std::to_string(n);
+		else if (s.length() == 3) {
+			throw TestIceSpider::Ex(std::string(s));
 		}
+		BOOST_REQUIRE_EQUAL(s, "some value");
+	}
+
+	void
+	complexParam(const Ice::optional<std::string> s, const TestIceSpider::SomeModelPtr m, const Ice::Current &) override
+	{
+		BOOST_REQUIRE(s);
+		BOOST_REQUIRE_EQUAL("1234", *s);
+		BOOST_REQUIRE(m);
+		BOOST_REQUIRE_EQUAL("some value", m->value);
+	}
+
+	Ice::Int
+	simple(const Ice::Current &) override
+	{
+		return 1;
+	}
+
+	std::string
+	simplei(Ice::Int n, const Ice::Current &) override
+	{
+		return std::to_string(n);
+	}
 };
 
 // NOLINTNEXTLINE(hicpp-special-member-functions)
 class TestApp : public CoreWithDefaultRouter {
-	public:
-		TestApp() :
-			adp(communicator->createObjectAdapterWithEndpoints("test", "default"))
-		{
-			adp->activate();
-			adp->add(std::make_shared<TestSerice>(), Ice::stringToIdentity("Test"));
-		}
-
-		~TestApp() override
-		{
-			adp->deactivate();
-			adp->destroy();
-		}
-
-	private:
-		Ice::ObjectAdapterPtr adp;
+public:
+	TestApp() : adp(communicator->createObjectAdapterWithEndpoints("test", "default"))
+	{
+		adp->activate();
+		adp->add(std::make_shared<TestSerice>(), Ice::stringToIdentity("Test"));
+	}
+
+	~TestApp() override
+	{
+		adp->deactivate();
+		adp->destroy();
+	}
+
+private:
+	Ice::ObjectAdapterPtr adp;
 };
 
 class Dummy : public IceSpider::Plugin, TestIceSpider::DummyPlugin {
-	public:
-		Dummy(const Ice::CommunicatorPtr &, const Ice::PropertiesPtr &) { }
+public:
+	Dummy(const Ice::CommunicatorPtr &, const Ice::PropertiesPtr &) { }
 };
 NAMEDFACTORY("DummyPlugin", Dummy, IceSpider::PluginFactory);
 
 BOOST_FIXTURE_TEST_SUITE(ta, TestApp);
 
-BOOST_AUTO_TEST_CASE( plugins )
+BOOST_AUTO_TEST_CASE(plugins)
 {
 	auto prx = this->getProxy<TestIceSpider::DummyPlugin>();
 	BOOST_REQUIRE(prx);
 	prx->ice_ping();
 }
 
-BOOST_AUTO_TEST_CASE( testCallIndex )
+BOOST_AUTO_TEST_CASE(testCallIndex)
 {
 	TestRequest requestGetIndex(this, HttpMethod::GET, "/");
 	process(&requestGetIndex);
 	auto h = requestGetIndex.getResponseHeaders();
 	BOOST_REQUIRE_EQUAL(h["Status"], "200 OK");
 	BOOST_REQUIRE_EQUAL(h["Content-Type"], "application/json");
-	auto v = Slicer::DeserializeAny<Slicer::JsonStreamDeserializer, TestIceSpider::SomeModelPtr>(requestGetIndex.output);
+	auto v = Slicer::DeserializeAny<Slicer::JsonStreamDeserializer, TestIceSpider::SomeModelPtr>(
+			requestGetIndex.output);
 	BOOST_REQUIRE_EQUAL(v->value, "index");
 }
 
-BOOST_AUTO_TEST_CASE( testCallMashS )
+BOOST_AUTO_TEST_CASE(testCallMashS)
 {
 	TestRequest requestGetMashS(this, HttpMethod::GET, "/mashS/something/something/1234");
 	process(&requestGetMashS);
@@ -238,7 +232,7 @@ BOOST_AUTO_TEST_CASE( testCallMashS )
 	BOOST_REQUIRE_EQUAL(v.b->value, "withParams");
 }
 
-BOOST_AUTO_TEST_CASE( testCallMashC )
+BOOST_AUTO_TEST_CASE(testCallMashC)
 {
 	TestRequest requestGetMashC(this, HttpMethod::GET, "/mashC/something/something/1234");
 	process(&requestGetMashC);
@@ -250,7 +244,7 @@ BOOST_AUTO_TEST_CASE( testCallMashC )
 	BOOST_REQUIRE_EQUAL(v->b->value, "withParams");
 }
 
-BOOST_AUTO_TEST_CASE( testCallViewSomething1234 )
+BOOST_AUTO_TEST_CASE(testCallViewSomething1234)
 {
 	TestRequest requestGetItem(this, HttpMethod::GET, "/view/something/1234");
 	process(&requestGetItem);
@@ -261,29 +255,31 @@ BOOST_AUTO_TEST_CASE( testCallViewSomething1234 )
 	BOOST_REQUIRE_EQUAL(v->value, "withParams");
 }
 
-BOOST_AUTO_TEST_CASE( testCallViewSomething1234_ )
+BOOST_AUTO_TEST_CASE(testCallViewSomething1234_)
 {
 	TestRequest requestGetItemGiven(this, HttpMethod::GET, "/item/something/1234");
 	process(&requestGetItemGiven);
 	auto h = requestGetItemGiven.getResponseHeaders();
 	BOOST_REQUIRE_EQUAL(h["Status"], "200 OK");
 	BOOST_REQUIRE_EQUAL(h["Content-Type"], "application/json");
-	auto v = Slicer::DeserializeAny<Slicer::JsonStreamDeserializer, TestIceSpider::SomeModelPtr>(requestGetItemGiven.output);
+	auto v = Slicer::DeserializeAny<Slicer::JsonStreamDeserializer, TestIceSpider::SomeModelPtr>(
+			requestGetItemGiven.output);
 	BOOST_REQUIRE_EQUAL(v->value, "withParams");
 }
 
-BOOST_AUTO_TEST_CASE( testCallViewSomething )
+BOOST_AUTO_TEST_CASE(testCallViewSomething)
 {
 	TestRequest requestGetItemDefault(this, HttpMethod::GET, "/item/something");
 	process(&requestGetItemDefault);
 	auto h = requestGetItemDefault.getResponseHeaders();
 	BOOST_REQUIRE_EQUAL(h["Status"], "200 OK");
 	BOOST_REQUIRE_EQUAL(h["Content-Type"], "application/json");
-	auto v = Slicer::DeserializeAny<Slicer::JsonStreamDeserializer, TestIceSpider::SomeModelPtr>(requestGetItemDefault.output);
+	auto v = Slicer::DeserializeAny<Slicer::JsonStreamDeserializer, TestIceSpider::SomeModelPtr>(
+			requestGetItemDefault.output);
 	BOOST_REQUIRE_EQUAL(v->value, "withParams");
 }
 
-BOOST_AUTO_TEST_CASE( testCallDeleteSomeValue )
+BOOST_AUTO_TEST_CASE(testCallDeleteSomeValue)
 {
 	TestRequest requestDeleteItem(this, HttpMethod::DELETE, "/some value");
 	process(&requestDeleteItem);
@@ -293,7 +289,7 @@ BOOST_AUTO_TEST_CASE( testCallDeleteSomeValue )
 	BOOST_REQUIRE(requestDeleteItem.output.eof());
 }
 
-BOOST_AUTO_TEST_CASE( testCallPost1234 )
+BOOST_AUTO_TEST_CASE(testCallPost1234)
 {
 	TestRequest requestUpdateItem(this, HttpMethod::POST, "/1234");
 	requestUpdateItem.env["CONTENT_TYPE"] = "application/json";
@@ -305,7 +301,7 @@ BOOST_AUTO_TEST_CASE( testCallPost1234 )
 	BOOST_REQUIRE(requestUpdateItem.output.eof());
 }
 
-BOOST_AUTO_TEST_CASE( testCallPost1234NoContentType )
+BOOST_AUTO_TEST_CASE(testCallPost1234NoContentType)
 {
 	TestRequest requestUpdateItem(this, HttpMethod::POST, "/1234");
 	requestUpdateItem.input << R"({"value": "some value"})";
@@ -316,7 +312,7 @@ BOOST_AUTO_TEST_CASE( testCallPost1234NoContentType )
 	BOOST_REQUIRE(requestUpdateItem.output.eof());
 }
 
-BOOST_AUTO_TEST_CASE( testCallPost1234UnsupportedMediaType )
+BOOST_AUTO_TEST_CASE(testCallPost1234UnsupportedMediaType)
 {
 	TestRequest requestUpdateItem(this, HttpMethod::POST, "/1234");
 	requestUpdateItem.env["CONTENT_TYPE"] = "application/notathing";
@@ -328,7 +324,7 @@ BOOST_AUTO_TEST_CASE( testCallPost1234UnsupportedMediaType )
 	BOOST_REQUIRE(requestUpdateItem.output.eof());
 }
 
-BOOST_AUTO_TEST_CASE( testCallIndexAcceptJson )
+BOOST_AUTO_TEST_CASE(testCallIndexAcceptJson)
 {
 	TestRequest requestJson(this, HttpMethod::GET, "/");
 	requestJson.hdr["Accept"] = "application/json";
@@ -340,7 +336,7 @@ BOOST_AUTO_TEST_CASE( testCallIndexAcceptJson )
 	BOOST_REQUIRE_EQUAL(v->value, "index");
 }
 
-BOOST_AUTO_TEST_CASE( testCallIndexAcceptAny )
+BOOST_AUTO_TEST_CASE(testCallIndexAcceptAny)
 {
 	TestRequest requestAnyAny(this, HttpMethod::GET, "/");
 	requestAnyAny.hdr["Accept"] = "*/*";
@@ -351,7 +347,7 @@ BOOST_AUTO_TEST_CASE( testCallIndexAcceptAny )
 	BOOST_REQUIRE_EQUAL(v->value, "index");
 }
 
-BOOST_AUTO_TEST_CASE( testCallIndexAcceptApplicationAny )
+BOOST_AUTO_TEST_CASE(testCallIndexAcceptApplicationAny)
 {
 	TestRequest requestApplicationAny(this, HttpMethod::GET, "/");
 	requestApplicationAny.hdr["Accept"] = "application/*";
@@ -359,11 +355,12 @@ BOOST_AUTO_TEST_CASE( testCallIndexAcceptApplicationAny )
 	auto h = requestApplicationAny.getResponseHeaders();
 	BOOST_REQUIRE_EQUAL(h["Status"], "200 OK");
 	BOOST_REQUIRE(boost::algorithm::starts_with(h["Content-Type"], "application/"));
-	auto v = Slicer::DeserializeAny<Slicer::JsonStreamDeserializer, TestIceSpider::SomeModelPtr>(requestApplicationAny.output);
+	auto v = Slicer::DeserializeAny<Slicer::JsonStreamDeserializer, TestIceSpider::SomeModelPtr>(
+			requestApplicationAny.output);
 	BOOST_REQUIRE_EQUAL(v->value, "index");
 }
 
-BOOST_AUTO_TEST_CASE( testCallIndexAcceptXml )
+BOOST_AUTO_TEST_CASE(testCallIndexAcceptXml)
 {
 	TestRequest requestXml(this, HttpMethod::GET, "/");
 	requestXml.hdr["Accept"] = "application/xml";
@@ -375,7 +372,7 @@ BOOST_AUTO_TEST_CASE( testCallIndexAcceptXml )
 	BOOST_REQUIRE_EQUAL(v->value, "index");
 }
 
-BOOST_AUTO_TEST_CASE( testCallIndexAcceptTextHtml )
+BOOST_AUTO_TEST_CASE(testCallIndexAcceptTextHtml)
 {
 	TestRequest requestHtml(this, HttpMethod::GET, "/");
 	requestHtml.hdr["Accept"] = "text/html";
@@ -388,7 +385,7 @@ BOOST_AUTO_TEST_CASE( testCallIndexAcceptTextHtml )
 	BOOST_REQUIRE_EQUAL(d.get_document()->get_root_node()->get_name(), "html");
 }
 
-BOOST_AUTO_TEST_CASE( testCallViewSomethingAcceptHtml )
+BOOST_AUTO_TEST_CASE(testCallViewSomethingAcceptHtml)
 {
 	TestRequest requestHtml(this, HttpMethod::GET, "/view/something/1234");
 	requestHtml.hdr["Accept"] = "text/html";
@@ -399,7 +396,7 @@ BOOST_AUTO_TEST_CASE( testCallViewSomethingAcceptHtml )
 	BOOST_REQUIRE(requestHtml.output.eof());
 }
 
-BOOST_AUTO_TEST_CASE( testCallIndexAcceptNotSupported )
+BOOST_AUTO_TEST_CASE(testCallIndexAcceptNotSupported)
 {
 	TestRequest requestBadAccept(this, HttpMethod::GET, "/");
 	requestBadAccept.hdr["Accept"] = "not/supported";
@@ -410,7 +407,7 @@ BOOST_AUTO_TEST_CASE( testCallIndexAcceptNotSupported )
 	BOOST_REQUIRE(requestBadAccept.output.eof());
 }
 
-BOOST_AUTO_TEST_CASE( testCallIndexComplexAccept )
+BOOST_AUTO_TEST_CASE(testCallIndexComplexAccept)
 {
 	TestRequest requestChoice(this, HttpMethod::GET, "/");
 	requestChoice.hdr["Accept"] = "something/special ; q = 0.9, application/json ; q = 0.8, application/xml;q=1.0";
@@ -422,7 +419,7 @@ BOOST_AUTO_TEST_CASE( testCallIndexComplexAccept )
 	BOOST_REQUIRE_EQUAL(v->value, "index");
 }
 
-BOOST_AUTO_TEST_CASE( testCall404 )
+BOOST_AUTO_TEST_CASE(testCall404)
 {
 	TestRequest requestGetIndex(this, HttpMethod::GET, "/this/404");
 	process(&requestGetIndex);
@@ -432,7 +429,7 @@ BOOST_AUTO_TEST_CASE( testCall404 )
 	BOOST_REQUIRE(requestGetIndex.output.eof());
 }
 
-BOOST_AUTO_TEST_CASE( testCall405 )
+BOOST_AUTO_TEST_CASE(testCall405)
 {
 	TestRequest requestGetIndex(this, HttpMethod::GET, "/405");
 	process(&requestGetIndex);
@@ -442,7 +439,7 @@ BOOST_AUTO_TEST_CASE( testCall405 )
 	BOOST_REQUIRE(requestGetIndex.output.eof());
 }
 
-BOOST_AUTO_TEST_CASE( testCallSearch )
+BOOST_AUTO_TEST_CASE(testCallSearch)
 {
 	TestRequest request(this, HttpMethod::GET, "/search");
 	request.qs["s"] = "something";
@@ -453,7 +450,7 @@ BOOST_AUTO_TEST_CASE( testCallSearch )
 	Slicer::DeserializeAny<Slicer::JsonStreamDeserializer, TestIceSpider::SomeModelPtr>(request.output);
 }
 
-BOOST_AUTO_TEST_CASE( testCallSearchBadLexicalCast )
+BOOST_AUTO_TEST_CASE(testCallSearchBadLexicalCast)
 {
 	TestRequest request(this, HttpMethod::GET, "/search");
 	request.qs["s"] = "something";
@@ -465,7 +462,7 @@ BOOST_AUTO_TEST_CASE( testCallSearchBadLexicalCast )
 	BOOST_REQUIRE(request.output.eof());
 }
 
-BOOST_AUTO_TEST_CASE( testCallSearchMissingS )
+BOOST_AUTO_TEST_CASE(testCallSearchMissingS)
 {
 	TestRequest request(this, HttpMethod::GET, "/search");
 	request.qs["i"] = "1234";
@@ -476,7 +473,7 @@ BOOST_AUTO_TEST_CASE( testCallSearchMissingS )
 	BOOST_REQUIRE(request.output.eof());
 }
 
-BOOST_AUTO_TEST_CASE( testCallSearchMissingI )
+BOOST_AUTO_TEST_CASE(testCallSearchMissingI)
 {
 	TestRequest request(this, HttpMethod::GET, "/search");
 	request.qs["s"] = "something";
@@ -487,7 +484,7 @@ BOOST_AUTO_TEST_CASE( testCallSearchMissingI )
 	BOOST_REQUIRE(request.output.eof());
 }
 
-BOOST_AUTO_TEST_CASE( testCookies )
+BOOST_AUTO_TEST_CASE(testCookies)
 {
 	TestRequest request(this, HttpMethod::GET, "/cookies");
 	request.cookies["mycookievar"] = "something";
@@ -498,30 +495,30 @@ BOOST_AUTO_TEST_CASE( testCookies )
 }
 
 class DummyErrorHandler : public IceSpider::ErrorHandler {
-	public:
-		IceSpider::ErrorHandlerResult
-		handleError(IceSpider::IHttpRequest * request, const std::exception & ex) const override
-		{
-			if (const auto * tex = dynamic_cast<const TestIceSpider::Ex *>(&ex)) {
-				if (tex->message == "404") {
-					throw IceSpider::Http404_NotFound();
-				}
-				if (tex->message == "304") {
-					request->getRequestPath().front() = "some value";
-					return IceSpider::ErrorHandlerResult_Modified;
-				}
-				if (tex->message == "400") {
-					request->response(400, "Handled");
-					return IceSpider::ErrorHandlerResult_Handled;
-				}
+public:
+	IceSpider::ErrorHandlerResult
+	handleError(IceSpider::IHttpRequest * request, const std::exception & ex) const override
+	{
+		if (const auto * tex = dynamic_cast<const TestIceSpider::Ex *>(&ex)) {
+			if (tex->message == "404") {
+				throw IceSpider::Http404_NotFound();
+			}
+			if (tex->message == "304") {
+				request->getRequestPath().front() = "some value";
+				return IceSpider::ErrorHandlerResult_Modified;
+			}
+			if (tex->message == "400") {
+				request->response(400, "Handled");
+				return IceSpider::ErrorHandlerResult_Handled;
 			}
-			return IceSpider::ErrorHandlerResult_Unhandled;
 		}
+		return IceSpider::ErrorHandlerResult_Unhandled;
+	}
 };
 
 PLUGIN(DummyErrorHandler, IceSpider::ErrorHandler);
 
-BOOST_AUTO_TEST_CASE( testErrorHandler_Unhandled )
+BOOST_AUTO_TEST_CASE(testErrorHandler_Unhandled)
 {
 	TestRequest requestDeleteItem(this, HttpMethod::DELETE, "/error");
 	process(&requestDeleteItem);
@@ -533,7 +530,7 @@ BOOST_AUTO_TEST_CASE( testErrorHandler_Unhandled )
 	BOOST_REQUIRE_EQUAL(b, "Exception type: TestIceSpider::Ex\nDetail: test error\n");
 }
 
-BOOST_AUTO_TEST_CASE( testErrorHandler_Handled1 )
+BOOST_AUTO_TEST_CASE(testErrorHandler_Handled1)
 {
 	TestRequest requestDeleteItem(this, HttpMethod::DELETE, "/404");
 	process(&requestDeleteItem);
@@ -543,7 +540,7 @@ BOOST_AUTO_TEST_CASE( testErrorHandler_Handled1 )
 	BOOST_REQUIRE(requestDeleteItem.output.eof());
 }
 
-BOOST_AUTO_TEST_CASE( testErrorHandler_Handled2 )
+BOOST_AUTO_TEST_CASE(testErrorHandler_Handled2)
 {
 	TestRequest requestDeleteItem(this, HttpMethod::DELETE, "/400");
 	process(&requestDeleteItem);
@@ -553,7 +550,7 @@ BOOST_AUTO_TEST_CASE( testErrorHandler_Handled2 )
 	BOOST_REQUIRE(requestDeleteItem.output.eof());
 }
 
-BOOST_AUTO_TEST_CASE( testErrorHandler_Handled3 )
+BOOST_AUTO_TEST_CASE(testErrorHandler_Handled3)
 {
 	TestRequest requestDeleteItem(this, HttpMethod::DELETE, "/304");
 	process(&requestDeleteItem);
@@ -564,4 +561,3 @@ BOOST_AUTO_TEST_CASE( testErrorHandler_Handled3 )
 }
 
 BOOST_AUTO_TEST_SUITE_END();
-
diff --git a/icespider/unittests/testCompile.cpp b/icespider/unittests/testCompile.cpp
index 0135303..811de52 100644
--- a/icespider/unittests/testCompile.cpp
+++ b/icespider/unittests/testCompile.cpp
@@ -1,34 +1,34 @@
 #define BOOST_TEST_MODULE TestCompile
 #include <boost/test/unit_test.hpp>
 
-#include <definedDirs.h>
-#include <plugins.h>
-#include <dlfcn.h>
 #include "../compile/routeCompiler.h"
 #include "../core/irouteHandler.h"
 #include <boost/algorithm/string/join.hpp>
+#include <definedDirs.h>
+#include <dlfcn.h>
+#include <plugins.h>
 #include <slicer/modelPartsTypes.h>
 
 using namespace IceSpider;
 
 static void forceEarlyChangeDir() __attribute__((constructor(101)));
-void forceEarlyChangeDir()
+void
+forceEarlyChangeDir()
 {
 	std::filesystem::current_path(XSTR(ROOT));
 }
 
 class CoreFixture {
-	protected:
-		CoreFixture() :
-			modeDir(binDir.lexically_relative(rootDir / "bin" / "testCompile.test"))
-		{
-		}
-		// NOLINTNEXTLINE(misc-non-private-member-variables-in-classes)
-		const std::filesystem::path modeDir;
+protected:
+	CoreFixture() : modeDir(binDir.lexically_relative(rootDir / "bin" / "testCompile.test")) { }
+	// NOLINTNEXTLINE(misc-non-private-member-variables-in-classes)
+	const std::filesystem::path modeDir;
 };
 
 namespace std {
-	ostream & operator<<(ostream & s, const IceSpider::HttpMethod & m) {
+	ostream &
+	operator<<(ostream & s, const IceSpider::HttpMethod & m)
+	{
 		s << Slicer::ModelPartForEnum<IceSpider::HttpMethod>::lookup(m);
 		return s;
 	}
@@ -36,7 +36,7 @@ namespace std {
 
 BOOST_FIXTURE_TEST_SUITE(cf, CoreFixture)
 
-BOOST_AUTO_TEST_CASE( testLoadConfiguration )
+BOOST_AUTO_TEST_CASE(testLoadConfiguration)
 {
 	Compile::RouteCompiler rc;
 	rc.searchPath.push_back(rootDir);
@@ -71,7 +71,7 @@ BOOST_AUTO_TEST_CASE( testLoadConfiguration )
 	BOOST_REQUIRE_EQUAL("test-api.ice", cfg->slices[0]);
 }
 
-BOOST_AUTO_TEST_CASE( testRouteCompile )
+BOOST_AUTO_TEST_CASE(testRouteCompile)
 {
 	auto input = rootDir / "testRoutes.json";
 	auto outputc = binDir / "testRoutes.cpp";
@@ -82,4 +82,3 @@ BOOST_AUTO_TEST_CASE( testRouteCompile )
 }
 
 BOOST_AUTO_TEST_SUITE_END();
-
diff --git a/icespider/unittests/testFcgi.cpp b/icespider/unittests/testFcgi.cpp
index d8c1b0f..789e6fa 100644
--- a/icespider/unittests/testFcgi.cpp
+++ b/icespider/unittests/testFcgi.cpp
@@ -1,16 +1,18 @@
 #define BOOST_TEST_MODULE TestApp
 #include <boost/test/unit_test.hpp>
 
+#include <cgiRequestBase.h>
 #include <core.h>
 #include <definedDirs.h>
-#include <cgiRequestBase.h>
-#include <test-fcgi.h>
 #include <slicer/modelPartsTypes.h>
+#include <test-fcgi.h>
 
 using namespace std::literals;
 namespace std {
 	template<typename T>
-	ostream & operator<<(ostream & s, const std::optional<T> & o) {
+	ostream &
+	operator<<(ostream & s, const std::optional<T> & o)
+	{
 		if (o) {
 			s << *o;
 		}
@@ -19,89 +21,90 @@ namespace std {
 }
 
 namespace std {
-	ostream & operator<<(ostream & s, const IceSpider::HttpMethod & m) {
+	ostream &
+	operator<<(ostream & s, const IceSpider::HttpMethod & m)
+	{
 		s << Slicer::ModelPartForEnum<IceSpider::HttpMethod>::lookup(m);
 		return s;
 	}
 }
 
-
 class TestRequest : public IceSpider::CgiRequestBase {
-	public:
-		TestRequest(IceSpider::Core * c, char ** env) : IceSpider::CgiRequestBase(c, env)
-		{
-			initialize();
-		}
+public:
+	TestRequest(IceSpider::Core * c, char ** env) : IceSpider::CgiRequestBase(c, env)
+	{
+		initialize();
+	}
 
-		std::ostream & getOutputStream() const override
-		{
-			return out;
-		}
+	std::ostream &
+	getOutputStream() const override
+	{
+		return out;
+	}
 
-		// LCOV_EXCL_START we never actually read or write anything here
-		std::istream & getInputStream() const override
-		{
-			return std::cin;
-		}
-		// LCOV_EXCL_STOP
+	// LCOV_EXCL_START we never actually read or write anything here
+	std::istream &
+	getInputStream() const override
+	{
+		return std::cin;
+	}
+	// LCOV_EXCL_STOP
 
-		// NOLINTNEXTLINE(misc-non-private-member-variables-in-classes)
-		mutable std::stringstream out;
+	// NOLINTNEXTLINE(misc-non-private-member-variables-in-classes)
+	mutable std::stringstream out;
 };
 
 class TestPayloadRequest : public TestRequest {
-	public:
-		TestPayloadRequest(IceSpider::Core * c, char ** env, std::istream & s) :
-			TestRequest(c, env),
-			in(s)
-		{
-			initialize();
-		}
+public:
+	TestPayloadRequest(IceSpider::Core * c, char ** env, std::istream & s) : TestRequest(c, env), in(s)
+	{
+		initialize();
+	}
 
-		std::istream & getInputStream() const override
-		{
-			return in;
-		}
+	std::istream &
+	getInputStream() const override
+	{
+		return in;
+	}
 
-	private:
-		std::istream & in;
+private:
+	std::istream & in;
 };
 
 // NOLINTNEXTLINE(hicpp-special-member-functions)
 class CharPtrPtrArray : public std::vector<char *> {
-	public:
-		CharPtrPtrArray()
-		{
-			push_back(nullptr);
-		}
+public:
+	CharPtrPtrArray()
+	{
+		push_back(nullptr);
+	}
 
-		explicit CharPtrPtrArray(const std::vector<std::string> & a)
-		{
-			for (const auto & e : a) {
-				push_back(strdup(e.c_str()));
-			}
-			push_back(nullptr);
+	explicit CharPtrPtrArray(const std::vector<std::string> & a)
+	{
+		for (const auto & e : a) {
+			push_back(strdup(e.c_str()));
 		}
+		push_back(nullptr);
+	}
 
-		~CharPtrPtrArray()
-		{
-			for (const auto & e : *this) {
-				// NOLINTNEXTLINE(hicpp-no-malloc)
-				free(e);
-			}
+	~CharPtrPtrArray()
+	{
+		for (const auto & e : *this) {
+			// NOLINTNEXTLINE(hicpp-no-malloc)
+			free(e);
 		}
+	}
 
-		// NOLINTNEXTLINE(hicpp-explicit-conversions)
-		operator char **()
-		{
-			return &front();
-		}
+	// NOLINTNEXTLINE(hicpp-explicit-conversions)
+	operator char * *()
+	{
+		return &front();
+	}
 };
 
 namespace std {
 	// LCOV_EXCL_START assert failure helper only
-	static
-	std::ostream &
+	static std::ostream &
 	operator<<(std::ostream & s, const IceSpider::PathElements & pe)
 	{
 		for (const auto & e : pe) {
@@ -112,73 +115,75 @@ namespace std {
 	// LCOV_EXCL_STOP
 }
 
-BOOST_FIXTURE_TEST_SUITE( CgiRequestBase, IceSpider::CoreWithDefaultRouter );
+BOOST_FIXTURE_TEST_SUITE(CgiRequestBase, IceSpider::CoreWithDefaultRouter);
 
-BOOST_AUTO_TEST_CASE( NoEnvironment )
+BOOST_AUTO_TEST_CASE(NoEnvironment)
 {
-	BOOST_REQUIRE_THROW({
-		CharPtrPtrArray env;
-		TestRequest r(this, env);
-	}, IceSpider::Http400_BadRequest);
+	BOOST_REQUIRE_THROW(
+			{
+				CharPtrPtrArray env;
+				TestRequest r(this, env);
+			},
+			IceSpider::Http400_BadRequest);
 }
 
-BOOST_AUTO_TEST_CASE( script_name_root )
+BOOST_AUTO_TEST_CASE(script_name_root)
 {
-	CharPtrPtrArray env ({ "SCRIPT_NAME=/" });
+	CharPtrPtrArray env({"SCRIPT_NAME=/"});
 	TestRequest r(this, env);
 	BOOST_REQUIRE(r.getRequestPath().empty());
 	BOOST_CHECK(!r.isSecure());
 }
 
-BOOST_AUTO_TEST_CASE( script_name_root_https )
+BOOST_AUTO_TEST_CASE(script_name_root_https)
 {
-	CharPtrPtrArray env ({ "SCRIPT_NAME=/", "HTTPS=on" });
+	CharPtrPtrArray env({"SCRIPT_NAME=/", "HTTPS=on"});
 	TestRequest r(this, env);
 	BOOST_REQUIRE(r.getRequestPath().empty());
 	BOOST_CHECK(r.isSecure());
 }
 
-BOOST_AUTO_TEST_CASE( redirect_uri_root )
+BOOST_AUTO_TEST_CASE(redirect_uri_root)
 {
-	CharPtrPtrArray env ({ "REDIRECT_URL=/" });
+	CharPtrPtrArray env({"REDIRECT_URL=/"});
 	TestRequest r(this, env);
 	BOOST_REQUIRE(r.getRequestPath().empty());
 }
 
-BOOST_AUTO_TEST_CASE( script_name_foobar )
+BOOST_AUTO_TEST_CASE(script_name_foobar)
 {
-	CharPtrPtrArray env ({ "SCRIPT_NAME=/foo/bar" });
+	CharPtrPtrArray env({"SCRIPT_NAME=/foo/bar"});
 	TestRequest r(this, env);
 	BOOST_REQUIRE_EQUAL(IceSpider::PathElements({"foo", "bar"}), r.getRequestPath());
 }
 
-BOOST_AUTO_TEST_CASE( query_string_empty )
+BOOST_AUTO_TEST_CASE(query_string_empty)
 {
-	CharPtrPtrArray env ({ "SCRIPT_NAME=/foo/bar", "QUERY_STRING=" });
+	CharPtrPtrArray env({"SCRIPT_NAME=/foo/bar", "QUERY_STRING="});
 	TestRequest r(this, env);
 	BOOST_REQUIRE(!r.getQueryStringParam(""));
 }
 
-BOOST_AUTO_TEST_CASE( query_string_one )
+BOOST_AUTO_TEST_CASE(query_string_one)
 {
-	CharPtrPtrArray env ({ "SCRIPT_NAME=/foo/bar", "QUERY_STRING=one=1" });
+	CharPtrPtrArray env({"SCRIPT_NAME=/foo/bar", "QUERY_STRING=one=1"});
 	TestRequest r(this, env);
 	BOOST_REQUIRE(!r.getQueryStringParam(""));
 	BOOST_REQUIRE_EQUAL("1", *r.getQueryStringParam("one"));
 }
 
-BOOST_AUTO_TEST_CASE( query_string_two )
+BOOST_AUTO_TEST_CASE(query_string_two)
 {
-	CharPtrPtrArray env ({ "SCRIPT_NAME=/foo/bar", "QUERY_STRING=one=1&two=2" });
+	CharPtrPtrArray env({"SCRIPT_NAME=/foo/bar", "QUERY_STRING=one=1&two=2"});
 	TestRequest r(this, env);
 	BOOST_REQUIRE(!r.getQueryStringParam(""));
 	BOOST_REQUIRE_EQUAL("1", *r.getQueryStringParam("one"));
 	BOOST_REQUIRE_EQUAL("2", *r.getQueryStringParam("two"));
 }
 
-BOOST_AUTO_TEST_CASE( query_string_three )
+BOOST_AUTO_TEST_CASE(query_string_three)
 {
-	CharPtrPtrArray env ({ "SCRIPT_NAME=/foo/bar", "QUERY_STRING=one=1&two=2&three=3" });
+	CharPtrPtrArray env({"SCRIPT_NAME=/foo/bar", "QUERY_STRING=one=1&two=2&three=3"});
 	TestRequest r(this, env);
 	BOOST_REQUIRE(!r.getQueryStringParam(""));
 	BOOST_REQUIRE_EQUAL("1", *r.getQueryStringParam("one"));
@@ -186,18 +191,18 @@ BOOST_AUTO_TEST_CASE( query_string_three )
 	BOOST_REQUIRE_EQUAL("3", *r.getQueryStringParam("three"));
 }
 
-BOOST_AUTO_TEST_CASE( query_string_urlencoding )
+BOOST_AUTO_TEST_CASE(query_string_urlencoding)
 {
-	CharPtrPtrArray env ({ "SCRIPT_NAME=/foo/bar", "QUERY_STRING=url+%65ncoded=%53tring%2e" });
+	CharPtrPtrArray env({"SCRIPT_NAME=/foo/bar", "QUERY_STRING=url+%65ncoded=%53tring%2e"});
 	TestRequest r(this, env);
 	BOOST_REQUIRE(!r.getQueryStringParam(""));
 	BOOST_REQUIRE(r.getQueryStringParam("url encoded"));
 	BOOST_REQUIRE_EQUAL("String.", *r.getQueryStringParam("url encoded"));
 }
 
-BOOST_AUTO_TEST_CASE( query_string_three_emptyVal )
+BOOST_AUTO_TEST_CASE(query_string_three_emptyVal)
 {
-	CharPtrPtrArray env ({ "SCRIPT_NAME=/foo/bar", "QUERY_STRING=one=1&two=&three=3" });
+	CharPtrPtrArray env({"SCRIPT_NAME=/foo/bar", "QUERY_STRING=one=1&two=&three=3"});
 	TestRequest r(this, env);
 	BOOST_REQUIRE(!r.getQueryStringParam(""));
 	BOOST_REQUIRE_EQUAL("1", *r.getQueryStringParam("one"));
@@ -205,9 +210,9 @@ BOOST_AUTO_TEST_CASE( query_string_three_emptyVal )
 	BOOST_REQUIRE_EQUAL("3", *r.getQueryStringParam("three"));
 }
 
-BOOST_AUTO_TEST_CASE( query_string_three_noVal )
+BOOST_AUTO_TEST_CASE(query_string_three_noVal)
 {
-	CharPtrPtrArray env ({ "SCRIPT_NAME=/foo/bar", "QUERY_STRING=one=1&two&three=3" });
+	CharPtrPtrArray env({"SCRIPT_NAME=/foo/bar", "QUERY_STRING=one=1&two&three=3"});
 	TestRequest r(this, env);
 	BOOST_REQUIRE(!r.getQueryStringParam(""));
 	BOOST_REQUIRE_EQUAL("1", *r.getQueryStringParam("one"));
@@ -215,109 +220,112 @@ BOOST_AUTO_TEST_CASE( query_string_three_noVal )
 	BOOST_REQUIRE_EQUAL("3", *r.getQueryStringParam("three"));
 }
 
-BOOST_AUTO_TEST_CASE( requestmethod_get )
+BOOST_AUTO_TEST_CASE(requestmethod_get)
 {
-	CharPtrPtrArray env ({ "SCRIPT_NAME=/", "REQUEST_METHOD=GET" });
+	CharPtrPtrArray env({"SCRIPT_NAME=/", "REQUEST_METHOD=GET"});
 	TestRequest r(this, env);
 	BOOST_REQUIRE_EQUAL(IceSpider::HttpMethod::GET, r.getRequestMethod());
 }
 
-BOOST_AUTO_TEST_CASE( requestmethod_post )
+BOOST_AUTO_TEST_CASE(requestmethod_post)
 {
-	CharPtrPtrArray env ({ "SCRIPT_NAME=/", "REQUEST_METHOD=POST" });
+	CharPtrPtrArray env({"SCRIPT_NAME=/", "REQUEST_METHOD=POST"});
 	TestRequest r(this, env);
 	BOOST_REQUIRE_EQUAL(IceSpider::HttpMethod::POST, r.getRequestMethod());
 }
 
-BOOST_AUTO_TEST_CASE( requestmethod_bad )
+BOOST_AUTO_TEST_CASE(requestmethod_bad)
 {
-	CharPtrPtrArray env ({ "SCRIPT_NAME=/", "REQUEST_METHOD=No" });
+	CharPtrPtrArray env({"SCRIPT_NAME=/", "REQUEST_METHOD=No"});
 	TestRequest r(this, env);
-	BOOST_REQUIRE_THROW(r.getRequestMethod(), IceSpider::Http405_MethodNotAllowed);
+	BOOST_REQUIRE_THROW((void)r.getRequestMethod(), IceSpider::Http405_MethodNotAllowed);
 }
 
-BOOST_AUTO_TEST_CASE( requestmethod_missing )
+BOOST_AUTO_TEST_CASE(requestmethod_missing)
 {
-	CharPtrPtrArray env ({ "SCRIPT_NAME=/" });
+	CharPtrPtrArray env({"SCRIPT_NAME=/"});
 	TestRequest r(this, env);
-	BOOST_REQUIRE_THROW(r.getRequestMethod(), IceSpider::Http400_BadRequest);
+	BOOST_REQUIRE_THROW((void)r.getRequestMethod(), IceSpider::Http400_BadRequest);
 }
 
-BOOST_AUTO_TEST_CASE( acceptheader )
+BOOST_AUTO_TEST_CASE(acceptheader)
 {
-	CharPtrPtrArray env ({ "SCRIPT_NAME=/", "HTTP_ACCEPT=text/html" });
+	CharPtrPtrArray env({"SCRIPT_NAME=/", "HTTP_ACCEPT=text/html"});
 	TestRequest r(this, env);
 	BOOST_REQUIRE_EQUAL("text/html", *r.getHeaderParam("ACCEPT"));
 	BOOST_REQUIRE_EQUAL("text/html", *r.getHeaderParam(IceSpider::H::ACCEPT));
 }
 
-BOOST_AUTO_TEST_CASE( missingheader )
+BOOST_AUTO_TEST_CASE(missingheader)
 {
-	CharPtrPtrArray env ({ "SCRIPT_NAME=/", "HTTP_ACCEPT=text/html" });
+	CharPtrPtrArray env({"SCRIPT_NAME=/", "HTTP_ACCEPT=text/html"});
 	TestRequest r(this, env);
 	BOOST_REQUIRE(!r.getHeaderParam("ACCEPT_LANGUAGE"));
 }
 
-BOOST_AUTO_TEST_CASE( postxwwwformurlencoded_simple )
+BOOST_AUTO_TEST_CASE(postxwwwformurlencoded_simple)
 {
-	CharPtrPtrArray env ({ "SCRIPT_NAME=/", "REQUEST_METHOD=No", "CONTENT_TYPE=application/x-www-form-urlencoded" });
+	CharPtrPtrArray env({"SCRIPT_NAME=/", "REQUEST_METHOD=No", "CONTENT_TYPE=application/x-www-form-urlencoded"});
 	std::stringstream f("value=314");
 	TestPayloadRequest r(this, env, f);
 	auto n = r.getBody<int>();
 	BOOST_REQUIRE_EQUAL(314, n);
 }
 
-BOOST_AUTO_TEST_CASE( reqParsePerf )
+BOOST_AUTO_TEST_CASE(reqParsePerf)
 {
-	CharPtrPtrArray env ({
-		"CONTEXT_DOCUMENT_ROOT=/var/www/shared/vhosts/sys.randomdan.homeip.net",
-		"CONTEXT_PREFIX=",
-		"DOCUMENT_ROOT=/var/www/shared/vhosts/sys.randomdan.homeip.net",
-		"GATEWAY_INTERFACE=CGI/1.1",
-		"H2PUSH=on",
-		"H2_PUSH=on",
-		"H2_PUSHED=",
-		"H2_PUSHED_ON=",
-		"H2_STREAM_ID=1",
-		"H2_STREAM_TAG=137-1",
-		"HTTP2=on",
-		"HTTPS=on",
-		"HTTP_ACCEPT=text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3",
-		"HTTP_ACCEPT_ENCODING=gzip, deflate, br",
-		"HTTP_ACCEPT_LANGUAGE=en,en-GB;q=0.9",
-		"HTTP_HOST=sys.randomdan.homeip.net",
-		"HTTP_SEC_FETCH_SITE=none",
-		"HTTP_UPGRADE_INSECURE_REQUESTS=1",
-		"HTTP_USER_AGENT=Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36",
-		"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
-		"PWD=/var/www/shared/files/localhost",
-		"QUERY_STRING=",
-		"REMOTE_ADDR=10.10.0.189",
-		"REMOTE_PORT=44030",
-		"REQUEST_METHOD=GET",
-		"REQUEST_SCHEME=https",
-		"REQUEST_URI=/env.cgi",
-		"SCRIPT_FILENAME=/var/www/shared/vhosts/sys.randomdan.homeip.net/env.cgi",
-		"SCRIPT_NAME=/env.cgi",
-		"SERVER_ADDR=fdc7:602:e9c5:b8f0::3",
-		"SERVER_ADMIN=dan.goodliffe@randomdan.homeip.net",
-		"SERVER_NAME=sys.randomdan.homeip.net",
-		"SERVER_PORT=443",
-		"SERVER_PROTOCOL=HTTP/2.0",
-		"SERVER_SIGNATURE=<address>Apache/2.4.41 (Gentoo) mod_fcgid/2.3.9 PHP/7.2.23 OpenSSL/1.1.1d mod_perl/2.0.10 Perl/v5.30.0 Server at sys.randomdan.homeip.net Port 443</address>",
-		"SERVER_SOFTWARE=Apache/2.4.41 (Gentoo) mod_fcgid/2.3.9 PHP/7.2.23 OpenSSL/1.1.1d mod_perl/2.0.10 Perl/v5.30.0",
-		"SHLVL=0",
-		"SSL_TLS_SNI=sys.randomdan.homeip.net",
+	CharPtrPtrArray env({
+			"CONTEXT_DOCUMENT_ROOT=/var/www/shared/vhosts/sys.randomdan.homeip.net",
+			"CONTEXT_PREFIX=",
+			"DOCUMENT_ROOT=/var/www/shared/vhosts/sys.randomdan.homeip.net",
+			"GATEWAY_INTERFACE=CGI/1.1",
+			"H2PUSH=on",
+			"H2_PUSH=on",
+			"H2_PUSHED=",
+			"H2_PUSHED_ON=",
+			"H2_STREAM_ID=1",
+			"H2_STREAM_TAG=137-1",
+			"HTTP2=on",
+			"HTTPS=on",
+			("HTTP_ACCEPT=text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/"
+			 "*;q=0.8,application/signed-exchange;v=b3"),
+			"HTTP_ACCEPT_ENCODING=gzip, deflate, br",
+			"HTTP_ACCEPT_LANGUAGE=en,en-GB;q=0.9",
+			"HTTP_HOST=sys.randomdan.homeip.net",
+			"HTTP_SEC_FETCH_SITE=none",
+			"HTTP_UPGRADE_INSECURE_REQUESTS=1",
+			("HTTP_USER_AGENT=Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) "
+			 "Chrome/77.0.3865.90 Safari/537.36"),
+			"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
+			"PWD=/var/www/shared/files/localhost",
+			"QUERY_STRING=",
+			"REMOTE_ADDR=10.10.0.189",
+			"REMOTE_PORT=44030",
+			"REQUEST_METHOD=GET",
+			"REQUEST_SCHEME=https",
+			"REQUEST_URI=/env.cgi",
+			"SCRIPT_FILENAME=/var/www/shared/vhosts/sys.randomdan.homeip.net/env.cgi",
+			"SCRIPT_NAME=/env.cgi",
+			"SERVER_ADDR=fdc7:602:e9c5:b8f0::3",
+			"SERVER_ADMIN=dan.goodliffe@randomdan.homeip.net",
+			"SERVER_NAME=sys.randomdan.homeip.net",
+			"SERVER_PORT=443",
+			"SERVER_PROTOCOL=HTTP/2.0",
+			("SERVER_SIGNATURE=<address>Apache/2.4.41 (Gentoo) mod_fcgid/2.3.9 PHP/7.2.23 OpenSSL/1.1.1d "
+			 "mod_perl/2.0.10 Perl/v5.30.0 Server at sys.randomdan.homeip.net Port 443</address>"),
+			("SERVER_SOFTWARE=Apache/2.4.41 (Gentoo) mod_fcgid/2.3.9 PHP/7.2.23 OpenSSL/1.1.1d mod_perl/2.0.10 "
+			 "Perl/v5.30.0"),
+			"SHLVL=0",
+			"SSL_TLS_SNI=sys.randomdan.homeip.net",
 	});
-	for (int x = 0; x < 10000; x +=1) {
+	for (int x = 0; x < 10000; x += 1) {
 		TestRequest req(this, env);
 	}
 }
 
-
-BOOST_AUTO_TEST_CASE( postxwwwformurlencoded_dictionary )
+BOOST_AUTO_TEST_CASE(postxwwwformurlencoded_dictionary)
 {
-	CharPtrPtrArray env ({ "SCRIPT_NAME=/", "REQUEST_METHOD=No", "CONTENT_TYPE=application/x-www-form-urlencoded" });
+	CharPtrPtrArray env({"SCRIPT_NAME=/", "REQUEST_METHOD=No", "CONTENT_TYPE=application/x-www-form-urlencoded"});
 	std::stringstream f("alpha=abcde&number=3.14&boolean=true&spaces=This+is+a%20string.&empty=");
 	TestPayloadRequest r(this, env, f);
 	auto n = *r.getBody<IceSpider::StringMap>();
@@ -329,9 +337,9 @@ BOOST_AUTO_TEST_CASE( postxwwwformurlencoded_dictionary )
 	BOOST_REQUIRE_EQUAL("", n["empty"]);
 }
 
-BOOST_AUTO_TEST_CASE( postxwwwformurlencoded_complex )
+BOOST_AUTO_TEST_CASE(postxwwwformurlencoded_complex)
 {
-	CharPtrPtrArray env ({ "SCRIPT_NAME=/", "REQUEST_METHOD=No", "CONTENT_TYPE=application/x-www-form-urlencoded" });
+	CharPtrPtrArray env({"SCRIPT_NAME=/", "REQUEST_METHOD=No", "CONTENT_TYPE=application/x-www-form-urlencoded"});
 	std::stringstream f("alpha=abcde&number=3.14&boolean=true&empty=&spaces=This+is+a%20string.");
 	TestPayloadRequest r(this, env, f);
 	auto n = *r.getBody<TestFcgi::ComplexPtr>();
@@ -342,9 +350,9 @@ BOOST_AUTO_TEST_CASE( postxwwwformurlencoded_complex )
 	BOOST_REQUIRE_EQUAL("", n->empty);
 }
 
-BOOST_AUTO_TEST_CASE( postjson_complex )
+BOOST_AUTO_TEST_CASE(postjson_complex)
 {
-	CharPtrPtrArray env ({ "SCRIPT_NAME=/", "REQUEST_METHOD=No", "CONTENT_TYPE=application/json" });
+	CharPtrPtrArray env({"SCRIPT_NAME=/", "REQUEST_METHOD=No", "CONTENT_TYPE=application/json"});
 	std::stringstream f(R"J({"alpha":"abcde","number":3.14,"boolean":true,"empty":"","spaces":"This is a string."})J");
 	TestPayloadRequest r(this, env, f);
 	auto n = *r.getBody<TestFcgi::ComplexPtr>();
@@ -355,10 +363,11 @@ BOOST_AUTO_TEST_CASE( postjson_complex )
 	BOOST_REQUIRE_EQUAL("", n->empty);
 }
 
-BOOST_AUTO_TEST_CASE( postjson_dictionary )
+BOOST_AUTO_TEST_CASE(postjson_dictionary)
 {
-	CharPtrPtrArray env ({ "SCRIPT_NAME=/", "REQUEST_METHOD=No", "CONTENT_TYPE=application/json" });
-	std::stringstream f(R"J({"alpha":"abcde","number":"3.14","boolean":"true","empty":"","spaces":"This is a string."})J");
+	CharPtrPtrArray env({"SCRIPT_NAME=/", "REQUEST_METHOD=No", "CONTENT_TYPE=application/json"});
+	std::stringstream f(
+			R"J({"alpha":"abcde","number":"3.14","boolean":"true","empty":"","spaces":"This is a string."})J");
 	TestPayloadRequest r(this, env, f);
 	auto n = *r.getBody<IceSpider::StringMap>();
 	BOOST_REQUIRE_EQUAL(5, n.size());
@@ -369,24 +378,26 @@ BOOST_AUTO_TEST_CASE( postjson_dictionary )
 	BOOST_REQUIRE_EQUAL("", n["empty"]);
 }
 
-BOOST_AUTO_TEST_CASE( cookies )
+BOOST_AUTO_TEST_CASE(cookies)
 {
-	CharPtrPtrArray env ({ "SCRIPT_NAME=/", "REQUEST_METHOD=No", "CONTENT_TYPE=application/json", "HTTP_COOKIE=valueA=1234; value+B=Something+with+spaces." });
+	CharPtrPtrArray env({"SCRIPT_NAME=/", "REQUEST_METHOD=No", "CONTENT_TYPE=application/json",
+			"HTTP_COOKIE=valueA=1234; value+B=Something+with+spaces."});
 	TestRequest r(this, env);
 	BOOST_REQUIRE_EQUAL(1234, *r.IceSpider::IHttpRequest::getCookieParam<Ice::Int>("valueA"));
 	BOOST_REQUIRE_EQUAL("Something with spaces.", *r.IceSpider::IHttpRequest::getCookieParam<std::string>("value B"));
 	BOOST_REQUIRE(!r.IceSpider::IHttpRequest::getCookieParam<Ice::Int>("notAThing"));
 	r.setCookie("some int.", 1234, "www.com"s, "/dir"s, true, 1476142378);
-	BOOST_REQUIRE_EQUAL("Set-Cookie: some+int%2e=1234; expires=Mon, 10 Oct 2016 23:32:58 GMT; domain=www.com; path=/dir; secure; samesite=strict\r\n", r.out.str());
+	BOOST_REQUIRE_EQUAL("Set-Cookie: some+int%2e=1234; expires=Mon, 10 Oct 2016 23:32:58 GMT; domain=www.com; "
+						"path=/dir; secure; samesite=strict\r\n",
+			r.out.str());
 }
 
-BOOST_AUTO_TEST_CASE( response )
+BOOST_AUTO_TEST_CASE(response)
 {
-	CharPtrPtrArray env ({ "SCRIPT_NAME=/" });
+	CharPtrPtrArray env({"SCRIPT_NAME=/"});
 	TestRequest r(this, env);
 	r.response(200, "OK");
 	BOOST_REQUIRE_EQUAL("Status: 200 OK\r\n\r\n", r.out.str());
 }
 
 BOOST_AUTO_TEST_SUITE_END();
-
diff --git a/icespider/unittests/testFileSessions.cpp b/icespider/unittests/testFileSessions.cpp
index 1ab75f7..3712d03 100644
--- a/icespider/unittests/testFileSessions.cpp
+++ b/icespider/unittests/testFileSessions.cpp
@@ -3,28 +3,26 @@
 
 #include <Ice/Initialize.h>
 #include <Ice/Properties.h>
-#include <session.h>
 #include <core.h>
 #include <definedDirs.h>
+#include <session.h>
 
 BOOST_TEST_DONT_PRINT_LOG_VALUE(IceSpider::Variables);
 
 class TestCore : public IceSpider::CoreWithDefaultRouter {
-	public:
-		TestCore() :
-			IceSpider::CoreWithDefaultRouter({
-				"--IceSpider.SessionManager=IceSpider-FileSessions",
+public:
+	TestCore() :
+		IceSpider::CoreWithDefaultRouter({"--IceSpider.SessionManager=IceSpider-FileSessions",
 				"--IceSpider.FileSessions.Path=" + (binDir / "test-sessions").string(),
-				"--IceSpider.FileSessions.Duration=0"
-			}),
-			root(communicator->getProperties()->getProperty("IceSpider.FileSessions.Path"))
-		{
-		}
-		// NOLINTNEXTLINE(misc-non-private-member-variables-in-classes)
-		const std::filesystem::path root;
+				"--IceSpider.FileSessions.Duration=0"}),
+		root(communicator->getProperties()->getProperty("IceSpider.FileSessions.Path"))
+	{
+	}
+	// NOLINTNEXTLINE(misc-non-private-member-variables-in-classes)
+	const std::filesystem::path root;
 };
 
-BOOST_AUTO_TEST_CASE( clear )
+BOOST_AUTO_TEST_CASE(clear)
 {
 	TestCore tc;
 	if (std::filesystem::exists(tc.root)) {
@@ -34,14 +32,14 @@ BOOST_AUTO_TEST_CASE( clear )
 
 BOOST_FIXTURE_TEST_SUITE(Core, TestCore);
 
-BOOST_AUTO_TEST_CASE( ping )
+BOOST_AUTO_TEST_CASE(ping)
 {
 	auto prx = this->getProxy<IceSpider::SessionManager>();
 	BOOST_REQUIRE(prx);
 	prx->ice_ping();
 }
 
-BOOST_AUTO_TEST_CASE( createAndDestroy )
+BOOST_AUTO_TEST_CASE(createAndDestroy)
 {
 	auto prx = this->getProxy<IceSpider::SessionManager>();
 	auto s = prx->createSession();
@@ -52,7 +50,7 @@ BOOST_AUTO_TEST_CASE( createAndDestroy )
 	BOOST_REQUIRE(!std::filesystem::exists(root / s->id));
 }
 
-BOOST_AUTO_TEST_CASE( createAndChangeRestore )
+BOOST_AUTO_TEST_CASE(createAndChangeRestore)
 {
 	auto prx = this->getProxy<IceSpider::SessionManager>();
 	auto s = prx->createSession();
@@ -66,7 +64,7 @@ BOOST_AUTO_TEST_CASE( createAndChangeRestore )
 	prx->destroySession(s->id);
 }
 
-BOOST_AUTO_TEST_CASE( createAndExpire )
+BOOST_AUTO_TEST_CASE(createAndExpire)
 {
 	auto prx = this->getProxy<IceSpider::SessionManager>();
 	auto s = prx->createSession();
@@ -79,35 +77,34 @@ BOOST_AUTO_TEST_CASE( createAndExpire )
 	BOOST_REQUIRE(!std::filesystem::exists(root / s->id));
 }
 
-BOOST_AUTO_TEST_CASE( missing )
+BOOST_AUTO_TEST_CASE(missing)
 {
 	auto prx = this->getProxy<IceSpider::SessionManager>();
 	BOOST_REQUIRE(!prx->getSession("missing"));
 	BOOST_REQUIRE(!std::filesystem::exists(root / "missing"));
 }
 
-BOOST_AUTO_TEST_CASE( createAndLeave )
+BOOST_AUTO_TEST_CASE(createAndLeave)
 {
 	auto prx = this->getProxy<IceSpider::SessionManager>();
 	auto s = prx->createSession();
 	BOOST_REQUIRE(std::filesystem::exists(root / s->id));
 }
 
-BOOST_AUTO_TEST_CASE( left )
+BOOST_AUTO_TEST_CASE(left)
 {
 	BOOST_REQUIRE(!std::filesystem::is_empty(root));
 }
 
-BOOST_AUTO_TEST_CASE( expire )
+BOOST_AUTO_TEST_CASE(expire)
 {
 	usleep(1001000);
 }
 
 BOOST_AUTO_TEST_SUITE_END();
 
-BOOST_AUTO_TEST_CASE( empty )
+BOOST_AUTO_TEST_CASE(empty)
 {
 	TestCore tc;
 	BOOST_REQUIRE(std::filesystem::is_empty(tc.root));
 }
-
diff --git a/icespider/xslt/exslt.cpp b/icespider/xslt/exslt.cpp
index 772ef5e..186c77a 100644
--- a/icespider/xslt/exslt.cpp
+++ b/icespider/xslt/exslt.cpp
@@ -2,7 +2,8 @@
 #include <libxslt/transform.h>
 
 static void initLibXml() __attribute__((constructor(102)));
-void initLibXml()
+void
+initLibXml()
 {
 	xmlInitParser();
 	exsltRegisterAll();
@@ -10,10 +11,10 @@ void initLibXml()
 
 // LCOV_EXCL_START lcov actually misses destructor functions
 static void cleanupLibXml() __attribute__((destructor(102)));
-void cleanupLibXml()
+void
+cleanupLibXml()
 {
 	xsltCleanupGlobals();
 	xmlCleanupParser();
 }
 // LCOV_EXCL_STOP
-
diff --git a/icespider/xslt/xsltStreamSerializer.cpp b/icespider/xslt/xsltStreamSerializer.cpp
index d798835..b6dc44c 100644
--- a/icespider/xslt/xsltStreamSerializer.cpp
+++ b/icespider/xslt/xsltStreamSerializer.cpp
@@ -1,26 +1,26 @@
 #include "xsltStreamSerializer.h"
-#include <libxslt/xsltInternals.h>
-#include <libxml/HTMLtree.h>
 #include <factory.impl.h>
 #include <filesystem>
+#include <libxml/HTMLtree.h>
+#include <libxslt/xsltInternals.h>
 
 namespace IceSpider {
-	static int xmlstrmclosecallback(void * context)
+	static int
+	xmlstrmclosecallback(void * context)
 	{
-		((std::ostream*)context)->flush();
+		((std::ostream *)context)->flush();
 		return 0;
 	}
 
-	static int xmlstrmwritecallback(void * context, const char * buffer, int len)
+	static int
+	xmlstrmwritecallback(void * context, const char * buffer, int len)
 	{
-		((std::ostream*)context)->write(buffer, len);
+		((std::ostream *)context)->write(buffer, len);
 		return len;
 	}
 
 	XsltStreamSerializer::IceSpiderFactory::IceSpiderFactory(const char * path) :
-		stylesheetPath(path),
-		stylesheetWriteTime(std::filesystem::file_time_type::min()),
-		stylesheet(nullptr)
+		stylesheetPath(path), stylesheetWriteTime(std::filesystem::file_time_type::min()), stylesheet(nullptr)
 	{
 	}
 
@@ -47,10 +47,7 @@ namespace IceSpider {
 	}
 
 	XsltStreamSerializer::XsltStreamSerializer(std::ostream & os, xsltStylesheet * ss) :
-		Slicer::XmlDocumentSerializer(doc),
-		strm(os),
-		doc(nullptr),
-		stylesheet(ss)
+		Slicer::XmlDocumentSerializer(doc), strm(os), doc(nullptr), stylesheet(ss)
 	{
 	}
 
@@ -69,13 +66,12 @@ namespace IceSpider {
 		}
 		xmlOutputBufferPtr buf = xmlOutputBufferCreateIO(xmlstrmwritecallback, xmlstrmclosecallback, &strm, nullptr);
 		if (xmlStrcmp(stylesheet->method, BAD_CAST "html") == 0) {
-			htmlDocContentDumpFormatOutput(buf, result, (const char *) stylesheet->encoding, 0);
+			htmlDocContentDumpFormatOutput(buf, result, (const char *)stylesheet->encoding, 0);
 		}
 		else {
-			xmlNodeDumpOutput(buf, result, result->children, 0, 0, (const char *) stylesheet->encoding);
+			xmlNodeDumpOutput(buf, result, result->children, 0, 0, (const char *)stylesheet->encoding);
 		}
 		xmlOutputBufferClose(buf);
 		xmlFreeDoc(result);
 	}
 }
-
diff --git a/icespider/xslt/xsltStreamSerializer.h b/icespider/xslt/xsltStreamSerializer.h
index dae6ac3..a21f424 100644
--- a/icespider/xslt/xsltStreamSerializer.h
+++ b/icespider/xslt/xsltStreamSerializer.h
@@ -1,38 +1,40 @@
 #ifndef ICESPIDER_CORE_XSLTSTREAMSERIALIZER_H
 #define ICESPIDER_CORE_XSLTSTREAMSERIALIZER_H
 
+#include <c++11Helpers.h>
+#include <filesystem>
+#include <libxslt/transform.h>
 #include <slicer/xml/serializer.h>
 #include <visibility.h>
-#include <libxslt/transform.h>
-#include <filesystem>
 
 namespace IceSpider {
 	class DLL_PUBLIC XsltStreamSerializer : public Slicer::XmlDocumentSerializer {
+	public:
+		class IceSpiderFactory : public Slicer::StreamSerializerFactory {
 		public:
-			class IceSpiderFactory : public Slicer::StreamSerializerFactory {
-				public:
-					IceSpiderFactory(const char *);
-					~IceSpiderFactory();
+			explicit IceSpiderFactory(const char *);
+			SPECIAL_MEMBERS_MOVE_RO(IceSpiderFactory);
+			~IceSpiderFactory() override;
 
-					Slicer::SerializerPtr create(std::ostream &) const override;
+			Slicer::SerializerPtr create(std::ostream &) const override;
 
-				private:
-					const std::filesystem::path stylesheetPath;
-					mutable std::filesystem::file_time_type stylesheetWriteTime;
-					mutable xsltStylesheet * stylesheet;
-			};
+		private:
+			const std::filesystem::path stylesheetPath;
+			mutable std::filesystem::file_time_type stylesheetWriteTime;
+			mutable xsltStylesheet * stylesheet;
+		};
 
-			XsltStreamSerializer(std::ostream &, xsltStylesheet *);
-			~XsltStreamSerializer();
+		XsltStreamSerializer(std::ostream &, xsltStylesheet *);
+		SPECIAL_MEMBERS_DELETE(XsltStreamSerializer);
+		~XsltStreamSerializer() override;
 
-			void Serialize(Slicer::ModelPartForRootPtr mp) override;
+		void Serialize(Slicer::ModelPartForRootPtr mp) override;
 
-		protected:
-			std::ostream & strm;
-			xmlpp::Document * doc;
-			xsltStylesheet * stylesheet;
+	protected:
+		std::ostream & strm;
+		xmlpp::Document * doc;
+		xsltStylesheet * stylesheet;
 	};
 }
 
 #endif
-