change exception texts

Alairion · Alairion · commit a77cd42a5237 · 2019-06-09T10:49:59.000+02:00
diff --git a/include/nes/named_mutex.hpp b/include/nes/named_mutex.hpp
@@ -73,11 +73,11 @@ struct named_mutex_base
             {
                 handle = OpenMutexW(SYNCHRONIZE, FALSE, std::data(native_name));
                 if(!handle)
-                    throw std::runtime_error{"Can not open named mutex. " + get_error_message()};
+                    throw std::runtime_error{"Failed to open named mutex. " + get_error_message()};
             }
             else
             {
-                throw std::runtime_error{"Can not create named mutex. " + get_error_message()};
+                throw std::runtime_error{"Failed to create named mutex. " + get_error_message()};
             }
         }
 
@@ -94,7 +94,7 @@ struct named_mutex_base
         out_path.resize(required_size);
 
         if(!MultiByteToWideChar(CP_UTF8, 0, std::data(path), std::size(path), std::data(out_path), std::size(out_path)))
-            throw std::runtime_error{"Can not convert the path to wide."};
+            throw std::runtime_error{"Failed to convert the path to wide."};
 
         return out_path;
     }
@@ -267,19 +267,19 @@ inline mutex_base create_or_open_mutex(const std::string& name, bool recursive)
 
     int shm_handle{shm_open(std::data(native_name), O_RDWR | O_CREAT, 0660)};
     if(shm_handle == -1)
-        throw std::runtime_error{"Can not allocate space for named mutex. " + std::string{strerror(errno)}};
+        throw std::runtime_error{"Failed to allocate space for named mutex. " + std::string{strerror(errno)}};
 
     if(ftruncate(shm_handle, sizeof(mutex_data)) == -1)
     {
         close(shm_handle);
-        throw std::runtime_error{"Can not truncate shared memory for named mutex. " + std::string{strerror(errno)}};
+        throw std::runtime_error{"Failed to truncate shared memory for named mutex. " + std::string{strerror(errno)}};
     }
 
     auto* ptr{reinterpret_cast<mutex_data*>(mmap(nullptr, sizeof(mutex_data), PROT_READ | PROT_WRITE, MAP_SHARED, shm_handle, 0))};
     if(ptr == MAP_FAILED)
     {
         close(shm_handle);
-        throw std::runtime_error{"Can not map shared memory for named mutex. " + std::string{strerror(errno)}};
+        throw std::runtime_error{"Failed to map shared memory for named mutex. " + std::string{strerror(errno)}};
     }
 
     if(!ptr->opened)
@@ -296,17 +296,17 @@ inline mutex_base create_or_open_mutex(const std::string& name, bool recursive)
         };
 
         if(auto error = pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED); error != 0)
-            clean_and_throw("Can not set process shared attribute of mutex. ", error);
+            clean_and_throw("Failed to set process shared attribute of mutex. ", error);
 
         if(auto error = pthread_mutexattr_setrobust(&attr, PTHREAD_MUTEX_ROBUST); error != 0)
-            clean_and_throw("Can not set robust attribute of mutex. ", error);
+            clean_and_throw("Failed to set robust attribute of mutex. ", error);
 
         if(recursive)
             if(auto error = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); error != 0)
-                clean_and_throw("Can not set recursive attribute of mutex. ", error);
+                clean_and_throw("Failed to set recursive attribute of mutex. ", error);
 
         if(auto error = pthread_mutex_init(&ptr->mutex, &attr); error != 0)
-            clean_and_throw("Can not init mutex. ", error);
+            clean_and_throw("Failed to init mutex. ", error);
 
         pthread_mutexattr_destroy(&attr);
 
@@ -330,7 +330,7 @@ inline void lock_mutex(mutex_base& mutex)
     if(error == EOWNERDEAD)
         pthread_mutex_consistent(&mutex.data->mutex);
     else if(error != 0)
-        throw std::runtime_error{"Can not lock mutex. " +  std::string{strerror(error)}};
+        throw std::runtime_error{"Failed to lock mutex. " +  std::string{strerror(error)}};
 }
 
 inline bool try_lock_mutex(mutex_base& mutex)
diff --git a/include/nes/named_semaphore.hpp b/include/nes/named_semaphore.hpp
@@ -72,11 +72,11 @@ class named_semaphore
             {
                 m_handle = OpenSemaphoreW(SYNCHRONIZE, FALSE, std::data(native_name));
                 if(!m_handle)
-                    throw std::runtime_error{"Can not open semaphore. " + get_error_message()};
+                    throw std::runtime_error{"Failed to open semaphore. " + get_error_message()};
             }
             else
             {
-                throw std::runtime_error{"Can not create semaphore. " + get_error_message()};
+                throw std::runtime_error{"Failed to create semaphore. " + get_error_message()};
             }
         }
     }
@@ -124,7 +124,7 @@ class named_semaphore
         out_path.resize(required_size);
 
         if(!MultiByteToWideChar(CP_UTF8, 0, std::data(path), std::size(path), std::data(out_path), std::size(out_path)))
-            throw std::runtime_error{"Can not convert the path to wide."};
+            throw std::runtime_error{"Failed to convert the path to wide."};
 
         return out_path;
     }
@@ -164,11 +164,11 @@ class timed_named_semaphore
             {
                 m_handle = OpenSemaphoreW(SYNCHRONIZE, FALSE, std::data(native_name));
                 if(!m_handle)
-                    throw std::runtime_error{"Can not open semaphore. " + get_error_message()};
+                    throw std::runtime_error{"Failed to open semaphore. " + get_error_message()};
             }
             else
             {
-                throw std::runtime_error{"Can not create semaphore. " + get_error_message()};
+                throw std::runtime_error{"Failed to create semaphore. " + get_error_message()};
             }
         }
     }
@@ -232,7 +232,7 @@ class timed_named_semaphore
         out_path.resize(required_size);
 
         if(!MultiByteToWideChar(CP_UTF8, 0, std::data(path), std::size(path), std::data(out_path), std::size(out_path)))
-            throw std::runtime_error{"Can not convert the path to wide."};
+            throw std::runtime_error{"Failed to convert the path to wide."};
 
         return out_path;
     }
@@ -276,7 +276,7 @@ class named_semaphore
 
         m_handle = sem_open(std::data(native_name), O_CREAT, 0660, initial_count);
         if(m_handle == SEM_FAILED)
-            throw std::runtime_error{"Can not create semaphore. " + std::string{strerror(errno)}};
+            throw std::runtime_error{"Failed to create semaphore. " + std::string{strerror(errno)}};
     }
 
     ~named_semaphore()
@@ -327,7 +327,7 @@ class timed_named_semaphore
 
         m_handle = sem_open(std::data(native_name), O_CREAT, 0660, initial_count);
         if(m_handle == SEM_FAILED)
-            throw std::runtime_error{"Can not create semaphore. " + std::string{strerror(errno)}};
+            throw std::runtime_error{"Failed to create semaphore. " + std::string{strerror(errno)}};
     }
 
     ~timed_named_semaphore()
diff --git a/include/nes/pipe.hpp b/include/nes/pipe.hpp
@@ -268,7 +268,7 @@ class basic_pipe_streambuf : public std::basic_streambuf<CharT, Traits>
         out_path.resize(required_size);
 
         if(!MultiByteToWideChar(CP_UTF8, 0, std::data(path), std::size(path), std::data(out_path), std::size(out_path)))
-            throw std::runtime_error{"Can not convert the path to wide."};
+            throw std::runtime_error{"Failed to convert the path to wide."};
 
         return out_path;
     }
@@ -449,7 +449,7 @@ std::pair<basic_pipe_istream<CharT, Traits>, basic_pipe_ostream<CharT, Traits>>
     HANDLE output{};
 
     if(!CreatePipe(&input, &output, nullptr, 0))
-        throw std::runtime_error{"Can not create pipe"};
+        throw std::runtime_error{"Failed to create pipe"};
 
     return std::make_pair(basic_pipe_istream<CharT, Traits>{basic_pipe_streambuf<CharT, Traits>{input, std::ios_base::in}},
                           basic_pipe_ostream<CharT, Traits>{basic_pipe_streambuf<CharT, Traits>{output, std::ios_base::out}});
@@ -824,7 +824,7 @@ std::pair<basic_pipe_istream<CharT, Traits>, basic_pipe_ostream<CharT, Traits>>
     int fd[2];
 
     if(pipe(fd))
-        throw std::runtime_error{"Can not create pipe"};
+        throw std::runtime_error{"Failed to create pipe"};
 
     return std::make_pair(basic_pipe_istream<CharT, Traits>{basic_pipe_streambuf<CharT, Traits>{fd[0], std::ios_base::in}},
                           basic_pipe_ostream<CharT, Traits>{basic_pipe_streambuf<CharT, Traits>{fd[1], std::ios_base::out}});
diff --git a/include/nes/process.hpp b/include/nes/process.hpp
@@ -249,15 +249,15 @@ class process
 
         if(static_cast<bool>(options & process_options::grab_stdin))
             if(!CreatePipe(&stdin_rd, &stdin_wr, &security_attributes, 0) || !SetHandleInformation(stdin_wr, HANDLE_FLAG_INHERIT, 0))
-                throw std::runtime_error{"Can not create stdin pipe. " + get_error_message()};
+                throw std::runtime_error{"Failed to create stdin pipe. " + get_error_message()};
 
         if(static_cast<bool>(options & process_options::grab_stdout))
             if(!CreatePipe(&stdout_rd, &stdout_wr, &security_attributes, 0) || !SetHandleInformation(stdout_rd, HANDLE_FLAG_INHERIT, 0))
-                throw std::runtime_error{"Can not create stdout pipe. " + get_error_message()};
+                throw std::runtime_error{"Failed to create stdout pipe. " + get_error_message()};
 
         if(static_cast<bool>(options & process_options::grab_stderr))
             if(!CreatePipe(&stderr_rd, &stderr_wr, &security_attributes, 0) || !SetHandleInformation(stderr_rd, HANDLE_FLAG_INHERIT, 0))
-                throw std::runtime_error{"Can not create stderr pipe. " + get_error_message()};
+                throw std::runtime_error{"Failed to create stderr pipe. " + get_error_message()};
     #endif
 
         args.insert(std::begin(args), path);
@@ -326,7 +326,7 @@ class process
 
         PROCESS_INFORMATION process_info{};
         if(!CreateProcessW(std::data(native_path), null_or_data(args_str), nullptr, nullptr, TRUE, 0, nullptr, null_or_data(native_working_directory), &startup_info, &process_info))
-            throw std::runtime_error{"Can not create process. " + get_error_message()};
+            throw std::runtime_error{"Failed to create process. " + get_error_message()};
 
         m_id = static_cast<id>(process_info.dwProcessId);
         m_handle = process_info.hProcess;
@@ -401,10 +401,10 @@ class process
         assert(joinable() && "nes::process::join() called with joinable() returning false.");
 
         if(WaitForSingleObject(m_handle, INFINITE))
-            throw std::runtime_error{"Can not join the process. " + get_error_message()};
+            throw std::runtime_error{"Failed to join the process. " + get_error_message()};
 
         if(!GetExitCodeProcess(m_handle, reinterpret_cast<DWORD*>(&m_return_code)))
-            throw std::runtime_error{"Can not get the return code of the process. " + get_error_message()};
+            throw std::runtime_error{"Failed to get the return code of the process. " + get_error_message()};
 
         close_process();
     }
@@ -421,7 +421,7 @@ class process
 
         DWORD result = WaitForSingleObject(m_handle, 0);
         if(result == WAIT_FAILED)
-            throw std::runtime_error{"Can not get the state of the process. " + get_error_message()};
+            throw std::runtime_error{"Failed to get the state of the process. " + get_error_message()};
 
         return result == WAIT_TIMEOUT;
     }
@@ -490,7 +490,7 @@ class process
         out_path.resize(required_size);
 
         if(!MultiByteToWideChar(CP_UTF8, 0, std::data(path), std::size(path), std::data(out_path), std::size(out_path)))
-            throw std::runtime_error{"Can not convert the path to wide."};
+            throw std::runtime_error{"Failed to convert the path to wide."};
 
         return out_path;
     }
@@ -561,7 +561,7 @@ inline std::string working_directory()
     path.resize(required_size);
 
     if(!WideCharToMultiByte(CP_UTF8, 0, std::data(native_path), std::size(native_path), std::data(path), std::size(path), nullptr, nullptr))
-        throw std::runtime_error{"Can not convert the path to UTF-8."};
+        throw std::runtime_error{"Failed to convert the path to UTF-8."};
 
     return path;
 }
@@ -573,7 +573,7 @@ inline bool change_working_directory(const std::string& path)
     native_path.resize(required_size);
 
     if(!MultiByteToWideChar(CP_UTF8, 0, std::data(path), std::size(path), std::data(native_path), std::size(native_path)))
-        throw std::runtime_error{"Can not convert the path to wide."};
+        throw std::runtime_error{"Failed to convert the path to wide."};
 
     return SetCurrentDirectoryW(std::data(native_path));
 }
@@ -799,13 +799,13 @@ class process
         impl::auto_handle stderr_fd[2]{};
 
         if(static_cast<bool>(options & process_options::grab_stdin) && pipe(reinterpret_cast<int*>(stdin_fd)))
-            throw std::runtime_error{"Can not create stdin pipe. " + std::string{strerror(errno)}};
+            throw std::runtime_error{"Failed to create stdin pipe. " + std::string{strerror(errno)}};
 
         if(static_cast<bool>(options & process_options::grab_stdout) && pipe(reinterpret_cast<int*>(stdout_fd)))
-            throw std::runtime_error{"Can not create stdout pipe. " + std::string{strerror(errno)}};
+            throw std::runtime_error{"Failed to create stdout pipe. " + std::string{strerror(errno)}};
 
         if(static_cast<bool>(options & process_options::grab_stderr) && pipe(reinterpret_cast<int*>(stderr_fd)))
-            throw std::runtime_error{"Can not create stderr pipe. " + std::string{strerror(errno)}};
+            throw std::runtime_error{"Failed to create stderr pipe. " + std::string{strerror(errno)}};
 
         const bool standard_streams{static_cast<bool>(options & process_options::grab_stdin) || static_cast<bool>(options & process_options::grab_stdout) || static_cast<bool>(options & process_options::grab_stderr)};
     #else
@@ -819,7 +819,7 @@ class process
 
             if(id < 0)
             {
-                throw std::runtime_error{"Can not create process. " + std::string{strerror(errno)}};
+                throw std::runtime_error{"Failed to create process. " + std::string{strerror(errno)}};
             }
             else if(id == 0)
             {
@@ -833,7 +833,7 @@ class process
 
             if(id < 0)
             {
-                throw std::runtime_error{"Can not create process. " + std::string{strerror(errno)}};
+                throw std::runtime_error{"Failed to create process. " + std::string{strerror(errno)}};
             }
             else if(id == 0)
             {
@@ -920,7 +920,7 @@ class process
 
         int return_code{};
         if(waitpid(m_id, &return_code, 0) == -1)
-            throw std::runtime_error{"Can not join the process. " + std::string{strerror(errno)}};
+            throw std::runtime_error{"Failed to join the process. " + std::string{strerror(errno)}};
 
         m_id = -1;
         m_return_code = WEXITSTATUS(return_code);
@@ -1016,7 +1016,7 @@ inline std::string working_directory()
         if(errno == ERANGE)
             path.resize(std::size(path) * 2);
         else
-            throw std::runtime_error{"Can not get the current working directory. " + std::string{strerror(errno)}};
+            throw std::runtime_error{"Failed to get the current working directory. " + std::string{strerror(errno)}};
     }
 
     path.resize(path.find_first_of('\0'));
diff --git a/include/nes/semaphore.hpp b/include/nes/semaphore.hpp
@@ -63,7 +63,7 @@ class semaphore
     {
         m_handle = CreateSemaphoreW(nullptr, static_cast<LONG>(initial_count), std::numeric_limits<LONG>::max(), nullptr);
         if(!m_handle)
-            throw std::runtime_error{"Can not create semaphore. " + get_error_message()};
+            throw std::runtime_error{"Failed to create semaphore. " + get_error_message()};
     }
 
     ~semaphore()
@@ -128,7 +128,7 @@ class timed_semaphore
     {
         m_handle = CreateSemaphoreW(nullptr, static_cast<LONG>(initial_count), std::numeric_limits<LONG>::max(), nullptr);
         if(!m_handle)
-            throw std::runtime_error{"Can not create semaphore. " + get_error_message()};
+            throw std::runtime_error{"Failed to create semaphore. " + get_error_message()};
     }
 
     ~timed_semaphore()
@@ -214,7 +214,7 @@ class semaphore
     explicit semaphore(std::size_t initial_count = 0)
     {
         if(sem_init(m_handle.get(), 0, initial_count) != 0)
-            throw std::runtime_error{"Can not create semaphore. " + std::string{strerror(errno)}};
+            throw std::runtime_error{"Failed to create semaphore. " + std::string{strerror(errno)}};
     }
 
     ~semaphore()
@@ -262,7 +262,7 @@ class timed_semaphore
     explicit timed_semaphore(std::size_t initial_count = 0)
     {
         if(sem_init(m_handle.get(), 0, initial_count) != 0)
-            throw std::runtime_error{"Can not create timed_semaphore. " + std::string{strerror(errno)}};
+            throw std::runtime_error{"Failed to create timed_semaphore. " + std::string{strerror(errno)}};
     }
 
     ~timed_semaphore()
diff --git a/include/nes/shared_library.hpp b/include/nes/shared_library.hpp
@@ -64,7 +64,7 @@ class shared_library
     {
         m_handle = GetModuleHandleW(nullptr);
         if(!m_handle)
-            throw std::runtime_error{"Can not load current binary file. " + get_error_message()};
+            throw std::runtime_error{"Failed to load current binary file. " + get_error_message()};
     }
 
     explicit shared_library(const std::string& path)
@@ -73,7 +73,7 @@ class shared_library
 
         m_handle = LoadLibraryW(to_wide(path).c_str());
         if(!m_handle)
-            throw std::runtime_error{"Can not load binary file \"" + path + "\". " + get_error_message()};
+            throw std::runtime_error{"Failed to load binary file \"" + path + "\". " + get_error_message()};
         m_need_free = true;
     }
 
@@ -131,7 +131,7 @@ class shared_library
         out_path.resize(required_size);
 
         if(!MultiByteToWideChar(CP_UTF8, 0, std::data(path), std::size(path), std::data(out_path), std::size(out_path)))
-            throw std::runtime_error{"Can not convert the path to wide."};
+            throw std::runtime_error{"Failed to convert the path to wide."};
 
         return out_path;
     }
@@ -176,7 +176,7 @@ class shared_library
     {
         m_handle = dlopen(nullptr, RTLD_NOW);
         if(!m_handle)
-            throw std::runtime_error{"Can not load current binary file. " + std::string{dlerror()}};
+            throw std::runtime_error{"Failed to load current binary file. " + std::string{dlerror()}};
     }
 
     explicit shared_library(const std::string& path)
@@ -185,7 +185,7 @@ class shared_library
 
         m_handle = dlopen(std::data(path), RTLD_NOW);
         if(!m_handle)
-            throw std::runtime_error{"Can not load binary file \"" + path + "\". " + std::string{dlerror()}};
+            throw std::runtime_error{"Failed to load binary file \"" + path + "\". " + std::string{dlerror()}};
     }
 
     ~shared_library()
diff --git a/include/nes/shared_memory.hpp b/include/nes/shared_memory.hpp
diff --git a/main.cpp b/main.cpp
diff --git a/other.cpp b/other.cpp

Original file line number	Diff line number	Diff line change
`@@ -73,11 +73,11 @@ struct named_mutex_base`
`73`	`73`	`{`
`74`	`74`	`handle = OpenMutexW(SYNCHRONIZE, FALSE, std::data(native_name));`
`75`	`75`	`if(!handle)`
`76`		`- throw std::runtime_error{"Can not open named mutex. " + get_error_message()};`
	`76`	`+ throw std::runtime_error{"Failed to open named mutex. " + get_error_message()};`
`77`	`77`	`}`
`78`	`78`	`else`
`79`	`79`	`{`
`80`		`- throw std::runtime_error{"Can not create named mutex. " + get_error_message()};`
	`80`	`+ throw std::runtime_error{"Failed to create named mutex. " + get_error_message()};`
`81`	`81`	`}`
`82`	`82`	`}`
`83`	`83`
`@@ -94,7 +94,7 @@ struct named_mutex_base`
`94`	`94`	`out_path.resize(required_size);`
`95`	`95`
`96`	`96`	`if(!MultiByteToWideChar(CP_UTF8, 0, std::data(path), std::size(path), std::data(out_path), std::size(out_path)))`
`97`		`- throw std::runtime_error{"Can not convert the path to wide."};`
	`97`	`+ throw std::runtime_error{"Failed to convert the path to wide."};`
`98`	`98`
`99`	`99`	`return out_path;`
`100`	`100`	`}`
`@@ -267,19 +267,19 @@ inline mutex_base create_or_open_mutex(const std::string& name, bool recursive)`
`267`	`267`
`268`	`268`	`int shm_handle{shm_open(std::data(native_name), O_RDWR \| O_CREAT, 0660)};`
`269`	`269`	`if(shm_handle == -1)`
`270`		`- throw std::runtime_error{"Can not allocate space for named mutex. " + std::string{strerror(errno)}};`
	`270`	`+ throw std::runtime_error{"Failed to allocate space for named mutex. " + std::string{strerror(errno)}};`
`271`	`271`
`272`	`272`	`if(ftruncate(shm_handle, sizeof(mutex_data)) == -1)`
`273`	`273`	`{`
`274`	`274`	`close(shm_handle);`
`275`		`- throw std::runtime_error{"Can not truncate shared memory for named mutex. " + std::string{strerror(errno)}};`
	`275`	`+ throw std::runtime_error{"Failed to truncate shared memory for named mutex. " + std::string{strerror(errno)}};`
`276`	`276`	`}`
`277`	`277`
`278`	`278`	`auto* ptr{reinterpret_cast<mutex_data*>(mmap(nullptr, sizeof(mutex_data), PROT_READ \| PROT_WRITE, MAP_SHARED, shm_handle, 0))};`
`279`	`279`	`if(ptr == MAP_FAILED)`
`280`	`280`	`{`
`281`	`281`	`close(shm_handle);`
`282`		`- throw std::runtime_error{"Can not map shared memory for named mutex. " + std::string{strerror(errno)}};`
	`282`	`+ throw std::runtime_error{"Failed to map shared memory for named mutex. " + std::string{strerror(errno)}};`
`283`	`283`	`}`
`284`	`284`
`285`	`285`	`if(!ptr->opened)`
`@@ -296,17 +296,17 @@ inline mutex_base create_or_open_mutex(const std::string& name, bool recursive)`
`296`	`296`	`};`
`297`	`297`
`298`	`298`	`if(auto error = pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED); error != 0)`
`299`		`- clean_and_throw("Can not set process shared attribute of mutex. ", error);`
	`299`	`+ clean_and_throw("Failed to set process shared attribute of mutex. ", error);`
`300`	`300`
`301`	`301`	`if(auto error = pthread_mutexattr_setrobust(&attr, PTHREAD_MUTEX_ROBUST); error != 0)`
`302`		`- clean_and_throw("Can not set robust attribute of mutex. ", error);`
	`302`	`+ clean_and_throw("Failed to set robust attribute of mutex. ", error);`
`303`	`303`
`304`	`304`	`if(recursive)`
`305`	`305`	`if(auto error = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); error != 0)`
`306`		`- clean_and_throw("Can not set recursive attribute of mutex. ", error);`
	`306`	`+ clean_and_throw("Failed to set recursive attribute of mutex. ", error);`
`307`	`307`
`308`	`308`	`if(auto error = pthread_mutex_init(&ptr->mutex, &attr); error != 0)`
`309`		`- clean_and_throw("Can not init mutex. ", error);`
	`309`	`+ clean_and_throw("Failed to init mutex. ", error);`
`310`	`310`
`311`	`311`	`pthread_mutexattr_destroy(&attr);`
`312`	`312`
`@@ -330,7 +330,7 @@ inline void lock_mutex(mutex_base& mutex)`
`330`	`330`	`if(error == EOWNERDEAD)`
`331`	`331`	`pthread_mutex_consistent(&mutex.data->mutex);`
`332`	`332`	`else if(error != 0)`
`333`		`- throw std::runtime_error{"Can not lock mutex. " + std::string{strerror(error)}};`
	`333`	`+ throw std::runtime_error{"Failed to lock mutex. " + std::string{strerror(error)}};`
`334`	`334`	`}`
`335`	`335`
`336`	`336`	`inline bool try_lock_mutex(mutex_base& mutex)`
Original file line number	Diff line number	Diff line change
`@@ -72,11 +72,11 @@ class named_semaphore`
`72`	`72`	`{`
`73`	`73`	`m_handle = OpenSemaphoreW(SYNCHRONIZE, FALSE, std::data(native_name));`
`74`	`74`	`if(!m_handle)`
`75`		`- throw std::runtime_error{"Can not open semaphore. " + get_error_message()};`
	`75`	`+ throw std::runtime_error{"Failed to open semaphore. " + get_error_message()};`
`76`	`76`	`}`
`77`	`77`	`else`
`78`	`78`	`{`
`79`		`- throw std::runtime_error{"Can not create semaphore. " + get_error_message()};`
	`79`	`+ throw std::runtime_error{"Failed to create semaphore. " + get_error_message()};`
`80`	`80`	`}`
`81`	`81`	`}`
`82`	`82`	`}`
`@@ -124,7 +124,7 @@ class named_semaphore`
`124`	`124`	`out_path.resize(required_size);`
`125`	`125`
`126`	`126`	`if(!MultiByteToWideChar(CP_UTF8, 0, std::data(path), std::size(path), std::data(out_path), std::size(out_path)))`
`127`		`- throw std::runtime_error{"Can not convert the path to wide."};`
	`127`	`+ throw std::runtime_error{"Failed to convert the path to wide."};`
`128`	`128`
`129`	`129`	`return out_path;`
`130`	`130`	`}`
`@@ -164,11 +164,11 @@ class timed_named_semaphore`
`164`	`164`	`{`
`165`	`165`	`m_handle = OpenSemaphoreW(SYNCHRONIZE, FALSE, std::data(native_name));`
`166`	`166`	`if(!m_handle)`
`167`		`- throw std::runtime_error{"Can not open semaphore. " + get_error_message()};`
	`167`	`+ throw std::runtime_error{"Failed to open semaphore. " + get_error_message()};`
`168`	`168`	`}`
`169`	`169`	`else`
`170`	`170`	`{`
`171`		`- throw std::runtime_error{"Can not create semaphore. " + get_error_message()};`
	`171`	`+ throw std::runtime_error{"Failed to create semaphore. " + get_error_message()};`
`172`	`172`	`}`
`173`	`173`	`}`
`174`	`174`	`}`
`@@ -232,7 +232,7 @@ class timed_named_semaphore`
`232`	`232`	`out_path.resize(required_size);`
`233`	`233`
`234`	`234`	`if(!MultiByteToWideChar(CP_UTF8, 0, std::data(path), std::size(path), std::data(out_path), std::size(out_path)))`
`235`		`- throw std::runtime_error{"Can not convert the path to wide."};`
	`235`	`+ throw std::runtime_error{"Failed to convert the path to wide."};`
`236`	`236`
`237`	`237`	`return out_path;`
`238`	`238`	`}`
`@@ -276,7 +276,7 @@ class named_semaphore`
`276`	`276`
`277`	`277`	`m_handle = sem_open(std::data(native_name), O_CREAT, 0660, initial_count);`
`278`	`278`	`if(m_handle == SEM_FAILED)`
`279`		`- throw std::runtime_error{"Can not create semaphore. " + std::string{strerror(errno)}};`
	`279`	`+ throw std::runtime_error{"Failed to create semaphore. " + std::string{strerror(errno)}};`
`280`	`280`	`}`
`281`	`281`
`282`	`282`	`~named_semaphore()`
`@@ -327,7 +327,7 @@ class timed_named_semaphore`
`327`	`327`
`328`	`328`	`m_handle = sem_open(std::data(native_name), O_CREAT, 0660, initial_count);`
`329`	`329`	`if(m_handle == SEM_FAILED)`
`330`		`- throw std::runtime_error{"Can not create semaphore. " + std::string{strerror(errno)}};`
	`330`	`+ throw std::runtime_error{"Failed to create semaphore. " + std::string{strerror(errno)}};`
`331`	`331`	`}`
`332`	`332`
`333`	`333`	`~timed_named_semaphore()`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ class semaphore`
`63`	`63`	`{`
`64`	`64`	`m_handle = CreateSemaphoreW(nullptr, static_cast<LONG>(initial_count), std::numeric_limits<LONG>::max(), nullptr);`
`65`	`65`	`if(!m_handle)`
`66`		`- throw std::runtime_error{"Can not create semaphore. " + get_error_message()};`
	`66`	`+ throw std::runtime_error{"Failed to create semaphore. " + get_error_message()};`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`~semaphore()`
`@@ -128,7 +128,7 @@ class timed_semaphore`
`128`	`128`	`{`
`129`	`129`	`m_handle = CreateSemaphoreW(nullptr, static_cast<LONG>(initial_count), std::numeric_limits<LONG>::max(), nullptr);`
`130`	`130`	`if(!m_handle)`
`131`		`- throw std::runtime_error{"Can not create semaphore. " + get_error_message()};`
	`131`	`+ throw std::runtime_error{"Failed to create semaphore. " + get_error_message()};`
`132`	`132`	`}`
`133`	`133`
`134`	`134`	`~timed_semaphore()`
`@@ -214,7 +214,7 @@ class semaphore`
`214`	`214`	`explicit semaphore(std::size_t initial_count = 0)`
`215`	`215`	`{`
`216`	`216`	`if(sem_init(m_handle.get(), 0, initial_count) != 0)`
`217`		`- throw std::runtime_error{"Can not create semaphore. " + std::string{strerror(errno)}};`
	`217`	`+ throw std::runtime_error{"Failed to create semaphore. " + std::string{strerror(errno)}};`
`218`	`218`	`}`
`219`	`219`
`220`	`220`	`~semaphore()`
`@@ -262,7 +262,7 @@ class timed_semaphore`
`262`	`262`	`explicit timed_semaphore(std::size_t initial_count = 0)`
`263`	`263`	`{`
`264`	`264`	`if(sem_init(m_handle.get(), 0, initial_count) != 0)`
`265`		`- throw std::runtime_error{"Can not create timed_semaphore. " + std::string{strerror(errno)}};`
	`265`	`+ throw std::runtime_error{"Failed to create timed_semaphore. " + std::string{strerror(errno)}};`
`266`	`266`	`}`
`267`	`267`
`268`	`268`	`~timed_semaphore()`
Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ class shared_library`
`64`	`64`	`{`
`65`	`65`	`m_handle = GetModuleHandleW(nullptr);`
`66`	`66`	`if(!m_handle)`
`67`		`- throw std::runtime_error{"Can not load current binary file. " + get_error_message()};`
	`67`	`+ throw std::runtime_error{"Failed to load current binary file. " + get_error_message()};`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`explicit shared_library(const std::string& path)`
`@@ -73,7 +73,7 @@ class shared_library`
`73`	`73`
`74`	`74`	`m_handle = LoadLibraryW(to_wide(path).c_str());`
`75`	`75`	`if(!m_handle)`
`76`		`- throw std::runtime_error{"Can not load binary file \"" + path + "\". " + get_error_message()};`
	`76`	`+ throw std::runtime_error{"Failed to load binary file \"" + path + "\". " + get_error_message()};`
`77`	`77`	`m_need_free = true;`
`78`	`78`	`}`
`79`	`79`
`@@ -131,7 +131,7 @@ class shared_library`
`131`	`131`	`out_path.resize(required_size);`
`132`	`132`
`133`	`133`	`if(!MultiByteToWideChar(CP_UTF8, 0, std::data(path), std::size(path), std::data(out_path), std::size(out_path)))`
`134`		`- throw std::runtime_error{"Can not convert the path to wide."};`
	`134`	`+ throw std::runtime_error{"Failed to convert the path to wide."};`
`135`	`135`
`136`	`136`	`return out_path;`
`137`	`137`	`}`
`@@ -176,7 +176,7 @@ class shared_library`
`176`	`176`	`{`
`177`	`177`	`m_handle = dlopen(nullptr, RTLD_NOW);`
`178`	`178`	`if(!m_handle)`
`179`		`- throw std::runtime_error{"Can not load current binary file. " + std::string{dlerror()}};`
	`179`	`+ throw std::runtime_error{"Failed to load current binary file. " + std::string{dlerror()}};`
`180`	`180`	`}`
`181`	`181`
`182`	`182`	`explicit shared_library(const std::string& path)`
`@@ -185,7 +185,7 @@ class shared_library`
`185`	`185`
`186`	`186`	`m_handle = dlopen(std::data(path), RTLD_NOW);`
`187`	`187`	`if(!m_handle)`
`188`		`- throw std::runtime_error{"Can not load binary file \"" + path + "\". " + std::string{dlerror()}};`
	`188`	`+ throw std::runtime_error{"Failed to load binary file \"" + path + "\". " + std::string{dlerror()}};`
`189`	`189`	`}`
`190`	`190`
`191`	`191`	`~shared_library()`