mirror of
https://github.com/PabloMK7/citra
synced 2024-11-15 13:18:24 +00:00
Merge pull request #4726 from FearlessTobi/port-2312
Port yuzu-emu/yuzu#2312: "general: Use deducation guides for std::lock_guard and std::unique_lock"
This commit is contained in:
Weiyi Wang
GitHub
commit
4a206237be
21 changed files with 124 additions and 122 deletions
|
|
@ -59,7 +59,7 @@ void EmuThread::run() {
|
|||
|
||||
was_active = false;
|
||||
} else {
|
||||
std::unique_lock<std::mutex> lock(running_mutex);
|
||||
std::unique_lock lock{running_mutex};
|
||||
running_cv.wait(lock, [this] { return IsRunning() || exec_step || stop_run; });
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ public:
|
|||
* @note This function is thread-safe
|
||||
*/
|
||||
void SetRunning(bool running) {
|
||||
std::unique_lock<std::mutex> lock(running_mutex);
|
||||
std::unique_lock lock{running_mutex};
|
||||
this->running = running;
|
||||
lock.unlock();
|
||||
running_cv.notify_all();
|
||||
|
|
|
|||
|
|
@ -16,22 +16,22 @@ DetachedTasks::DetachedTasks() {
|
|||
}
|
||||
|
||||
void DetachedTasks::WaitForAllTasks() {
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
std::unique_lock lock{mutex};
|
||||
cv.wait(lock, [this]() { return count == 0; });
|
||||
}
|
||||
|
||||
DetachedTasks::~DetachedTasks() {
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
std::unique_lock lock{mutex};
|
||||
ASSERT(count == 0);
|
||||
instance = nullptr;
|
||||
}
|
||||
|
||||
void DetachedTasks::AddTask(std::function<void()> task) {
|
||||
std::unique_lock<std::mutex> lock(instance->mutex);
|
||||
std::unique_lock lock{instance->mutex};
|
||||
++instance->count;
|
||||
std::thread([task{std::move(task)}]() {
|
||||
task();
|
||||
std::unique_lock<std::mutex> lock(instance->mutex);
|
||||
std::unique_lock lock{instance->mutex};
|
||||
--instance->count;
|
||||
std::notify_all_at_thread_exit(instance->cv, std::move(lock));
|
||||
})
|
||||
|
|
|
|||
|
|
@ -46,12 +46,12 @@ public:
|
|||
}
|
||||
|
||||
void AddBackend(std::unique_ptr<Backend> backend) {
|
||||
std::lock_guard<std::mutex> lock(writing_mutex);
|
||||
std::lock_guard lock{writing_mutex};
|
||||
backends.push_back(std::move(backend));
|
||||
}
|
||||
|
||||
void RemoveBackend(std::string_view backend_name) {
|
||||
std::lock_guard<std::mutex> lock(writing_mutex);
|
||||
std::lock_guard lock{writing_mutex};
|
||||
const auto it =
|
||||
std::remove_if(backends.begin(), backends.end(),
|
||||
[&backend_name](const auto& i) { return backend_name == i->GetName(); });
|
||||
|
|
@ -80,7 +80,7 @@ private:
|
|||
backend_thread = std::thread([&] {
|
||||
Entry entry;
|
||||
auto write_logs = [&](Entry& e) {
|
||||
std::lock_guard<std::mutex> lock(writing_mutex);
|
||||
std::lock_guard lock{writing_mutex};
|
||||
for (const auto& backend : backends) {
|
||||
backend->Write(e);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ namespace Common {
|
|||
class Event {
|
||||
public:
|
||||
void Set() {
|
||||
std::lock_guard<std::mutex> lk(mutex);
|
||||
std::lock_guard lk{mutex};
|
||||
if (!is_set) {
|
||||
is_set = true;
|
||||
condvar.notify_one();
|
||||
|
|
@ -24,14 +24,14 @@ public:
|
|||
}
|
||||
|
||||
void Wait() {
|
||||
std::unique_lock<std::mutex> lk(mutex);
|
||||
std::unique_lock lk{mutex};
|
||||
condvar.wait(lk, [&] { return is_set; });
|
||||
is_set = false;
|
||||
}
|
||||
|
||||
template <class Duration>
|
||||
bool WaitFor(const std::chrono::duration<Duration>& time) {
|
||||
std::unique_lock<std::mutex> lk(mutex);
|
||||
std::unique_lock lk(mutex);
|
||||
if (!condvar.wait_for(lk, time, [this] { return is_set; }))
|
||||
return false;
|
||||
is_set = false;
|
||||
|
|
@ -40,7 +40,7 @@ public:
|
|||
|
||||
template <class Clock, class Duration>
|
||||
bool WaitUntil(const std::chrono::time_point<Clock, Duration>& time) {
|
||||
std::unique_lock<std::mutex> lk(mutex);
|
||||
std::unique_lock lk{mutex};
|
||||
if (!condvar.wait_until(lk, time, [this] { return is_set; }))
|
||||
return false;
|
||||
is_set = false;
|
||||
|
|
@ -48,7 +48,7 @@ public:
|
|||
}
|
||||
|
||||
void Reset() {
|
||||
std::unique_lock<std::mutex> lk(mutex);
|
||||
std::unique_lock lk{mutex};
|
||||
// no other action required, since wait loops on the predicate and any lingering signal will
|
||||
// get cleared on the first iteration
|
||||
is_set = false;
|
||||
|
|
@ -66,7 +66,7 @@ public:
|
|||
|
||||
/// Blocks until all "count" threads have called Sync()
|
||||
void Sync() {
|
||||
std::unique_lock<std::mutex> lk(mutex);
|
||||
std::unique_lock lk{mutex};
|
||||
const std::size_t current_generation = generation;
|
||||
|
||||
if (++waiting == count) {
|
||||
|
|
@ -80,7 +80,7 @@ public:
|
|||
}
|
||||
|
||||
std::size_t Generation() const {
|
||||
std::unique_lock<std::mutex> lk(mutex);
|
||||
std::unique_lock lk(mutex);
|
||||
return generation;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -78,7 +78,7 @@ public:
|
|||
|
||||
T PopWait() {
|
||||
if (Empty()) {
|
||||
std::unique_lock<std::mutex> lock(cv_mutex);
|
||||
std::unique_lock lock{cv_mutex};
|
||||
cv.wait(lock, [this]() { return !Empty(); });
|
||||
}
|
||||
T t;
|
||||
|
|
@ -137,7 +137,7 @@ public:
|
|||
|
||||
template <typename Arg>
|
||||
void Push(Arg&& t) {
|
||||
std::lock_guard<std::mutex> lock(write_lock);
|
||||
std::lock_guard lock{write_lock};
|
||||
spsc_queue.Push(t);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -65,14 +65,14 @@ void AnnounceMultiplayerSession::Stop() {
|
|||
|
||||
AnnounceMultiplayerSession::CallbackHandle AnnounceMultiplayerSession::BindErrorCallback(
|
||||
std::function<void(const Common::WebResult&)> function) {
|
||||
std::lock_guard<std::mutex> lock(callback_mutex);
|
||||
std::lock_guard lock(callback_mutex);
|
||||
auto handle = std::make_shared<std::function<void(const Common::WebResult&)>>(function);
|
||||
error_callbacks.insert(handle);
|
||||
return handle;
|
||||
}
|
||||
|
||||
void AnnounceMultiplayerSession::UnbindErrorCallback(CallbackHandle handle) {
|
||||
std::lock_guard<std::mutex> lock(callback_mutex);
|
||||
std::lock_guard lock(callback_mutex);
|
||||
error_callbacks.erase(handle);
|
||||
}
|
||||
|
||||
|
|
@ -112,7 +112,7 @@ void AnnounceMultiplayerSession::AnnounceMultiplayerLoop() {
|
|||
UpdateBackendData(room);
|
||||
Common::WebResult result = backend->Update();
|
||||
if (result.result_code != Common::WebResult::Code::Success) {
|
||||
std::lock_guard<std::mutex> lock(callback_mutex);
|
||||
std::lock_guard lock(callback_mutex);
|
||||
for (auto callback : error_callbacks) {
|
||||
(*callback)(result);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@ private:
|
|||
explicit Device(std::weak_ptr<TouchState>&& touch_state) : touch_state(touch_state) {}
|
||||
std::tuple<float, float, bool> GetStatus() const override {
|
||||
if (auto state = touch_state.lock()) {
|
||||
std::lock_guard<std::mutex> guard(state->mutex);
|
||||
std::lock_guard guard{state->mutex};
|
||||
return std::make_tuple(state->touch_x, state->touch_y, state->touch_pressed);
|
||||
}
|
||||
return std::make_tuple(0.0f, 0.0f, false);
|
||||
|
|
@ -98,7 +98,7 @@ void EmuWindow::TouchPressed(unsigned framebuffer_x, unsigned framebuffer_y) {
|
|||
|
||||
if (Settings::values.toggle_3d && framebuffer_x >= framebuffer_layout.width / 2)
|
||||
framebuffer_x -= framebuffer_layout.width / 2;
|
||||
std::lock_guard<std::mutex> guard(touch_state->mutex);
|
||||
std::lock_guard guard(touch_state->mutex);
|
||||
if (Settings::values.toggle_3d) {
|
||||
touch_state->touch_x =
|
||||
static_cast<float>(framebuffer_x - framebuffer_layout.bottom_screen.left / 2) /
|
||||
|
|
@ -117,7 +117,7 @@ void EmuWindow::TouchPressed(unsigned framebuffer_x, unsigned framebuffer_y) {
|
|||
}
|
||||
|
||||
void EmuWindow::TouchReleased() {
|
||||
std::lock_guard<std::mutex> guard(touch_state->mutex);
|
||||
std::lock_guard guard{touch_state->mutex};
|
||||
touch_state->touch_pressed = false;
|
||||
touch_state->touch_x = 0;
|
||||
touch_state->touch_y = 0;
|
||||
|
|
|
|||
|
|
@ -1575,7 +1575,7 @@ void SVC::CallSVC(u32 immediate) {
|
|||
MICROPROFILE_SCOPE(Kernel_SVC);
|
||||
|
||||
// Lock the global kernel mutex when we enter the kernel HLE.
|
||||
std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
|
||||
std::lock_guard lock{HLE::g_hle_lock};
|
||||
|
||||
DEBUG_ASSERT_MSG(kernel.GetCurrentProcess()->status == ProcessStatus::Running,
|
||||
"Running threads from exiting processes is unimplemented");
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@ constexpr u16 BroadcastNetworkNodeId = 0xFFFF;
|
|||
constexpr u16 HostDestNodeId = 1;
|
||||
|
||||
std::list<Network::WifiPacket> NWM_UDS::GetReceivedBeacons(const MacAddress& sender) {
|
||||
std::lock_guard<std::mutex> lock(beacon_mutex);
|
||||
std::lock_guard lock(beacon_mutex);
|
||||
if (sender != Network::BroadcastMac) {
|
||||
std::list<Network::WifiPacket> filtered_list;
|
||||
const auto beacon = std::find_if(received_beacons.begin(), received_beacons.end(),
|
||||
|
|
@ -107,7 +107,7 @@ void NWM_UDS::BroadcastNodeMap() {
|
|||
}
|
||||
|
||||
void NWM_UDS::HandleNodeMapPacket(const Network::WifiPacket& packet) {
|
||||
std::lock_guard<std::mutex> lock(connection_status_mutex);
|
||||
std::lock_guard lock(connection_status_mutex);
|
||||
if (connection_status.status == static_cast<u32>(NetworkStatus::ConnectedAsHost)) {
|
||||
LOG_DEBUG(Service_NWM, "Ignored NodeMapPacket since connection_status is host");
|
||||
return;
|
||||
|
|
@ -129,7 +129,7 @@ void NWM_UDS::HandleNodeMapPacket(const Network::WifiPacket& packet) {
|
|||
}
|
||||
|
||||
void NWM_UDS::HandleBeaconFrame(const Network::WifiPacket& packet) {
|
||||
std::lock_guard<std::mutex> lock(beacon_mutex);
|
||||
std::lock_guard lock(beacon_mutex);
|
||||
const auto unique_beacon =
|
||||
std::find_if(received_beacons.begin(), received_beacons.end(),
|
||||
[&packet](const Network::WifiPacket& new_packet) {
|
||||
|
|
@ -153,7 +153,7 @@ void NWM_UDS::HandleAssociationResponseFrame(const Network::WifiPacket& packet)
|
|||
ASSERT_MSG(std::get<AssocStatus>(assoc_result) == AssocStatus::Successful,
|
||||
"Could not join network");
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(connection_status_mutex);
|
||||
std::lock_guard lock(connection_status_mutex);
|
||||
if (connection_status.status != static_cast<u32>(NetworkStatus::Connecting)) {
|
||||
LOG_DEBUG(Service_NWM,
|
||||
"Ignored AssociationResponseFrame because connection status is {}",
|
||||
|
|
@ -175,8 +175,8 @@ void NWM_UDS::HandleAssociationResponseFrame(const Network::WifiPacket& packet)
|
|||
}
|
||||
|
||||
void NWM_UDS::HandleEAPoLPacket(const Network::WifiPacket& packet) {
|
||||
std::unique_lock<std::recursive_mutex> hle_lock(HLE::g_hle_lock, std::defer_lock);
|
||||
std::unique_lock<std::mutex> lock(connection_status_mutex, std::defer_lock);
|
||||
std::unique_lock hle_lock(HLE::g_hle_lock, std::defer_lock);
|
||||
std::unique_lock lock(connection_status_mutex, std::defer_lock);
|
||||
std::lock(hle_lock, lock);
|
||||
|
||||
if (GetEAPoLFrameType(packet.data) == EAPoLStartMagic) {
|
||||
|
|
@ -295,8 +295,8 @@ void NWM_UDS::HandleEAPoLPacket(const Network::WifiPacket& packet) {
|
|||
|
||||
void NWM_UDS::HandleSecureDataPacket(const Network::WifiPacket& packet) {
|
||||
auto secure_data = ParseSecureDataHeader(packet.data);
|
||||
std::unique_lock<std::recursive_mutex> hle_lock(HLE::g_hle_lock, std::defer_lock);
|
||||
std::unique_lock<std::mutex> lock(connection_status_mutex, std::defer_lock);
|
||||
std::unique_lock hle_lock(HLE::g_hle_lock, std::defer_lock);
|
||||
std::unique_lock lock(connection_status_mutex, std::defer_lock);
|
||||
std::lock(hle_lock, lock);
|
||||
|
||||
if (connection_status.status != static_cast<u32>(NetworkStatus::ConnectedAsHost) &&
|
||||
|
|
@ -358,7 +358,7 @@ void NWM_UDS::StartConnectionSequence(const MacAddress& server) {
|
|||
using Network::WifiPacket;
|
||||
WifiPacket auth_request;
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(connection_status_mutex);
|
||||
std::lock_guard lock(connection_status_mutex);
|
||||
connection_status.status = static_cast<u32>(NetworkStatus::Connecting);
|
||||
|
||||
// TODO(Subv): Handle timeout.
|
||||
|
|
@ -378,7 +378,7 @@ void NWM_UDS::SendAssociationResponseFrame(const MacAddress& address) {
|
|||
WifiPacket assoc_response;
|
||||
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(connection_status_mutex);
|
||||
std::lock_guard lock(connection_status_mutex);
|
||||
if (connection_status.status != static_cast<u32>(NetworkStatus::ConnectedAsHost)) {
|
||||
LOG_ERROR(Service_NWM, "Connection sequence aborted, because connection status is {}",
|
||||
connection_status.status);
|
||||
|
|
@ -404,7 +404,7 @@ void NWM_UDS::HandleAuthenticationFrame(const Network::WifiPacket& packet) {
|
|||
using Network::WifiPacket;
|
||||
WifiPacket auth_request;
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(connection_status_mutex);
|
||||
std::lock_guard lock(connection_status_mutex);
|
||||
if (connection_status.status != static_cast<u32>(NetworkStatus::ConnectedAsHost)) {
|
||||
LOG_ERROR(Service_NWM,
|
||||
"Connection sequence aborted, because connection status is {}",
|
||||
|
|
@ -438,8 +438,8 @@ void NWM_UDS::HandleAuthenticationFrame(const Network::WifiPacket& packet) {
|
|||
|
||||
void NWM_UDS::HandleDeauthenticationFrame(const Network::WifiPacket& packet) {
|
||||
LOG_DEBUG(Service_NWM, "called");
|
||||
std::unique_lock<std::recursive_mutex> hle_lock(HLE::g_hle_lock, std::defer_lock);
|
||||
std::unique_lock<std::mutex> lock(connection_status_mutex, std::defer_lock);
|
||||
std::unique_lock hle_lock(HLE::g_hle_lock, std::defer_lock);
|
||||
std::unique_lock lock(connection_status_mutex, std::defer_lock);
|
||||
std::lock(hle_lock, lock);
|
||||
if (connection_status.status != static_cast<u32>(NetworkStatus::ConnectedAsHost)) {
|
||||
LOG_ERROR(Service_NWM, "Got deauthentication frame but we are not the host");
|
||||
|
|
@ -633,7 +633,7 @@ ResultVal<std::shared_ptr<Kernel::Event>> NWM_UDS::Initialize(
|
|||
}
|
||||
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(connection_status_mutex);
|
||||
std::lock_guard lock(connection_status_mutex);
|
||||
|
||||
// Reset the connection status, it contains all zeros after initialization,
|
||||
// except for the actual status value.
|
||||
|
|
@ -686,7 +686,7 @@ void NWM_UDS::GetConnectionStatus(Kernel::HLERequestContext& ctx) {
|
|||
|
||||
rb.Push(RESULT_SUCCESS);
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(connection_status_mutex);
|
||||
std::lock_guard lock(connection_status_mutex);
|
||||
rb.PushRaw(connection_status);
|
||||
|
||||
// Reset the bitmask of changed nodes after each call to this
|
||||
|
|
@ -711,7 +711,7 @@ void NWM_UDS::GetNodeInformation(Kernel::HLERequestContext& ctx) {
|
|||
}
|
||||
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(connection_status_mutex);
|
||||
std::lock_guard lock(connection_status_mutex);
|
||||
auto itr = std::find_if(node_info.begin(), node_info.end(),
|
||||
[network_node_id](const NodeInfo& node) {
|
||||
return node.network_node_id == network_node_id;
|
||||
|
|
@ -770,7 +770,7 @@ void NWM_UDS::Bind(Kernel::HLERequestContext& ctx) {
|
|||
// Create a new event for this bind node.
|
||||
auto event = system.Kernel().CreateEvent(Kernel::ResetType::OneShot,
|
||||
"NWM::BindNodeEvent" + std::to_string(bind_node_id));
|
||||
std::lock_guard<std::mutex> lock(connection_status_mutex);
|
||||
std::lock_guard lock(connection_status_mutex);
|
||||
|
||||
ASSERT(channel_data.find(data_channel) == channel_data.end());
|
||||
// TODO(B3N30): Support more than one bind node per channel.
|
||||
|
|
@ -792,7 +792,7 @@ void NWM_UDS::Unbind(Kernel::HLERequestContext& ctx) {
|
|||
return;
|
||||
}
|
||||
|
||||
std::lock_guard<std::mutex> lock(connection_status_mutex);
|
||||
std::lock_guard lock(connection_status_mutex);
|
||||
|
||||
auto itr =
|
||||
std::find_if(channel_data.begin(), channel_data.end(), [bind_node_id](const auto& data) {
|
||||
|
|
@ -819,7 +819,7 @@ ResultCode NWM_UDS::BeginHostingNetwork(const u8* network_info_buffer,
|
|||
// TODO(Subv): Store the passphrase and verify it when attempting a connection.
|
||||
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(connection_status_mutex);
|
||||
std::lock_guard lock(connection_status_mutex);
|
||||
network_info = {};
|
||||
std::memcpy(&network_info, network_info_buffer, network_info_size);
|
||||
|
||||
|
|
@ -933,7 +933,7 @@ void NWM_UDS::DestroyNetwork(Kernel::HLERequestContext& ctx) {
|
|||
system.CoreTiming().UnscheduleEvent(beacon_broadcast_event, 0);
|
||||
|
||||
// Only a host can destroy
|
||||
std::lock_guard<std::mutex> lock(connection_status_mutex);
|
||||
std::lock_guard lock(connection_status_mutex);
|
||||
if (connection_status.status != static_cast<u8>(NetworkStatus::ConnectedAsHost)) {
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
|
||||
rb.Push(ResultCode(ErrCodes::WrongStatus, ErrorModule::UDS, ErrorSummary::InvalidState,
|
||||
|
|
@ -970,7 +970,7 @@ void NWM_UDS::DisconnectNetwork(Kernel::HLERequestContext& ctx) {
|
|||
using Network::WifiPacket;
|
||||
WifiPacket deauth;
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(connection_status_mutex);
|
||||
std::lock_guard lock(connection_status_mutex);
|
||||
if (connection_status.status == static_cast<u32>(NetworkStatus::ConnectedAsHost)) {
|
||||
// A real 3ds makes strange things here. We do the same
|
||||
u16_le tmp_node_id = connection_status.network_node_id;
|
||||
|
|
@ -1027,7 +1027,7 @@ void NWM_UDS::SendTo(Kernel::HLERequestContext& ctx) {
|
|||
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
|
||||
|
||||
std::lock_guard<std::mutex> lock(connection_status_mutex);
|
||||
std::lock_guard lock(connection_status_mutex);
|
||||
if (connection_status.status != static_cast<u32>(NetworkStatus::ConnectedAsClient) &&
|
||||
connection_status.status != static_cast<u32>(NetworkStatus::ConnectedAsHost)) {
|
||||
rb.Push(ResultCode(ErrorDescription::NotAuthorized, ErrorModule::UDS,
|
||||
|
|
@ -1091,7 +1091,7 @@ void NWM_UDS::PullPacket(Kernel::HLERequestContext& ctx) {
|
|||
// This size is hard coded into the uds module. We don't know the meaning yet.
|
||||
u32 buff_size = std::min<u32>(max_out_buff_size_aligned, 0x172) << 2;
|
||||
|
||||
std::lock_guard<std::mutex> lock(connection_status_mutex);
|
||||
std::lock_guard lock(connection_status_mutex);
|
||||
if (connection_status.status != static_cast<u32>(NetworkStatus::ConnectedAsHost) &&
|
||||
connection_status.status != static_cast<u32>(NetworkStatus::ConnectedAsClient) &&
|
||||
connection_status.status != static_cast<u32>(NetworkStatus::ConnectedAsSpectator)) {
|
||||
|
|
@ -1154,7 +1154,7 @@ void NWM_UDS::GetChannel(Kernel::HLERequestContext& ctx) {
|
|||
IPC::RequestParser rp(ctx, 0x1A, 0, 0);
|
||||
IPC::RequestBuilder rb = rp.MakeBuilder(2, 0);
|
||||
|
||||
std::lock_guard<std::mutex> lock(connection_status_mutex);
|
||||
std::lock_guard lock(connection_status_mutex);
|
||||
bool is_connected = connection_status.status != static_cast<u32>(NetworkStatus::NotConnected);
|
||||
|
||||
u8 channel = is_connected ? network_channel : 0;
|
||||
|
|
|
|||
|
|
@ -18,13 +18,13 @@ using std::chrono::microseconds;
|
|||
namespace Core {
|
||||
|
||||
void PerfStats::BeginSystemFrame() {
|
||||
std::lock_guard<std::mutex> lock(object_mutex);
|
||||
std::lock_guard lock{object_mutex};
|
||||
|
||||
frame_begin = Clock::now();
|
||||
}
|
||||
|
||||
void PerfStats::EndSystemFrame() {
|
||||
std::lock_guard<std::mutex> lock(object_mutex);
|
||||
std::lock_guard lock{object_mutex};
|
||||
|
||||
auto frame_end = Clock::now();
|
||||
accumulated_frametime += frame_end - frame_begin;
|
||||
|
|
@ -35,13 +35,13 @@ void PerfStats::EndSystemFrame() {
|
|||
}
|
||||
|
||||
void PerfStats::EndGameFrame() {
|
||||
std::lock_guard<std::mutex> lock(object_mutex);
|
||||
std::lock_guard lock{object_mutex};
|
||||
|
||||
game_frames += 1;
|
||||
}
|
||||
|
||||
PerfStats::Results PerfStats::GetAndResetStats(microseconds current_system_time_us) {
|
||||
std::lock_guard<std::mutex> lock(object_mutex);
|
||||
std::lock_guard lock(object_mutex);
|
||||
|
||||
const auto now = Clock::now();
|
||||
// Walltime elapsed since stats were reset
|
||||
|
|
@ -67,7 +67,7 @@ PerfStats::Results PerfStats::GetAndResetStats(microseconds current_system_time_
|
|||
}
|
||||
|
||||
double PerfStats::GetLastFrameTimeScale() {
|
||||
std::lock_guard<std::mutex> lock(object_mutex);
|
||||
std::lock_guard lock{object_mutex};
|
||||
|
||||
constexpr double FRAME_LENGTH = 1.0 / GPU::SCREEN_REFRESH_RATE;
|
||||
return duration_cast<DoubleSecs>(previous_frame_length).count() / FRAME_LENGTH;
|
||||
|
|
|
|||
|
|
@ -36,18 +36,18 @@ struct KeyButtonPair {
|
|||
class KeyButtonList {
|
||||
public:
|
||||
void AddKeyButton(int key_code, KeyButton* key_button) {
|
||||
std::lock_guard<std::mutex> guard(mutex);
|
||||
std::lock_guard guard{mutex};
|
||||
list.push_back(KeyButtonPair{key_code, key_button});
|
||||
}
|
||||
|
||||
void RemoveKeyButton(const KeyButton* key_button) {
|
||||
std::lock_guard<std::mutex> guard(mutex);
|
||||
std::lock_guard guard{mutex};
|
||||
list.remove_if(
|
||||
[key_button](const KeyButtonPair& pair) { return pair.key_button == key_button; });
|
||||
}
|
||||
|
||||
void ChangeKeyStatus(int key_code, bool pressed) {
|
||||
std::lock_guard<std::mutex> guard(mutex);
|
||||
std::lock_guard guard{mutex};
|
||||
for (const KeyButtonPair& pair : list) {
|
||||
if (pair.key_code == key_code)
|
||||
pair.key_button->status.store(pressed);
|
||||
|
|
@ -55,7 +55,7 @@ public:
|
|||
}
|
||||
|
||||
void ChangeAllKeyStatus(bool pressed) {
|
||||
std::lock_guard<std::mutex> guard(mutex);
|
||||
std::lock_guard guard{mutex};
|
||||
for (const KeyButtonPair& pair : list) {
|
||||
pair.key_button->status.store(pressed);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@ public:
|
|||
void Tilt(int x, int y) {
|
||||
auto mouse_move = Common::MakeVec(x, y) - mouse_origin;
|
||||
if (is_tilting) {
|
||||
std::lock_guard<std::mutex> guard(tilt_mutex);
|
||||
std::lock_guard guard{tilt_mutex};
|
||||
if (mouse_move.x == 0 && mouse_move.y == 0) {
|
||||
tilt_angle = 0;
|
||||
} else {
|
||||
|
|
@ -52,13 +52,13 @@ public:
|
|||
}
|
||||
|
||||
void EndTilt() {
|
||||
std::lock_guard<std::mutex> guard(tilt_mutex);
|
||||
std::lock_guard guard{tilt_mutex};
|
||||
tilt_angle = 0;
|
||||
is_tilting = false;
|
||||
}
|
||||
|
||||
std::tuple<Common::Vec3<float>, Common::Vec3<float>> GetStatus() {
|
||||
std::lock_guard<std::mutex> guard(status_mutex);
|
||||
std::lock_guard guard{status_mutex};
|
||||
return status;
|
||||
}
|
||||
|
||||
|
|
@ -95,7 +95,7 @@ private:
|
|||
old_q = q;
|
||||
|
||||
{
|
||||
std::lock_guard<std::mutex> guard(tilt_mutex);
|
||||
std::lock_guard guard{tilt_mutex};
|
||||
|
||||
// Find the quaternion describing current 3DS tilting
|
||||
q = Common::MakeQuaternion(
|
||||
|
|
@ -117,7 +117,7 @@ private:
|
|||
|
||||
// Update the sensor state
|
||||
{
|
||||
std::lock_guard<std::mutex> guard(status_mutex);
|
||||
std::lock_guard guard{status_mutex};
|
||||
status = std::make_tuple(gravity, angular_rate);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -55,22 +55,22 @@ public:
|
|||
: guid{std::move(guid_)}, port{port_}, sdl_joystick{joystick, deleter} {}
|
||||
|
||||
void SetButton(int button, bool value) {
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
std::lock_guard lock{mutex};
|
||||
state.buttons[button] = value;
|
||||
}
|
||||
|
||||
bool GetButton(int button) const {
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
std::lock_guard lock{mutex};
|
||||
return state.buttons.at(button);
|
||||
}
|
||||
|
||||
void SetAxis(int axis, Sint16 value) {
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
std::lock_guard lock{mutex};
|
||||
state.axes[axis] = value;
|
||||
}
|
||||
|
||||
float GetAxis(int axis) const {
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
std::lock_guard lock{mutex};
|
||||
return state.axes.at(axis) / 32767.0f;
|
||||
}
|
||||
|
||||
|
|
@ -92,12 +92,12 @@ public:
|
|||
}
|
||||
|
||||
void SetHat(int hat, Uint8 direction) {
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
std::lock_guard lock{mutex};
|
||||
state.hats[hat] = direction;
|
||||
}
|
||||
|
||||
bool GetHatDirection(int hat, Uint8 direction) const {
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
std::lock_guard lock{mutex};
|
||||
return (state.hats.at(hat) & direction) != 0;
|
||||
}
|
||||
/**
|
||||
|
|
@ -140,7 +140,7 @@ private:
|
|||
* Get the nth joystick with the corresponding GUID
|
||||
*/
|
||||
std::shared_ptr<SDLJoystick> SDLState::GetSDLJoystickByGUID(const std::string& guid, int port) {
|
||||
std::lock_guard<std::mutex> lock(joystick_map_mutex);
|
||||
std::lock_guard lock{joystick_map_mutex};
|
||||
const auto it = joystick_map.find(guid);
|
||||
if (it != joystick_map.end()) {
|
||||
while (it->second.size() <= port) {
|
||||
|
|
@ -161,7 +161,8 @@ std::shared_ptr<SDLJoystick> SDLState::GetSDLJoystickByGUID(const std::string& g
|
|||
std::shared_ptr<SDLJoystick> SDLState::GetSDLJoystickBySDLID(SDL_JoystickID sdl_id) {
|
||||
auto sdl_joystick = SDL_JoystickFromInstanceID(sdl_id);
|
||||
const std::string guid = GetGUID(sdl_joystick);
|
||||
std::lock_guard<std::mutex> lock(joystick_map_mutex);
|
||||
|
||||
std::lock_guard lock{joystick_map_mutex};
|
||||
auto map_it = joystick_map.find(guid);
|
||||
if (map_it != joystick_map.end()) {
|
||||
auto vec_it = std::find_if(map_it->second.begin(), map_it->second.end(),
|
||||
|
|
@ -198,8 +199,9 @@ void SDLState::InitJoystick(int joystick_index) {
|
|||
LOG_ERROR(Input, "failed to open joystick {}", joystick_index);
|
||||
return;
|
||||
}
|
||||
std::string guid = GetGUID(sdl_joystick);
|
||||
std::lock_guard<std::mutex> lock(joystick_map_mutex);
|
||||
const std::string guid = GetGUID(sdl_joystick);
|
||||
|
||||
std::lock_guard lock{joystick_map_mutex};
|
||||
if (joystick_map.find(guid) == joystick_map.end()) {
|
||||
auto joystick = std::make_shared<SDLJoystick>(guid, 0, sdl_joystick);
|
||||
joystick_map[guid].emplace_back(std::move(joystick));
|
||||
|
|
@ -221,7 +223,7 @@ void SDLState::CloseJoystick(SDL_Joystick* sdl_joystick) {
|
|||
std::string guid = GetGUID(sdl_joystick);
|
||||
std::shared_ptr<SDLJoystick> joystick;
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(joystick_map_mutex);
|
||||
std::lock_guard lock{joystick_map_mutex};
|
||||
// This call to guid is safe since the joystick is guaranteed to be in the map
|
||||
auto& joystick_guid_list = joystick_map[guid];
|
||||
const auto joystick_it =
|
||||
|
|
@ -274,7 +276,7 @@ void SDLState::HandleGameControllerEvent(const SDL_Event& event) {
|
|||
}
|
||||
|
||||
void SDLState::CloseJoysticks() {
|
||||
std::lock_guard<std::mutex> lock(joystick_map_mutex);
|
||||
std::lock_guard lock{joystick_map_mutex};
|
||||
joystick_map.clear();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -165,7 +165,7 @@ void Client::OnPadData(Response::PadData data) {
|
|||
Common::Vec3f accel = Common::MakeVec<float>(-data.accel.x, data.accel.y, -data.accel.z);
|
||||
Common::Vec3f gyro = Common::MakeVec<float>(-data.gyro.pitch, -data.gyro.yaw, data.gyro.roll);
|
||||
{
|
||||
std::lock_guard<std::mutex> guard(status->update_mutex);
|
||||
std::lock_guard guard(status->update_mutex);
|
||||
|
||||
status->motion_status = {accel, gyro};
|
||||
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ class UDPTouchDevice final : public Input::TouchDevice {
|
|||
public:
|
||||
explicit UDPTouchDevice(std::shared_ptr<DeviceStatus> status_) : status(std::move(status_)) {}
|
||||
std::tuple<float, float, bool> GetStatus() const {
|
||||
std::lock_guard<std::mutex> guard(status->update_mutex);
|
||||
std::lock_guard guard(status->update_mutex);
|
||||
return status->touch_status;
|
||||
}
|
||||
|
||||
|
|
@ -27,7 +27,7 @@ class UDPMotionDevice final : public Input::MotionDevice {
|
|||
public:
|
||||
explicit UDPMotionDevice(std::shared_ptr<DeviceStatus> status_) : status(std::move(status_)) {}
|
||||
std::tuple<Common::Vec3<float>, Common::Vec3<float>> GetStatus() const {
|
||||
std::lock_guard<std::mutex> guard(status->update_mutex);
|
||||
std::lock_guard guard(status->update_mutex);
|
||||
return status->motion_status;
|
||||
}
|
||||
|
||||
|
|
@ -41,7 +41,7 @@ public:
|
|||
|
||||
std::unique_ptr<Input::TouchDevice> Create(const Common::ParamPackage& params) override {
|
||||
{
|
||||
std::lock_guard<std::mutex> guard(status->update_mutex);
|
||||
std::lock_guard guard(status->update_mutex);
|
||||
status->touch_calibration.emplace();
|
||||
// These default values work well for DS4 but probably not other touch inputs
|
||||
status->touch_calibration->min_x = params.Get("min_x", 100);
|
||||
|
|
|
|||
|
|
@ -302,7 +302,7 @@ void Room::RoomImpl::StartLoop() {
|
|||
|
||||
void Room::RoomImpl::HandleJoinRequest(const ENetEvent* event) {
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(member_mutex);
|
||||
std::lock_guard lock(member_mutex);
|
||||
if (members.size() >= room_information.member_slots) {
|
||||
SendRoomIsFull(event->peer);
|
||||
return;
|
||||
|
|
@ -369,13 +369,13 @@ void Room::RoomImpl::HandleJoinRequest(const ENetEvent* event) {
|
|||
|
||||
std::string uid;
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(verify_UID_mutex);
|
||||
std::lock_guard lock(verify_UID_mutex);
|
||||
uid = verify_UID;
|
||||
}
|
||||
member.user_data = verify_backend->LoadUserData(uid, token);
|
||||
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(ban_list_mutex);
|
||||
std::lock_guard lock(ban_list_mutex);
|
||||
|
||||
// Check username ban
|
||||
if (!member.user_data.username.empty() &&
|
||||
|
|
@ -401,7 +401,7 @@ void Room::RoomImpl::HandleJoinRequest(const ENetEvent* event) {
|
|||
SendStatusMessage(IdMemberJoin, member.nickname, member.user_data.username);
|
||||
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(member_mutex);
|
||||
std::lock_guard lock(member_mutex);
|
||||
members.push_back(std::move(member));
|
||||
}
|
||||
|
||||
|
|
@ -429,7 +429,7 @@ void Room::RoomImpl::HandleModKickPacket(const ENetEvent* event) {
|
|||
|
||||
std::string username;
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(member_mutex);
|
||||
std::lock_guard lock(member_mutex);
|
||||
const auto target_member =
|
||||
std::find_if(members.begin(), members.end(),
|
||||
[&nickname](const auto& member) { return member.nickname == nickname; });
|
||||
|
|
@ -469,7 +469,7 @@ void Room::RoomImpl::HandleModBanPacket(const ENetEvent* event) {
|
|||
std::string ip;
|
||||
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(member_mutex);
|
||||
std::lock_guard lock(member_mutex);
|
||||
const auto target_member =
|
||||
std::find_if(members.begin(), members.end(),
|
||||
[&nickname](const auto& member) { return member.nickname == nickname; });
|
||||
|
|
@ -493,7 +493,7 @@ void Room::RoomImpl::HandleModBanPacket(const ENetEvent* event) {
|
|||
}
|
||||
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(ban_list_mutex);
|
||||
std::lock_guard lock(ban_list_mutex);
|
||||
|
||||
if (!username.empty()) {
|
||||
// Ban the forum username
|
||||
|
|
@ -530,7 +530,7 @@ void Room::RoomImpl::HandleModUnbanPacket(const ENetEvent* event) {
|
|||
|
||||
bool unbanned = false;
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(ban_list_mutex);
|
||||
std::lock_guard lock(ban_list_mutex);
|
||||
|
||||
auto it = std::find(username_ban_list.begin(), username_ban_list.end(), address);
|
||||
if (it != username_ban_list.end()) {
|
||||
|
|
@ -568,28 +568,28 @@ bool Room::RoomImpl::IsValidNickname(const std::string& nickname) const {
|
|||
if (!std::regex_match(nickname, nickname_regex))
|
||||
return false;
|
||||
|
||||
std::lock_guard<std::mutex> lock(member_mutex);
|
||||
std::lock_guard lock(member_mutex);
|
||||
return std::all_of(members.begin(), members.end(),
|
||||
[&nickname](const auto& member) { return member.nickname != nickname; });
|
||||
}
|
||||
|
||||
bool Room::RoomImpl::IsValidMacAddress(const MacAddress& address) const {
|
||||
// A MAC address is valid if it is not already taken by anybody else in the room.
|
||||
std::lock_guard<std::mutex> lock(member_mutex);
|
||||
std::lock_guard lock(member_mutex);
|
||||
return std::all_of(members.begin(), members.end(),
|
||||
[&address](const auto& member) { return member.mac_address != address; });
|
||||
}
|
||||
|
||||
bool Room::RoomImpl::IsValidConsoleId(const std::string& console_id_hash) const {
|
||||
// A Console ID is valid if it is not already taken by anybody else in the room.
|
||||
std::lock_guard<std::mutex> lock(member_mutex);
|
||||
std::lock_guard lock(member_mutex);
|
||||
return std::all_of(members.begin(), members.end(), [&console_id_hash](const auto& member) {
|
||||
return member.console_id_hash != console_id_hash;
|
||||
});
|
||||
}
|
||||
|
||||
bool Room::RoomImpl::HasModPermission(const ENetPeer* client) const {
|
||||
std::lock_guard<std::mutex> lock(member_mutex);
|
||||
std::lock_guard lock(member_mutex);
|
||||
const auto sending_member =
|
||||
std::find_if(members.begin(), members.end(),
|
||||
[client](const auto& member) { return member.peer == client; });
|
||||
|
|
@ -734,7 +734,7 @@ void Room::RoomImpl::SendModBanListResponse(ENetPeer* client) {
|
|||
Packet packet;
|
||||
packet << static_cast<u8>(IdModBanListResponse);
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(ban_list_mutex);
|
||||
std::lock_guard lock(ban_list_mutex);
|
||||
packet << username_ban_list;
|
||||
packet << ip_ban_list;
|
||||
}
|
||||
|
|
@ -748,7 +748,7 @@ void Room::RoomImpl::SendModBanListResponse(ENetPeer* client) {
|
|||
void Room::RoomImpl::SendCloseMessage() {
|
||||
Packet packet;
|
||||
packet << static_cast<u8>(IdCloseRoom);
|
||||
std::lock_guard<std::mutex> lock(member_mutex);
|
||||
std::lock_guard lock(member_mutex);
|
||||
if (!members.empty()) {
|
||||
ENetPacket* enet_packet =
|
||||
enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE);
|
||||
|
|
@ -769,7 +769,7 @@ void Room::RoomImpl::SendStatusMessage(StatusMessageTypes type, const std::strin
|
|||
packet << static_cast<u8>(type);
|
||||
packet << nickname;
|
||||
packet << username;
|
||||
std::lock_guard<std::mutex> lock(member_mutex);
|
||||
std::lock_guard lock(member_mutex);
|
||||
if (!members.empty()) {
|
||||
ENetPacket* enet_packet =
|
||||
enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE);
|
||||
|
|
@ -792,7 +792,7 @@ void Room::RoomImpl::BroadcastRoomInformation() {
|
|||
|
||||
packet << static_cast<u32>(members.size());
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(member_mutex);
|
||||
std::lock_guard lock(member_mutex);
|
||||
for (const auto& member : members) {
|
||||
packet << member.nickname;
|
||||
packet << member.mac_address;
|
||||
|
|
@ -838,7 +838,7 @@ void Room::RoomImpl::HandleWifiPacket(const ENetEvent* event) {
|
|||
ENET_PACKET_FLAG_RELIABLE);
|
||||
|
||||
if (destination_address == BroadcastMac) { // Send the data to everyone except the sender
|
||||
std::lock_guard<std::mutex> lock(member_mutex);
|
||||
std::lock_guard lock(member_mutex);
|
||||
bool sent_packet = false;
|
||||
for (const auto& member : members) {
|
||||
if (member.peer != event->peer) {
|
||||
|
|
@ -851,7 +851,7 @@ void Room::RoomImpl::HandleWifiPacket(const ENetEvent* event) {
|
|||
enet_packet_destroy(enet_packet);
|
||||
}
|
||||
} else { // Send the data only to the destination client
|
||||
std::lock_guard<std::mutex> lock(member_mutex);
|
||||
std::lock_guard lock(member_mutex);
|
||||
auto member = std::find_if(members.begin(), members.end(),
|
||||
[destination_address](const Member& member) -> bool {
|
||||
return member.mac_address == destination_address;
|
||||
|
|
@ -881,7 +881,7 @@ void Room::RoomImpl::HandleChatPacket(const ENetEvent* event) {
|
|||
return member.peer == event->peer;
|
||||
};
|
||||
|
||||
std::lock_guard<std::mutex> lock(member_mutex);
|
||||
std::lock_guard lock(member_mutex);
|
||||
const auto sending_member = std::find_if(members.begin(), members.end(), CompareNetworkAddress);
|
||||
if (sending_member == members.end()) {
|
||||
return; // Received a chat message from a unknown sender
|
||||
|
|
@ -923,7 +923,7 @@ void Room::RoomImpl::HandleGameNamePacket(const ENetEvent* event) {
|
|||
in_packet >> game_info.id;
|
||||
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(member_mutex);
|
||||
std::lock_guard lock(member_mutex);
|
||||
auto member =
|
||||
std::find_if(members.begin(), members.end(), [event](const Member& member) -> bool {
|
||||
return member.peer == event->peer;
|
||||
|
|
@ -939,7 +939,7 @@ void Room::RoomImpl::HandleClientDisconnection(ENetPeer* client) {
|
|||
// Remove the client from the members list.
|
||||
std::string nickname, username;
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(member_mutex);
|
||||
std::lock_guard lock(member_mutex);
|
||||
auto member = std::find_if(members.begin(), members.end(), [client](const Member& member) {
|
||||
return member.peer == client;
|
||||
});
|
||||
|
|
@ -1009,18 +1009,18 @@ const RoomInformation& Room::GetRoomInformation() const {
|
|||
}
|
||||
|
||||
std::string Room::GetVerifyUID() const {
|
||||
std::lock_guard<std::mutex> lock(room_impl->verify_UID_mutex);
|
||||
std::lock_guard lock(room_impl->verify_UID_mutex);
|
||||
return room_impl->verify_UID;
|
||||
}
|
||||
|
||||
Room::BanList Room::GetBanList() const {
|
||||
std::lock_guard<std::mutex> lock(room_impl->ban_list_mutex);
|
||||
std::lock_guard lock(room_impl->ban_list_mutex);
|
||||
return {room_impl->username_ban_list, room_impl->ip_ban_list};
|
||||
}
|
||||
|
||||
std::vector<Room::Member> Room::GetRoomMemberList() const {
|
||||
std::vector<Room::Member> member_list;
|
||||
std::lock_guard<std::mutex> lock(room_impl->member_mutex);
|
||||
std::lock_guard lock(room_impl->member_mutex);
|
||||
for (const auto& member_impl : room_impl->members) {
|
||||
Member member;
|
||||
member.nickname = member_impl.nickname;
|
||||
|
|
@ -1039,7 +1039,7 @@ bool Room::HasPassword() const {
|
|||
}
|
||||
|
||||
void Room::SetVerifyUID(const std::string& uid) {
|
||||
std::lock_guard<std::mutex> lock(room_impl->verify_UID_mutex);
|
||||
std::lock_guard lock(room_impl->verify_UID_mutex);
|
||||
room_impl->verify_UID = uid;
|
||||
}
|
||||
|
||||
|
|
@ -1054,7 +1054,7 @@ void Room::Destroy() {
|
|||
room_impl->room_information = {};
|
||||
room_impl->server = nullptr;
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(room_impl->member_mutex);
|
||||
std::lock_guard lock(room_impl->member_mutex);
|
||||
room_impl->members.clear();
|
||||
}
|
||||
room_impl->room_information.member_slots = 0;
|
||||
|
|
|
|||
|
|
@ -157,7 +157,7 @@ bool RoomMember::RoomMemberImpl::IsConnected() const {
|
|||
void RoomMember::RoomMemberImpl::MemberLoop() {
|
||||
// Receive packets while the connection is open
|
||||
while (IsConnected()) {
|
||||
std::lock_guard<std::mutex> lock(network_mutex);
|
||||
std::lock_guard lock(network_mutex);
|
||||
ENetEvent event;
|
||||
if (enet_host_service(client, &event, 100) > 0) {
|
||||
switch (event.type) {
|
||||
|
|
@ -245,7 +245,7 @@ void RoomMember::RoomMemberImpl::MemberLoop() {
|
|||
}
|
||||
}
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(send_list_mutex);
|
||||
std::lock_guard lock(send_list_mutex);
|
||||
for (const auto& packet : send_list) {
|
||||
ENetPacket* enetPacket = enet_packet_create(packet.GetData(), packet.GetDataSize(),
|
||||
ENET_PACKET_FLAG_RELIABLE);
|
||||
|
|
@ -263,7 +263,7 @@ void RoomMember::RoomMemberImpl::StartLoop() {
|
|||
}
|
||||
|
||||
void RoomMember::RoomMemberImpl::Send(Packet&& packet) {
|
||||
std::lock_guard<std::mutex> lock(send_list_mutex);
|
||||
std::lock_guard lock(send_list_mutex);
|
||||
send_list.push_back(std::move(packet));
|
||||
}
|
||||
|
||||
|
|
@ -318,7 +318,7 @@ void RoomMember::RoomMemberImpl::HandleRoomInformationPacket(const ENetEvent* ev
|
|||
packet >> member.avatar_url;
|
||||
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(username_mutex);
|
||||
std::lock_guard lock(username_mutex);
|
||||
if (member.nickname == nickname) {
|
||||
username = member.username;
|
||||
}
|
||||
|
|
@ -473,7 +473,7 @@ RoomMember::RoomMemberImpl::Callbacks::Get() {
|
|||
|
||||
template <typename T>
|
||||
void RoomMember::RoomMemberImpl::Invoke(const T& data) {
|
||||
std::lock_guard<std::mutex> lock(callback_mutex);
|
||||
std::lock_guard lock(callback_mutex);
|
||||
CallbackSet<T> callback_set = callbacks.Get<T>();
|
||||
for (auto const& callback : callback_set)
|
||||
(*callback)(data);
|
||||
|
|
@ -482,7 +482,7 @@ void RoomMember::RoomMemberImpl::Invoke(const T& data) {
|
|||
template <typename T>
|
||||
RoomMember::CallbackHandle<T> RoomMember::RoomMemberImpl::Bind(
|
||||
std::function<void(const T&)> callback) {
|
||||
std::lock_guard<std::mutex> lock(callback_mutex);
|
||||
std::lock_guard lock(callback_mutex);
|
||||
CallbackHandle<T> handle;
|
||||
handle = std::make_shared<std::function<void(const T&)>>(callback);
|
||||
callbacks.Get<T>().insert(handle);
|
||||
|
|
@ -512,7 +512,7 @@ const std::string& RoomMember::GetNickname() const {
|
|||
}
|
||||
|
||||
const std::string& RoomMember::GetUsername() const {
|
||||
std::lock_guard<std::mutex> lock(room_member_impl->username_mutex);
|
||||
std::lock_guard lock(room_member_impl->username_mutex);
|
||||
return room_member_impl->username;
|
||||
}
|
||||
|
||||
|
|
@ -663,7 +663,7 @@ RoomMember::CallbackHandle<Room::BanList> RoomMember::BindOnBanListReceived(
|
|||
|
||||
template <typename T>
|
||||
void RoomMember::Unbind(CallbackHandle<T> handle) {
|
||||
std::lock_guard<std::mutex> lock(room_member_impl->callback_mutex);
|
||||
std::lock_guard lock(room_member_impl->callback_mutex);
|
||||
room_member_impl->callbacks.Get<T>().erase(handle);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@ namespace Pica {
|
|||
|
||||
void DebugContext::DoOnEvent(Event event, void* data) {
|
||||
{
|
||||
std::unique_lock<std::mutex> lock(breakpoint_mutex);
|
||||
std::unique_lock lock{breakpoint_mutex};
|
||||
|
||||
// Commit the rasterizer's caches so framebuffers, render targets, etc. will show on debug
|
||||
// widgets
|
||||
|
|
@ -66,7 +66,7 @@ void DebugContext::DoOnEvent(Event event, void* data) {
|
|||
|
||||
void DebugContext::Resume() {
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(breakpoint_mutex);
|
||||
std::lock_guard lock{breakpoint_mutex};
|
||||
|
||||
// Tell all observers that we are about to resume
|
||||
for (auto& breakpoint_observer : breakpoint_observers) {
|
||||
|
|
@ -282,14 +282,14 @@ void StartPicaTracing() {
|
|||
return;
|
||||
}
|
||||
|
||||
std::lock_guard<std::mutex> lock(pica_trace_mutex);
|
||||
std::lock_guard lock(pica_trace_mutex);
|
||||
pica_trace = std::make_unique<PicaTrace>();
|
||||
|
||||
g_is_pica_tracing = true;
|
||||
}
|
||||
|
||||
void OnPicaRegWrite(PicaTrace::Write write) {
|
||||
std::lock_guard<std::mutex> lock(pica_trace_mutex);
|
||||
std::lock_guard lock(pica_trace_mutex);
|
||||
|
||||
if (!g_is_pica_tracing)
|
||||
return;
|
||||
|
|
@ -307,7 +307,7 @@ std::unique_ptr<PicaTrace> FinishPicaTracing() {
|
|||
g_is_pica_tracing = false;
|
||||
|
||||
// Wait until running tracing is finished
|
||||
std::lock_guard<std::mutex> lock(pica_trace_mutex);
|
||||
std::lock_guard lock(pica_trace_mutex);
|
||||
std::unique_ptr<PicaTrace> ret(std::move(pica_trace));
|
||||
|
||||
return ret;
|
||||
|
|
|
|||
|
|
@ -63,14 +63,14 @@ public:
|
|||
/// Constructs the object such that it observes events of the given DebugContext.
|
||||
BreakPointObserver(std::shared_ptr<DebugContext> debug_context)
|
||||
: context_weak(debug_context) {
|
||||
std::unique_lock<std::mutex> lock(debug_context->breakpoint_mutex);
|
||||
std::unique_lock lock{debug_context->breakpoint_mutex};
|
||||
debug_context->breakpoint_observers.push_back(this);
|
||||
}
|
||||
|
||||
virtual ~BreakPointObserver() {
|
||||
auto context = context_weak.lock();
|
||||
if (context) {
|
||||
std::unique_lock<std::mutex> lock(context->breakpoint_mutex);
|
||||
std::unique_lock lock(context->breakpoint_mutex);
|
||||
context->breakpoint_observers.remove(this);
|
||||
|
||||
// If we are the last observer to be destroyed, tell the debugger context that
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@ constexpr std::size_t TIMEOUT_SECONDS = 30;
|
|||
struct Client::Impl {
|
||||
Impl(std::string host, std::string username, std::string token)
|
||||
: host{std::move(host)}, username{std::move(username)}, token{std::move(token)} {
|
||||
std::lock_guard<std::mutex> lock(jwt_cache.mutex);
|
||||
std::lock_guard lock{jwt_cache.mutex};
|
||||
if (this->username == jwt_cache.username && this->token == jwt_cache.token) {
|
||||
jwt = jwt_cache.jwt;
|
||||
}
|
||||
|
|
@ -154,7 +154,7 @@ struct Client::Impl {
|
|||
if (result.result_code != Common::WebResult::Code::Success) {
|
||||
LOG_ERROR(WebService, "UpdateJWT failed");
|
||||
} else {
|
||||
std::lock_guard<std::mutex> lock(jwt_cache.mutex);
|
||||
std::lock_guard lock{jwt_cache.mutex};
|
||||
jwt_cache.username = username;
|
||||
jwt_cache.token = token;
|
||||
jwt_cache.jwt = jwt = result.returned_data;
|
||||
|
|
|
|||
Loading…
Reference in a new issue