Fix/sonar maintainability rebased (#209)

* refactor(sonar): use override instead of redundant virtual (cpp:S3471)

* refactor(sonar): remove empty statements, one declaration per statement (cpp:S1116, cpp:S1659)

* refactor(sonar): drop redundant lambda return types (cpp:S3574)

* refactor(sonar): prefer using over typedef (cpp:S5416)

* refactor(sonar): use =default for trivial special members (cpp:S3490)

* refactor(sonar): use nullptr literal (cpp:S4962)

* refactor(sonar): remove redundant access specifiers (cpp:S3539)

* refactor(sonar): remove redundant casts (cpp:S1905)

* refactor(sonar): use std::scoped_lock instead of std::lock_guard (cpp:S5997)

* refactor(sonar): construct elements in place with emplace_back (cpp:S6003)

* refactor(sonar): make narrowing conversions explicit (cpp:S5276)

* refactor(sonar): mark unused parameters (cpp:S1172)

Unused names are commented out; parameters used only on some platforms
are marked [[maybe_unused]].

* refactor(sonar): declare non-mutating member functions const (cpp:S5817)

Virtual functions are left untouched so overrides keep matching.

* refactor(sonar): merge collapsible nested if statements (cpp:S1066)

Comments that preceded the inner if are kept above the merged statement.

* refactor(sonar): scope single-use variables in if init-statements (cpp:S6004)

* fix(sonar): give polymorphic base classes virtual destructors (cpp:S1235)

* refactor(sonar): use try_emplace for map insertion (cpp:S6030)

* refactor(sonar): use auto where the type is spelled out on the right (cpp:S5827)

* refactor(sonar): remove redundant parentheses (cpp:S1110)

* refactor(sonar): document intentionally empty functions (cpp:S1186)

* refactor(sonar): remove dead stores (cpp:S1854)

Side effects (e.g. LISTLINE++) are kept.

* refactor(sonar): remove unused variables, captures and private fields (cpp:S1481, cpp:S1068)

* refactor(sonar): use structured bindings for pair access (cpp:S6005)

* refactor(sonar): use range-based loops and ranges algorithms (cpp:S5566)

* refactor(sonar): split chained assignments (cpp:S1121)

* refactor(sonar): add default cases to switch statements (cpp:S3562)

* refactor(sonar): use std::size for array lengths (cpp:S7127)

* refactor(sonar): use std::ranges algorithms and std::erase(_if) (cpp:S6197)

* refactor(sonar): access static members through the class (cpp:S2209)

* refactor(sonar): add braces around nested if-else (cpp:S5261)

* refactor(sonar): avoid side effects inside typeid operands (cpp:S5279)

* refactor(sonar): drop top-level const from by-value return types (cpp:S5951)

* refactor(sonar): declare variables separately from their type definitions (cpp:S3646)

* refactor(sonar): declare loop counters in the for statement (cpp:S5955)

* refactor(sonar): rely on class template argument deduction (cpp:S6012)

* refactor(sonar): inherit base constructors instead of forwarding them (cpp:S5952)

* refactor(sonar): rename locals that shadow outer declarations (cpp:S1117)

Only local variables and definition parameters are renamed; shadowing
struct fields and enumerators in headers are left for a separate change.

* refactor(sonar): reduce enum qualification with using enum (cpp:S6177)

Applied only where no unqualified name in the block could be captured by
the introduced enumerators.

* refactor(sonar): mark converting constructors explicit (cpp:S1709)

sound_source and the gl::object conversion operators stay implicit; they
are relied upon by copy-list-initialisation and GL calls.

* refactor(sonar): initialise members in initialiser lists or declarations (cpp:S3230)

* refactor(sonar): make read-only local references and pointers const (cpp:S5350)

* refactor(sonar): take read-only pointer and reference parameters as const (cpp:S995)

TTrain command handlers keep their signature, it is fixed by the handler table.

* refactor(sonar): pass expensive-to-copy parameters by const reference (cpp:S1238)

Signatures declared in files touched by PR 206 (Driver.h, EU07.cpp) and
virtual overrides are left unchanged.

* refactor(sonar): use transparent comparators for string-keyed maps (cpp:S6045)

std::unordered_map instances and map types exposed in headers used by
other modules are left as they are.

* fix(sonar): do not use UI text as a printf format string (cpp:S5281)

Text lines containing '%' would otherwise be interpreted as format
specifiers by ImGui::TextColored.

* refactor(sonar): use std::bind_front for callbacks (cpp:S5995)

* refactor(sonar): drop const_cast on string literals passed to the Python C API (cpp:S859)

* refactor(sonar): take read-only string parameters as std::string_view (cpp:S6009)

The Windows messaging helpers keep std::string, they need c_str().

* refactor(sonar): make read-only global tables const (cpp:S5421)

Mutable global state (flags, timers, singletons) is left as is.

* refactor(sonar): replace single-case switch statements with if (cpp:S1301)

* refactor(sonar): format UUIDs and log timestamps with std::format (cpp:S6494, cpp:S5945)

* refactor(sonar): use std::array for local fixed-size arrays (cpp:S5945)

Arrays that are class members or part of headers are left unchanged.

* fix(sonar): test the bearing damage bit, not bit 0 (cpp:S872)

'DamageFlag & dtrain_bearing > 0' parsed as 'DamageFlag & (dtrain_bearing > 0)',
i.e. DamageFlag & 1, so bearing friction reacted to the wrong damage flag.

* refactor(sonar): assorted small fixes

- empty() instead of size() comparisons (cpp:S1155)
- member initialisers in declaration order (cpp:S3229)
- no redundant c_str() when a std::string is accepted (cpp:S7121)
- contains() on associative containers (cpp:S6171)
- const reference instead of a copying range-for (cpp:S6032)
- starts_with() for prefix checks (cpp:S6178)
- no std::move on temporaries (cpp:S5274)
- has_value() on std::optional (cpp:S7172)
- bool literals for bool members (cpp:S5820)
- inline only on the definition (cpp:S3548)
- explicit base access specifier (cpp:S5965)
- explicit element access instead of dereferencing an array (cpp:S7116)
- rely on the C++20 rewritten operator!= (cpp:S6186)

* refactor(sonar): more small fixes

- std::format instead of iostream manipulators in to_string/to_hex_str (cpp:S6495);
  output verified identical, negative hex values keep the unsigned form
- remove an empty compound statement (cpp:S108)
- drop an always-false unsigned < 0 branch (cpp:S1768)
- explicit lambda capture (cpp:S3608)
- std::make_unique (cpp:S5950)

* chore: strip stray carriage returns left in TTrain constructor comments

* fix: keep quantize() in its own value type

The S5276 change cast the result of the generic quantize<Type_>() to
unsigned int, which truncated float/double callers (shadow angle slider,
editor rotation snapping, AI speed control steps) and broke negative values.

* fix(sonar): use integer loop counters in segment sampling (cpp:S2193)

* refactor(sonar): clean up issues reported on PR 209

- remove locals left unused after the dead-store cleanup (cpp:S1481, cpp:S1854)
- unnamed unused parameter (cpp:S1172)
- single-use declarations moved into if init-statements (cpp:S6004)
- auto for casted initialisers (cpp:S5827)
- const references and pointers where nothing is modified (cpp:S5350)
- rename structured bindings shadowed by inner declarations (cpp:S1117)

launcher/textures_scanner.cpp

@@ -47,7 +47,7 @@ void ui::vehicles_bank::parse_entry(const std::string &line)
 
 		if (line[0] == '!')
 			parse_category_entry(param);
-		else if (line[0] == '*' && line[1] == '*')
+		else if (line.starts_with("**"))
 			parse_texture_rule(target.substr(2), param);
 		else if (line[0] == '*')
 			parse_coupling_rule(target.substr(1), param);
@@ -60,23 +60,24 @@ void ui::vehicles_bank::parse_entry(const std::string &line)
 
 void ui::vehicles_bank::parse_category_entry(const std::string &param)
 {
+	using enum ui::vehicle_type;
 	static std::unordered_map<char, vehicle_type> type_map = {
-	    { 'e', vehicle_type::electric_loco },
-	    { 's', vehicle_type::diesel_loco },
-	    { 'p', vehicle_type::steam_loco },
-	    { 'a', vehicle_type::railcar },
-	    { 'z', vehicle_type::emu },
-	    { 'r', vehicle_type::utility },
-	    { 'd', vehicle_type::draisine },
-	    { 't', vehicle_type::tram },
-	    { 'c', vehicle_type::truck },
-	    { 'b', vehicle_type::bus },
-	    { 'o', vehicle_type::car },
-	    { 'h', vehicle_type::man },
-	    { 'f', vehicle_type::animal },
+	    { 'e', electric_loco },
+	    { 's', diesel_loco },
+	    { 'p', steam_loco },
+	    { 'a', railcar },
+	    { 'z', emu },
+	    { 'r', utility },
+	    { 'd', draisine },
+	    { 't', tram },
+	    { 'c', truck },
+	    { 'b', bus },
+	    { 'o', car },
+	    { 'h', man },
+	    { 'f', animal },
 	};
 
-	ctx_type = vehicle_type::unknown;
+	ctx_type = unknown;
 
 	std::istringstream stream(param);
 
@@ -86,16 +87,15 @@ void ui::vehicles_bank::parse_category_entry(const std::string &param)
 	if (tok.size() < 1)
 		return;
 
-	auto it = type_map.find(tok[0]);
-	if (it != type_map.end())
+	if (auto it = type_map.find(tok[0]); it != type_map.end())
 		ctx_type = it->second;
 	else if (tok[0] >= 'A' && tok[0] <= 'Z')
-		ctx_type = vehicle_type::carriage;
+		ctx_type = carriage;
 
 	std::string mini;
 	std::getline(stream, mini, ',');
 
-	category_icons.emplace(ctx_type, "textures/mini/" + ToLower(mini) + ".bmp");
+	category_icons.try_emplace(ctx_type, "textures/mini/" + ToLower(mini) + ".bmp");
 }
 
 void ui::vehicles_bank::parse_controllable_entry(const std::string &target, const std::string &param)
@@ -108,7 +108,9 @@ void ui::vehicles_bank::parse_texture_info(const std::string &target, const std:
 {
 	std::istringstream stream(param);
 
-	std::string model, mini, miniplus;
+	std::string model;
+	std::string mini;
+	std::string miniplus;
 
 	std::getline(stream, model, ',');
 	std::getline(stream, mini, ',');
@@ -122,12 +124,12 @@ void ui::vehicles_bank::parse_texture_info(const std::string &target, const std:
 	set.meta = meta;
 
 	if (!mini.empty())
-		group_icons.emplace(mini, std::move(deferred_image("textures/mini/" + ToLower(mini) + ".bmp")));
+		group_icons.try_emplace(mini, deferred_image("textures/mini/" + ToLower(mini) + ".bmp"));
 
 	if (!miniplus.empty())
-		set.mini = std::move(deferred_image("textures/mini/" + ToLower(miniplus) + ".bmp"));
+		set.mini = deferred_image("textures/mini/" + ToLower(miniplus) + ".bmp");
 	else if (!mini.empty())
-		set.mini = std::move(deferred_image("textures/mini/" + ToLower(mini) + ".bmp"));
+		set.mini = deferred_image("textures/mini/" + ToLower(mini) + ".bmp");
 
 	set.skin = ToLower(target);
 	erase_extension(set.skin);
@@ -143,7 +145,7 @@ void ui::vehicles_bank::parse_texture_info(const std::string &target, const std:
 	vehicle->matching_skinsets.push_back(std::make_shared<skin_set>(std::move(set)));
 }
 
-std::shared_ptr<ui::skin_meta> ui::vehicles_bank::parse_meta(const std::string &str)
+std::shared_ptr<ui::skin_meta> ui::vehicles_bank::parse_meta(const std::string &str) const
 {
 	std::istringstream stream(str);
 
@@ -171,19 +173,20 @@ std::shared_ptr<ui::skin_meta> ui::vehicles_bank::parse_meta(const std::string &
 	        ToLower("n:" + meta->name + ":i:" + meta->short_id + ":d:" + meta->location +
 	                ":r:" + meta->rev_date + ":c:" + meta->rev_company + ":t:" + meta->texture_author + ":p:" + meta->photo_author);
 
-	std::replace(std::begin(meta->location), std::end(meta->location), '_', ' ');
-	std::replace(std::begin(meta->rev_company), std::end(meta->rev_company), '_', ' ');
-	std::replace(std::begin(meta->texture_author), std::end(meta->texture_author), '_', ' ');
-	std::replace(std::begin(meta->photo_author), std::end(meta->photo_author), '_', ' ');
+	std::ranges::replace(meta->location, '_', ' ');
+	std::ranges::replace(meta->rev_company, '_', ' ');
+	std::ranges::replace(meta->texture_author, '_', ' ');
+	std::ranges::replace(meta->photo_author, '_', ' ');
 
 	if (!meta->rev_date.empty() && meta->rev_date != "?") {
-		std::istringstream stream(meta->rev_date);
-		std::string day, month;
+		std::istringstream datestream(meta->rev_date);
+		std::string day;
+		std::string month;
 
-		std::getline(stream, day, '.');
-		std::getline(stream, month, '.');
+		std::getline(datestream, day, '.');
+		std::getline(datestream, month, '.');
 
-		stream >> meta->rev_year;
+		datestream >> meta->rev_year;
 	}
 
 	return meta;
@@ -205,7 +208,8 @@ void ui::vehicles_bank::parse_coupling_rule(const std::string &target, const std
 	std::string connected;
 	std::getline(stream, connected, ',');
 
-	std::string param1, param2;
+	std::string param1;
+	std::string param2;
 	std::getline(stream, param1, ',');
 	std::getline(stream, param2, ',');
 
@@ -232,7 +236,8 @@ void ui::vehicles_bank::parse_texture_rule(const std::string &target, const std:
 
 		std::istringstream rule_stream(replace_rule);
 
-		std::string src, dst;
+		std::string src;
+		std::string dst;
 		std::getline(rule_stream, src, '-');
 		std::getline(rule_stream, dst, '-');
 
@@ -257,7 +262,7 @@ std::shared_ptr<ui::vehicle_desc> ui::vehicles_bank::get_vehicle(const std::stri
 		auto desc = std::make_shared<vehicle_desc>();
 		desc->type = ctx_type;
 		desc->path = path;
-		vehicles.emplace(path, desc);
+		vehicles.try_emplace(path, desc);
 		return desc;
 	}
 }