Fix all compiler warnings in thread_system build

- Fix sign conversion warnings in convert_string.cpp by adding explicit casts
- Fix constructor initialization order warnings in multiple files:
  - callback_job.cpp: Reorder member initialization to match declaration order
  - thread_base.cpp: Reorder wake_interval_ initialization
  - message_job.cpp: Fix member initialization order
  - file_writer.cpp: Correct initialization sequence
  - log_job.cpp: Match declaration order for message type members
  - log_collector.cpp: Fix queue and log type initialization order
  - thread_worker.cpp: Reorder use_time_tag_ and job_queue_ initialization
  - thread_pool.cpp: Fix start_pool_ and job_queue_ initialization order
- Fix redundant move warnings in file_writer.cpp by removing unnecessary std::move
- Fix sign conversion warnings in file_writer.cpp with explicit streamsize casts
- Suppress duplicate library warnings on macOS with -Wl,-no_warn_duplicate_libraries flag

Author: kcenon

CMakeLists.txt

@@ -48,8 +48,8 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
 
   # Add additional flags for macOS
   if(APPLE)
-    # Add linker flag to avoid duplicate library warnings on macOS
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-warn_duplicate_libraries")
+    # Suppress duplicate library warnings on macOS (common with vcpkg)
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-no_warn_duplicate_libraries")
   endif()
 elseif(MSVC)
   # For Microsoft Visual C++ compiler

sources/logger/file_writer.cpp

@@ -45,13 +45,13 @@ namespace log_module
 {
 	file_writer::file_writer(void)
 		: thread_base("file_writer")
-		, job_queue_(std::make_shared<job_queue>())
 		, title_("log")
 		, use_backup_(false)
+		, file_target_(log_types::None)
 		, max_lines_(0)
 		, log_file_(nullptr)
 		, backup_file_(nullptr)
-		, file_target_(log_types::None)
+		, job_queue_(std::make_shared<job_queue>())
 	{
 	}
 
@@ -159,7 +159,7 @@ namespace log_module
 					backup_name_, std::ios_base::out | std::ios_base::app);
 			}
 
-			std::deque<std::string> backup_lines(log_lines_.begin(), log_lines_.begin() + index);
+			std::deque<std::string> backup_lines(log_lines_.begin(), log_lines_.begin() + static_cast<std::deque<std::string>::difference_type>(index));
 
 			if (backup_file_ && backup_file_->is_open())
 			{
@@ -168,7 +168,7 @@ namespace log_module
 			}
 		}
 
-		log_lines_.erase(log_lines_.begin(), log_lines_.begin() + index);
+		log_lines_.erase(log_lines_.begin(), log_lines_.begin() + static_cast<std::deque<std::string>::difference_type>(index));
 
 		log_file_ = write_lines(std::move(log_file_), log_lines_);
 		log_file_->close();
@@ -267,16 +267,16 @@ namespace log_module
 	{
 		if (file_handle == nullptr || !file_handle->is_open())
 		{
-			return std::move(file_handle);
+			return file_handle;
 		}
 
 		for (const auto& message : messages)
 		{
-			file_handle->write(message.c_str(), message.size());
+			file_handle->write(message.c_str(), static_cast<std::streamsize>(message.size()));
 		}
 
 		file_handle->flush();
 
-		return std::move(file_handle);
+		return file_handle;
 	}
 }

sources/logger/log_collector.cpp

@@ -38,10 +38,10 @@ namespace log_module
 {
 	log_collector::log_collector(void)
 		: thread_base("log_collector")
-		, log_queue_(std::make_shared<job_queue>())
 		, file_log_type_(log_types::None)
 		, console_log_type_(log_types::None)
 		, callback_log_type_(log_types::None)
+		, log_queue_(std::make_shared<job_queue>())
 	{
 	}
 

sources/logger/log_job.cpp

@@ -52,12 +52,12 @@ namespace log_module
 		std::optional<log_types> type,
 		std::optional<std::chrono::time_point<std::chrono::high_resolution_clock>> start_time)
 		: job("log_job")
-		, type_(type)
 		, message_type_(message_types::String)
 		, message_(message)
+		, log_message_("")
+		, type_(type)
 		, timestamp_(std::chrono::system_clock::now())
 		, start_time_(start_time)
-		, log_message_("")
 	{
 	}
 
@@ -66,12 +66,12 @@ namespace log_module
 		std::optional<log_types> type,
 		std::optional<std::chrono::time_point<std::chrono::high_resolution_clock>> start_time)
 		: job("log_job")
-		, type_(type)
 		, message_type_(message_types::WString)
 		, wmessage_(message)
+		, log_message_("")
+		, type_(type)
 		, timestamp_(std::chrono::system_clock::now())
 		, start_time_(start_time)
-		, log_message_("")
 	{
 	}
 

sources/logger/message_job.cpp

@@ -41,7 +41,7 @@ namespace log_module
 	message_job::message_job(const log_types& log_type,
 							 const std::string& datetime,
 							 const std::string& message)
-		: job("message_job"), log_type_(log_type), datetime_(datetime), message_(message)
+		: job("message_job"), datetime_(datetime), message_(message), log_type_(log_type)
 	{
 	}
 

sources/thread_base/callback_job.cpp

@@ -51,13 +51,13 @@ namespace thread_module
 	callback_job::callback_job(
 		const std::function<std::optional<std::string>(const std::vector<uint8_t>&)>& data_callback,
 		const std::vector<uint8_t>& data, const std::string& name)
-		: job(data, name), data_callback_([data_callback](const std::vector<uint8_t>& data) -> result_void {
+		: job(data, name), callback_(nullptr), data_callback_([data_callback](const std::vector<uint8_t>& data) -> result_void {
 			auto result = data_callback(data);
 			if (result.has_value()) {
 				return error{error_code::job_execution_failed, result.value()};
 			}
 			return result_void{};
-		}), callback_(nullptr)
+		})
 	{
 	}
 

sources/thread_base/thread_base.cpp

@@ -55,13 +55,13 @@ namespace thread_module
 	 * - Sets initial thread_condition_ to Created
 	 */
 	thread_base::thread_base(const std::string& thread_title)
-		: worker_thread_(nullptr)
+		: wake_interval_(std::nullopt)
+		, worker_thread_(nullptr)
 #ifdef USE_STD_JTHREAD
 		, stop_source_(std::nullopt)
 #else
 		, stop_requested_(false)
 #endif
-		, wake_interval_(std::nullopt)
 		, thread_title_(thread_title)
 		, thread_condition_(thread_conditions::Created)
 	{

sources/thread_pool/thread_pool.cpp

@@ -40,7 +40,7 @@ using namespace utility_module;
 namespace thread_pool_module
 {
 	thread_pool::thread_pool(const std::string& thread_title)
-		: thread_title_(thread_title), job_queue_(std::make_shared<job_queue>()), start_pool_(false)
+		: thread_title_(thread_title), start_pool_(false), job_queue_(std::make_shared<job_queue>())
 	{
 	}
 

sources/thread_pool/thread_worker.cpp

@@ -38,7 +38,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 namespace thread_pool_module
 {
 	thread_worker::thread_worker(const bool& use_time_tag)
-		: thread_base("thread_worker"), job_queue_(nullptr), use_time_tag_(use_time_tag)
+		: thread_base("thread_worker"), use_time_tag_(use_time_tag), job_queue_(nullptr)
 	{
 	}
 

sources/utilities/convert_string.cpp

@@ -452,7 +452,7 @@ namespace utility_module
 		int mod_table[] = { 0, 2, 1 };
 		for (int j = 0; j < mod_table[data.size() % 3]; j++)
 		{
-			encoded_string[encoded_string.size() - 1 - j] = '=';
+			encoded_string[encoded_string.size() - 1 - static_cast<size_t>(j)] = '=';
 		}
 
 		return encoded_string;
@@ -490,7 +490,7 @@ namespace utility_module
 		std::vector<int> decoding_table(256, -1);
 		for (int i = 0; i < 64; i++)
 		{
-			decoding_table[static_cast<unsigned char>(base64_chars[i])] = i;
+			decoding_table[static_cast<unsigned char>(base64_chars[static_cast<size_t>(i)])] = i;
 		}
 
 		uint32_t buffer = 0;
@@ -513,7 +513,7 @@ namespace utility_module
 				return { std::vector<uint8_t>(), "Invalid character in base64 string" };
 			}
 
-			buffer = (buffer << 6) | decoding_table[static_cast<unsigned char>(c)];
+			buffer = (buffer << 6) | static_cast<uint32_t>(decoding_table[static_cast<unsigned char>(c)]);
 			bits_collected += 6;
 
 			if (bits_collected >= 8)