Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-06-30 02:31:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove template types from lock RAII wrapper usages (#1756)

Browse Source 
C++17 has template type autodeduction. These wrappers include
std::lock_guard and std::unique_lock.
This commit is contained in:
Tyler Veness
2019-07-07 19:17:14 -07:00
committed by Peter Johnson
parent e582518bae
commit 841ef5d739
90 changed files with 621 additions and 621 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
wpiutil/src/main/native/cpp/SafeThread.cpp
View File

@@ -29,7 +29,7 @@ detail::SafeThreadOwnerBase::~SafeThreadOwnerBase() {
}
void detail::SafeThreadOwnerBase::Start(std::shared_ptr<SafeThread> thr) {
std::lock_guard<wpi::mutex> lock(m_mutex);
std::lock_guard lock(m_mutex);
if (auto thr = m_thread.lock()) return;
m_stdThread = std::thread([=] { thr->Main(); });
thr->m_threadId = m_stdThread.get_id();
@@ -37,7 +37,7 @@ void detail::SafeThreadOwnerBase::Start(std::shared_ptr<SafeThread> thr) {
}
void detail::SafeThreadOwnerBase::Stop() {
std::lock_guard<wpi::mutex> lock(m_mutex);
std::lock_guard lock(m_mutex);
if (auto thr = m_thread.lock()) {
thr->m_active = false;
thr->m_cond.notify_all();
@@ -47,7 +47,7 @@ void detail::SafeThreadOwnerBase::Stop() {
}
void detail::SafeThreadOwnerBase::Join() {
std::unique_lock<wpi::mutex> lock(m_mutex);
std::unique_lock lock(m_mutex);
if (auto thr = m_thread.lock()) {
auto stdThread = std::move(m_stdThread);
m_thread.reset();
@@ -64,25 +64,25 @@ void detail::swap(SafeThreadOwnerBase& lhs, SafeThreadOwnerBase& rhs) noexcept {
using std::swap;
if (&lhs == &rhs) return;
std::lock(lhs.m_mutex, rhs.m_mutex);
std::lock_guard<wpi::mutex> lock_lhs(lhs.m_mutex, std::adopt_lock);
std::lock_guard<wpi::mutex> lock_rhs(rhs.m_mutex, std::adopt_lock);
std::lock_guard lock_lhs(lhs.m_mutex, std::adopt_lock);
std::lock_guard lock_rhs(rhs.m_mutex, std::adopt_lock);
std::swap(lhs.m_stdThread, rhs.m_stdThread);
std::swap(lhs.m_thread, rhs.m_thread);
}
detail::SafeThreadOwnerBase::operator bool() const {
std::lock_guard<wpi::mutex> lock(m_mutex);
std::lock_guard lock(m_mutex);
return !m_thread.expired();
}
std::thread::native_handle_type
detail::SafeThreadOwnerBase::GetNativeThreadHandle() {
std::lock_guard<wpi::mutex> lock(m_mutex);
std::lock_guard lock(m_mutex);
return m_stdThread.native_handle();
}
std::shared_ptr<SafeThread> detail::SafeThreadOwnerBase::GetThreadSharedPtr()
const {
std::lock_guard<wpi::mutex> lock(m_mutex);
std::lock_guard lock(m_mutex);
return m_thread.lock();
}

12
wpiutil/src/main/native/cpp/TCPConnector_parallel.cpp
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2017-2018 FIRST. All Rights Reserved. */
/* Copyright (c) 2017-2019 FIRST. All Rights Reserved. */
/* Open Source Software - may be modified and shared by FRC teams. The code */
/* must be accompanied by the FIRST BSD license file in the root directory of */
/* the project. */
@@ -74,7 +74,7 @@ std::unique_ptr<NetworkStream> TCPConnector::connect_parallel(
// don't start a new worker if we had a previously still-active connection
// attempt to the same server
{
std::lock_guard<wpi::mutex> lock(local->mtx);
std::lock_guard lock(local->mtx);
if (local->active.count(active_tracker) > 0) continue; // already in set
}
@@ -85,7 +85,7 @@ std::unique_ptr<NetworkStream> TCPConnector::connect_parallel(
if (!result->done) {
// add to global state
{
std::lock_guard<wpi::mutex> lock(local->mtx);
std::lock_guard lock(local->mtx);
local->active.insert(active_tracker);
}
@@ -95,13 +95,13 @@ std::unique_ptr<NetworkStream> TCPConnector::connect_parallel(
// remove from global state
{
std::lock_guard<wpi::mutex> lock(local->mtx);
std::lock_guard lock(local->mtx);
local->active.erase(active_tracker);
}
// successful connection
if (stream) {
std::lock_guard<wpi::mutex> lock(result->mtx);
std::lock_guard lock(result->mtx);
if (!result->done.exchange(true)) result->stream = std::move(stream);
}
}
@@ -112,7 +112,7 @@ std::unique_ptr<NetworkStream> TCPConnector::connect_parallel(
}
// wait for a result, timeout, or all finished
std::unique_lock<wpi::mutex> lock(result->mtx);
std::unique_lock lock(result->mtx);
if (timeout == 0) {
result->cv.wait(
lock, [&] { return result->stream || result->count >= num_workers; });

18
wpiutil/src/main/native/cpp/future.cpp
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2018 FIRST. All Rights Reserved. */
/* Copyright (c) 2018-2019 FIRST. All Rights Reserved. */
/* Open Source Software - may be modified and shared by FRC teams. The code */
/* must be accompanied by the FIRST BSD license file in the root directory of */
/* the project. */
@@ -16,12 +16,12 @@ PromiseFactoryBase::~PromiseFactoryBase() {
}
void PromiseFactoryBase::IgnoreResult(uint64_t request) {
std::unique_lock<wpi::mutex> lock(m_resultMutex);
std::unique_lock lock(m_resultMutex);
EraseRequest(request);
}
uint64_t PromiseFactoryBase::CreateRequest() {
std::unique_lock<wpi::mutex> lock(m_resultMutex);
std::unique_lock lock(m_resultMutex);
uint64_t req = ++m_uid;
m_requests.push_back(req);
return req;
@@ -39,14 +39,14 @@ bool PromiseFactoryBase::EraseRequest(uint64_t request) {
} // namespace detail
future<void> PromiseFactory<void>::MakeReadyFuture() {
std::unique_lock<wpi::mutex> lock(GetResultMutex());
std::unique_lock lock(GetResultMutex());
uint64_t req = CreateErasedRequest();
m_results.emplace_back(req);
return future<void>{this, req};
}
void PromiseFactory<void>::SetValue(uint64_t request) {
std::unique_lock<wpi::mutex> lock(GetResultMutex());
std::unique_lock lock(GetResultMutex());
if (!EraseRequest(request)) return;
auto it = std::find_if(m_thens.begin(), m_thens.end(),
[=](const auto& x) { return x.request == request; });
@@ -63,7 +63,7 @@ void PromiseFactory<void>::SetValue(uint64_t request) {
void PromiseFactory<void>::SetThen(uint64_t request, uint64_t outRequest,
ThenFunction func) {
std::unique_lock<wpi::mutex> lock(GetResultMutex());
std::unique_lock lock(GetResultMutex());
auto it = std::find_if(m_results.begin(), m_results.end(),
[=](const auto& r) { return r == request; });
if (it != m_results.end()) {
@@ -75,7 +75,7 @@ void PromiseFactory<void>::SetThen(uint64_t request, uint64_t outRequest,
}
bool PromiseFactory<void>::IsReady(uint64_t request) noexcept {
std::unique_lock<wpi::mutex> lock(GetResultMutex());
std::unique_lock lock(GetResultMutex());
auto it = std::find_if(m_results.begin(), m_results.end(),
[=](const auto& r) { return r == request; });
return it != m_results.end();
@@ -83,7 +83,7 @@ bool PromiseFactory<void>::IsReady(uint64_t request) noexcept {
void PromiseFactory<void>::GetResult(uint64_t request) {
// wait for response
std::unique_lock<wpi::mutex> lock(GetResultMutex());
std::unique_lock lock(GetResultMutex());
while (IsActive()) {
// Did we get a response to *our* request?
auto it = std::find_if(m_results.begin(), m_results.end(),
@@ -100,7 +100,7 @@ void PromiseFactory<void>::GetResult(uint64_t request) {
void PromiseFactory<void>::WaitResult(uint64_t request) {
// wait for response
std::unique_lock<wpi::mutex> lock(GetResultMutex());
std::unique_lock lock(GetResultMutex());
while (IsActive()) {
// Did we get a response to *our* request?
auto it = std::find_if(m_results.begin(), m_results.end(),

12
wpiutil/src/main/native/cpp/llvm/ErrorHandling.cpp
View File

@@ -55,14 +55,14 @@ static std::mutex BadAllocErrorHandlerMutex;
void wpi::install_fatal_error_handler(fatal_error_handler_t handler,
void *user_data) {
std::lock_guard<std::mutex> Lock(ErrorHandlerMutex);
std::lock_guard Lock(ErrorHandlerMutex);
assert(!ErrorHandler && "Error handler already registered!\n");
ErrorHandler = handler;
ErrorHandlerUserData = user_data;
}
void wpi::remove_fatal_error_handler() {
std::lock_guard<std::mutex> Lock(ErrorHandlerMutex);
std::lock_guard Lock(ErrorHandlerMutex);
ErrorHandler = nullptr;
ErrorHandlerUserData = nullptr;
}
@@ -85,7 +85,7 @@ void wpi::report_fatal_error(const Twine &Reason, bool GenCrashDiag) {
{
// Only acquire the mutex while reading the handler, so as not to invoke a
// user-supplied callback under a lock.
std::lock_guard<std::mutex> Lock(ErrorHandlerMutex);
std::lock_guard Lock(ErrorHandlerMutex);
handler = ErrorHandler;
handlerData = ErrorHandlerUserData;
}
@@ -113,14 +113,14 @@ void wpi::report_fatal_error(const Twine &Reason, bool GenCrashDiag) {
void wpi::install_bad_alloc_error_handler(fatal_error_handler_t handler,
void *user_data) {
std::lock_guard<std::mutex> Lock(BadAllocErrorHandlerMutex);
std::lock_guard Lock(BadAllocErrorHandlerMutex);
assert(!ErrorHandler && "Bad alloc error handler already registered!\n");
BadAllocErrorHandler = handler;
BadAllocErrorHandlerUserData = user_data;
}
void wpi::remove_bad_alloc_error_handler() {
std::lock_guard<std::mutex> Lock(BadAllocErrorHandlerMutex);
std::lock_guard Lock(BadAllocErrorHandlerMutex);
BadAllocErrorHandler = nullptr;
BadAllocErrorHandlerUserData = nullptr;
}
@@ -131,7 +131,7 @@ void wpi::report_bad_alloc_error(const char *Reason, bool GenCrashDiag) {
{
// Only acquire the mutex while reading the handler, so as not to invoke a
// user-supplied callback under a lock.
std::lock_guard<std::mutex> Lock(BadAllocErrorHandlerMutex);
std::lock_guard Lock(BadAllocErrorHandlerMutex);
Handler = BadAllocErrorHandler;
HandlerData = BadAllocErrorHandlerUserData;
}

4
wpiutil/src/main/native/cpp/llvm/ManagedStatic.cpp
View File

@@ -33,7 +33,7 @@ static wpi::mutex* getManagedStaticMutex() {
void ManagedStaticBase::RegisterManagedStatic(void *(*Creator)(),
void (*Deleter)(void*)) const {
assert(Creator);
std::lock_guard<wpi::mutex> Lock(*getManagedStaticMutex());
std::lock_guard Lock(*getManagedStaticMutex());
if (!Ptr.load(std::memory_order_relaxed)) {
void *Tmp = Creator();
@@ -65,7 +65,7 @@ void ManagedStaticBase::destroy() const {
/// wpi_shutdown - Deallocate and destroy all ManagedStatic variables.
void wpi::wpi_shutdown() {
std::lock_guard<wpi::mutex> Lock(*getManagedStaticMutex());
std::lock_guard Lock(*getManagedStaticMutex());
while (StaticList)
StaticList->destroy();

2
wpiutil/src/main/native/include/wpi/WorkerThread.h
View File

@@ -131,7 +131,7 @@ template <typename R, typename... T>
void WorkerThreadThread<R, T...>::Main() {
std::vector<Request> requests;
while (m_active) {
std::unique_lock<wpi::mutex> lock(m_mutex);
std::unique_lock lock(m_mutex);
m_cond.wait(lock, [&] { return !m_active || !m_requests.empty(); });
if (!m_active) break;

20
wpiutil/src/main/native/include/wpi/future.h
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2018 FIRST. All Rights Reserved. */
/* Copyright (c) 2018-2019 FIRST. All Rights Reserved. */
/* Open Source Software - may be modified and shared by FRC teams. The code */
/* must be accompanied by the FIRST BSD license file in the root directory of */
/* the project. */
@@ -695,7 +695,7 @@ inline future<T> PromiseFactory<T>::CreateFuture(uint64_t request) {
template <typename T>
future<T> PromiseFactory<T>::MakeReadyFuture(T&& value) {
std::unique_lock<wpi::mutex> lock(GetResultMutex());
std::unique_lock lock(GetResultMutex());
uint64_t req = CreateErasedRequest();
m_results.emplace_back(std::piecewise_construct, std::forward_as_tuple(req),
std::forward_as_tuple(std::move(value)));
@@ -709,7 +709,7 @@ inline promise<T> PromiseFactory<T>::CreatePromise(uint64_t request) {
template <typename T>
void PromiseFactory<T>::SetValue(uint64_t request, const T& value) {
std::unique_lock<wpi::mutex> lock(GetResultMutex());
std::unique_lock lock(GetResultMutex());
if (!EraseRequest(request)) return;
auto it = std::find_if(m_thens.begin(), m_thens.end(),
[=](const auto& x) { return x.request == request; });
@@ -728,7 +728,7 @@ void PromiseFactory<T>::SetValue(uint64_t request, const T& value) {
template <typename T>
void PromiseFactory<T>::SetValue(uint64_t request, T&& value) {
std::unique_lock<wpi::mutex> lock(GetResultMutex());
std::unique_lock lock(GetResultMutex());
if (!EraseRequest(request)) return;
auto it = std::find_if(m_thens.begin(), m_thens.end(),
[=](const auto& x) { return x.request == request; });
@@ -748,7 +748,7 @@ void PromiseFactory<T>::SetValue(uint64_t request, T&& value) {
template <typename T>
void PromiseFactory<T>::SetThen(uint64_t request, uint64_t outRequest,
ThenFunction func) {
std::unique_lock<wpi::mutex> lock(GetResultMutex());
std::unique_lock lock(GetResultMutex());
auto it = std::find_if(m_results.begin(), m_results.end(),
[=](const auto& r) { return r.first == request; });
if (it != m_results.end()) {
@@ -762,7 +762,7 @@ void PromiseFactory<T>::SetThen(uint64_t request, uint64_t outRequest,
template <typename T>
bool PromiseFactory<T>::IsReady(uint64_t request) noexcept {
std::unique_lock<wpi::mutex> lock(GetResultMutex());
std::unique_lock lock(GetResultMutex());
auto it = std::find_if(m_results.begin(), m_results.end(),
[=](const auto& r) { return r.first == request; });
return it != m_results.end();
@@ -771,7 +771,7 @@ bool PromiseFactory<T>::IsReady(uint64_t request) noexcept {
template <typename T>
T PromiseFactory<T>::GetResult(uint64_t request) {
// wait for response
std::unique_lock<wpi::mutex> lock(GetResultMutex());
std::unique_lock lock(GetResultMutex());
while (IsActive()) {
// Did we get a response to *our* request?
auto it = std::find_if(m_results.begin(), m_results.end(),
@@ -791,7 +791,7 @@ T PromiseFactory<T>::GetResult(uint64_t request) {
template <typename T>
void PromiseFactory<T>::WaitResult(uint64_t request) {
// wait for response
std::unique_lock<wpi::mutex> lock(GetResultMutex());
std::unique_lock lock(GetResultMutex());
while (IsActive()) {
// Did we get a response to *our* request?
auto it = std::find_if(m_results.begin(), m_results.end(),
@@ -807,7 +807,7 @@ template <class Clock, class Duration>
bool PromiseFactory<T>::WaitResultUntil(
uint64_t request,
const std::chrono::time_point<Clock, Duration>& timeout_time) {
std::unique_lock<wpi::mutex> lock(GetResultMutex());
std::unique_lock lock(GetResultMutex());
bool timeout = false;
while (IsActive()) {
// Did we get a response to *our* request?
@@ -839,7 +839,7 @@ template <class Clock, class Duration>
bool PromiseFactory<void>::WaitResultUntil(
uint64_t request,
const std::chrono::time_point<Clock, Duration>& timeout_time) {
std::unique_lock<wpi::mutex> lock(GetResultMutex());
std::unique_lock lock(GetResultMutex());
bool timeout = false;
while (IsActive()) {
// Did we get a response to *our* request?

2
wpiutil/src/main/native/include/wpi/jni_util.h
View File

@@ -508,7 +508,7 @@ void JCallbackThread<T>::Main() {
reinterpret_cast<void**>(&env), &args);
if (rs != JNI_OK) return;
std::unique_lock<wpi::mutex> lock(m_mutex);
std::unique_lock lock(m_mutex);
while (m_active) {
m_cond.wait(lock, [&] { return !(m_active && m_queue.empty()); });
if (!m_active) break;

4
wpiutil/src/main/native/include/wpi/uv/Async.h
View File

@@ -68,7 +68,7 @@ class Async final : public HandleImpl<Async<T...>, uv_async_t> {
int err =
uv_async_init(loop->GetRaw(), h->GetRaw(), [](uv_async_t* handle) {
auto& h = *static_cast<Async*>(handle->data);
std::lock_guard<wpi::mutex> lock(h.m_mutex);
std::lock_guard lock(h.m_mutex);
for (auto&& v : h.m_data) std::apply(h.wakeup, v);
h.m_data.clear();
});
@@ -96,7 +96,7 @@ class Async final : public HandleImpl<Async<T...>, uv_async_t> {
}
{
std::lock_guard<wpi::mutex> lock(m_mutex);
std::lock_guard lock(m_mutex);
m_data.emplace_back(std::forward_as_tuple(std::forward<U>(u)...));
}
if (loop) this->Invoke(&uv_async_send, this->GetRaw());

4
wpiutil/src/main/native/include/wpi/uv/AsyncFunction.h
View File

@@ -81,7 +81,7 @@ class AsyncFunction<R(T...)> final
int err =
uv_async_init(loop->GetRaw(), h->GetRaw(), [](uv_async_t* handle) {
auto& h = *static_cast<AsyncFunction*>(handle->data);
std::unique_lock<wpi::mutex> lock(h.m_mutex);
std::unique_lock lock(h.m_mutex);
if (!h.m_params.empty()) {
// for each set of parameters in the input queue, call the wakeup
@@ -132,7 +132,7 @@ class AsyncFunction<R(T...)> final
// add the parameters to the input queue
{
std::lock_guard<wpi::mutex> lock(m_mutex);
std::lock_guard lock(m_mutex);
m_params.emplace_back(std::piecewise_construct,
std::forward_as_tuple(req),
std::forward_as_tuple(std::forward<U>(u)...));