3 files changed, 44 insertions, 42 deletions

diff --git a/gentoobrowse-api/domain/converters.cpp b/gentoobrowse-api/domain/converters.cpp
index e551d9a..4dfcb75 100644
--- a/gentoobrowse-api/domain/converters.cpp
+++ b/gentoobrowse-api/domain/converters.cpp
@@ -8,22 +8,20 @@
 #include <string>
 
 namespace Slicer {
-	template<typename T> PqArray<T>::PqArray(std::vector<T> * l) : ModelPartForSequence<std::vector<T>>(l) { }
-
 	template<typename T>
 	void
-	PqArray<T>::SetValue(ValueSource && s)
+	PqArray<T>::SetValue(ValueSource && input)
 	{
-		std::string in;
-		s.set(in);
-		*this->Model = unpackPqArray<T>(in);
+		std::string inputStr;
+		input.set(inputStr);
+		*this->Model = unpackPqArray<T>(inputStr);
 	}
 
 	template<typename T>
 	bool
-	PqArray<T>::GetValue(ValueTarget && s)
+	PqArray<T>::GetValue(ValueTarget && input)
 	{
-		s.get(packPqArray(*this->Model));
+		input.get(packPqArray(*this->Model));
 		return true;
 	}
 
@@ -31,14 +29,14 @@ namespace Slicer {
 	template class PqArray<std::string>;
 
 	boost::posix_time::ptime
-	shortDateToPosixTime(const std::string & s)
+	shortDateToPosixTime(const std::string & input)
 	{
-		return boost::posix_time::ptime(boost::gregorian::from_simple_string(s));
+		return boost::posix_time::ptime(boost::gregorian::from_simple_string(input));
 	}
 
 	std::string
-	posixTimeToShortDate(const boost::posix_time::ptime & s)
+	posixTimeToShortDate(const boost::posix_time::ptime & input)
 	{
-		return boost::gregorian::to_sql_string(s.date());
+		return boost::gregorian::to_sql_string(input.date());
 	}
 }
diff --git a/gentoobrowse-api/domain/converters.h b/gentoobrowse-api/domain/converters.h
index 35583e5..3805149 100644
--- a/gentoobrowse-api/domain/converters.h
+++ b/gentoobrowse-api/domain/converters.h
@@ -10,15 +10,15 @@
 namespace Slicer {
 	template<typename T> class DLL_PUBLIC PqArray : public ModelPartForSequence<std::vector<T>> {
 	public:
-		explicit PqArray(std::vector<T> *);
+		using ModelPartForSequence<std::vector<T>>::ModelPartForSequence;
 
 		void SetValue(ValueSource &&) override;
 		bool GetValue(ValueTarget &&) override;
 	};
 
 	DLL_PUBLIC
-	boost::posix_time::ptime shortDateToPosixTime(const std::string & s);
+	boost::posix_time::ptime shortDateToPosixTime(const std::string & input);
 
 	DLL_PUBLIC
-	std::string posixTimeToShortDate(const boost::posix_time::ptime & s);
+	std::string posixTimeToShortDate(const boost::posix_time::ptime & input);
 }
diff --git a/gentoobrowse-api/domain/converters.impl.h b/gentoobrowse-api/domain/converters.impl.h
index f6b6bad..d79b7e4 100644
--- a/gentoobrowse-api/domain/converters.impl.h
+++ b/gentoobrowse-api/domain/converters.impl.h
@@ -7,18 +7,22 @@
 namespace Slicer {
 	template<typename T> class UnpackPqTextArrayInto : public UnpackPqTextArray {
 	public:
-		UnpackPqTextArrayInto(std::istream & s, std::vector<T> & l) : UnpackPqTextArray(s), list(l) { }
+		UnpackPqTextArrayInto(std::istream & inputStrm, std::vector<T> & output) :
+			UnpackPqTextArray(inputStrm), list(output)
+		{
+		}
 
 		void
-		consume(std::string s) override
+		consume(std::string input) override
 		{
 			if constexpr (std::is_arithmetic_v<T>) {
-				if (std::from_chars(s.c_str(), s.c_str() + s.length(), list.emplace_back()).ec != std::error_code {}) {
+				if (std::from_chars(input.c_str(), input.c_str() + input.length(), list.emplace_back()).ec
+						!= std::error_code {}) {
 					throw std::domain_error {"Invalid arithmetic input"};
 				}
 			}
 			else {
-				list.emplace_back(std::move(s));
+				list.emplace_back(std::move(input));
 			}
 		}
 
@@ -28,50 +32,50 @@ namespace Slicer {
 
 	template<typename T>
 	void
-	packPqVar(std::ostream & s, const T & l)
+	packPqVar(std::ostream & outputStrm, const T & input)
 	{
 		if constexpr (std::is_arithmetic_v<T>) {
-			s << l;
+			outputStrm << input;
 		}
 		else {
-			s << '\"';
-			std::transform(l.begin(), l.end(), std::ostream_iterator<std::string_view>(s), [](const char & c) {
-				if (c == '"') {
+			outputStrm << '\"';
+			std::ranges::transform(input, std::ostream_iterator<std::string_view>(outputStrm), [](const char & chr) {
+				if (chr == '"') {
 					return std::string_view(R"(\")");
 				}
-				return std::string_view(&c, 1);
+				return std::string_view(&chr, 1);
 			});
-			s << '\"';
+			outputStrm << '\"';
 		}
 	}
 
 	template<typename T>
 	std::vector<T>
-	unpackPqArray(const std::string & s)
+	unpackPqArray(const std::string & input)
 	{
 		std::vector<T> rtn;
-		std::stringstream ss(s);
-		UnpackPqTextArrayInto<T> u(ss, rtn);
-		u.yylex();
+		std::stringstream inputStrm(input);
+		UnpackPqTextArrayInto<T> unpacker(inputStrm, rtn);
+		unpacker.yylex();
 		return rtn;
 	}
 
 	template<typename T>
 	std::string
-	packPqArray(const T & l)
+	packPqArray(const T & input)
 	{
-		std::stringstream ss;
-		ss << "{";
-		if (!l.empty()) {
-			auto i = l.cbegin();
-			packPqVar(ss, *i);
-			i++;
-			while (i != l.cend()) {
-				ss << ",";
-				packPqVar(ss, *i++);
+		std::stringstream outputStrm;
+		outputStrm << "{";
+		if (!input.empty()) {
+			auto chr = input.cbegin();
+			packPqVar(outputStrm, *chr);
+			chr++;
+			while (chr != input.cend()) {
+				outputStrm << ",";
+				packPqVar(outputStrm, *chr++);
 			}
 		}
-		ss << "}";
-		return std::move(ss).str();
+		outputStrm << "}";
+		return std::move(outputStrm).str();
 	}
 }