Use wpi::mutex instead of std::mutex. (#730)

This uses a priority-aware mutex on Linux platforms.

Fixes #729.

hal/src/main/native/sim/MockData/AccelerometerData.cpp

@@ -32,7 +32,7 @@ int32_t AccelerometerData::RegisterActiveCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_activeCallbacks =
         RegisterCallback(m_activeCallbacks, "Active", callback, param, &newUid);
   }
@@ -68,7 +68,7 @@ int32_t AccelerometerData::RegisterRangeCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_rangeCallbacks =
         RegisterCallback(m_rangeCallbacks, "Range", callback, param, &newUid);
   }
@@ -104,7 +104,7 @@ int32_t AccelerometerData::RegisterXCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_xCallbacks =
         RegisterCallback(m_xCallbacks, "X", callback, param, &newUid);
   }
@@ -140,7 +140,7 @@ int32_t AccelerometerData::RegisterYCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_yCallbacks =
         RegisterCallback(m_yCallbacks, "Y", callback, param, &newUid);
   }
@@ -176,7 +176,7 @@ int32_t AccelerometerData::RegisterZCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_zCallbacks =
         RegisterCallback(m_zCallbacks, "Z", callback, param, &newUid);
   }

hal/src/main/native/sim/MockData/AccelerometerDataInternal.h

@@ -10,6 +10,8 @@
 #include <atomic>
 #include <memory>
 
+#include <support/mutex.h>
+
 #include "MockData/AccelerometerData.h"
 #include "MockData/NotifyListenerVector.h"
 
@@ -54,7 +56,7 @@ class AccelerometerData {
   virtual void ResetData();
 
  private:
-  std::mutex m_registerMutex;
+  wpi::mutex m_registerMutex;
   std::atomic<HAL_Bool> m_active{false};
   std::shared_ptr<NotifyListenerVector> m_activeCallbacks = nullptr;
   std::atomic<HAL_AccelerometerRange> m_range{

hal/src/main/native/sim/MockData/AnalogGyroData.cpp

@@ -28,7 +28,7 @@ int32_t AnalogGyroData::RegisterAngleCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_angleCallbacks =
         RegisterCallback(m_angleCallbacks, "Angle", callback, param, &newUid);
   }
@@ -64,7 +64,7 @@ int32_t AnalogGyroData::RegisterRateCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_rateCallbacks =
         RegisterCallback(m_rateCallbacks, "Rate", callback, param, &newUid);
   }
@@ -100,7 +100,7 @@ int32_t AnalogGyroData::RegisterInitializedCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_initializedCallbacks = RegisterCallback(
         m_initializedCallbacks, "Initialized", callback, param, &newUid);
   }

hal/src/main/native/sim/MockData/AnalogGyroDataInternal.h

@@ -10,6 +10,8 @@
 #include <atomic>
 #include <memory>
 
+#include <support/mutex.h>
+
 #include "MockData/AnalogGyroData.h"
 #include "MockData/NotifyListenerVector.h"
 
@@ -40,7 +42,7 @@ class AnalogGyroData {
   virtual void ResetData();
 
  private:
-  std::mutex m_registerMutex;
+  wpi::mutex m_registerMutex;
   std::atomic<double> m_angle{0.0};
   std::shared_ptr<NotifyListenerVector> m_angleCallbacks = nullptr;
   std::atomic<double> m_rate{0.0};

hal/src/main/native/sim/MockData/AnalogInData.cpp

@@ -40,7 +40,7 @@ int32_t AnalogInData::RegisterInitializedCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_initializedCallbacks = RegisterCallback(
         m_initializedCallbacks, "Initialized", callback, param, &newUid);
   }
@@ -76,7 +76,7 @@ int32_t AnalogInData::RegisterAverageBitsCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_averageBitsCallbacks = RegisterCallback(
         m_averageBitsCallbacks, "AverageBits", callback, param, &newUid);
   }
@@ -111,7 +111,7 @@ int32_t AnalogInData::RegisterOversampleBitsCallback(
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_oversampleBitsCallbacks = RegisterCallback(
         m_oversampleBitsCallbacks, "OversampleBits", callback, param, &newUid);
   }
@@ -147,7 +147,7 @@ int32_t AnalogInData::RegisterVoltageCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_voltageCallbacks = RegisterCallback(m_voltageCallbacks, "Voltage",
                                           callback, param, &newUid);
   }
@@ -182,7 +182,7 @@ int32_t AnalogInData::RegisterAccumulatorInitializedCallback(
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_accumulatorInitializedCallbacks =
         RegisterCallback(m_accumulatorInitializedCallbacks,
                          "AccumulatorInitialized", callback, param, &newUid);
@@ -222,7 +222,7 @@ int32_t AnalogInData::RegisterAccumulatorValueCallback(
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_accumulatorValueCallbacks =
         RegisterCallback(m_accumulatorValueCallbacks, "AccumulatorValue",
                          callback, param, &newUid);
@@ -259,7 +259,7 @@ int32_t AnalogInData::RegisterAccumulatorCountCallback(
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_accumulatorCountCallbacks =
         RegisterCallback(m_accumulatorCountCallbacks, "AccumulatorCount",
                          callback, param, &newUid);
@@ -296,7 +296,7 @@ int32_t AnalogInData::RegisterAccumulatorCenterCallback(
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_accumulatorCenterCallbacks =
         RegisterCallback(m_accumulatorCenterCallbacks, "AccumulatorCenter",
                          callback, param, &newUid);
@@ -333,7 +333,7 @@ int32_t AnalogInData::RegisterAccumulatorDeadbandCallback(
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_accumulatorDeadbandCallbacks =
         RegisterCallback(m_accumulatorDeadbandCallbacks, "AccumulatorDeadband",
                          callback, param, &newUid);

hal/src/main/native/sim/MockData/AnalogInDataInternal.h

@@ -10,6 +10,8 @@
 #include <atomic>
 #include <memory>
 
+#include <support/mutex.h>
+
 #include "MockData/AnalogInData.h"
 #include "MockData/NotifyListenerVector.h"
 
@@ -85,7 +87,7 @@ class AnalogInData {
   virtual void ResetData();
 
  private:
-  std::mutex m_registerMutex;
+  wpi::mutex m_registerMutex;
   std::atomic<HAL_Bool> m_initialized{false};
   std::shared_ptr<NotifyListenerVector> m_initializedCallbacks = nullptr;
   std::atomic<int32_t> m_averageBits{7};

hal/src/main/native/sim/MockData/AnalogOutData.cpp

@@ -26,7 +26,7 @@ int32_t AnalogOutData::RegisterVoltageCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_voltageCallbacks = RegisterCallback(m_voltageCallbacks, "Voltage",
                                           callback, param, &newUid);
   }
@@ -62,7 +62,7 @@ int32_t AnalogOutData::RegisterInitializedCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_initializedCallbacks = RegisterCallback(
         m_initializedCallbacks, "Initialized", callback, param, &newUid);
   }

hal/src/main/native/sim/MockData/AnalogOutDataInternal.h

@@ -10,6 +10,8 @@
 #include <atomic>
 #include <memory>
 
+#include <support/mutex.h>
+
 #include "MockData/AnalogOutData.h"
 #include "MockData/NotifyListenerVector.h"
 
@@ -33,7 +35,7 @@ class AnalogOutData {
   virtual void ResetData();
 
  private:
-  std::mutex m_registerMutex;
+  wpi::mutex m_registerMutex;
   std::atomic<double> m_voltage{0.0};
   std::shared_ptr<NotifyListenerVector> m_voltageCallbacks = nullptr;
   std::atomic<HAL_Bool> m_initialized{0};

hal/src/main/native/sim/MockData/AnalogTriggerData.cpp

@@ -29,7 +29,7 @@ int32_t AnalogTriggerData::RegisterInitializedCallback(
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_initializedCallbacks = RegisterCallback(
         m_initializedCallbacks, "Initialized", callback, param, &newUid);
   }
@@ -64,7 +64,7 @@ int32_t AnalogTriggerData::RegisterTriggerLowerBoundCallback(
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_triggerLowerBoundCallbacks =
         RegisterCallback(m_triggerLowerBoundCallbacks, "TriggerLowerBound",
                          callback, param, &newUid);
@@ -101,7 +101,7 @@ int32_t AnalogTriggerData::RegisterTriggerUpperBoundCallback(
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_triggerUpperBoundCallbacks =
         RegisterCallback(m_triggerUpperBoundCallbacks, "TriggerUpperBound",
                          callback, param, &newUid);
@@ -138,7 +138,7 @@ int32_t AnalogTriggerData::RegisterTriggerModeCallback(
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_triggerModeCallbacks = RegisterCallback(
         m_triggerModeCallbacks, "TriggerMode", callback, param, &newUid);
   }

hal/src/main/native/sim/MockData/AnalogTriggerDataInternal.h

@@ -10,6 +10,8 @@
 #include <atomic>
 #include <memory>
 
+#include <support/mutex.h>
+
 #include "MockData/AnalogTriggerData.h"
 #include "MockData/NotifyListenerVector.h"
 
@@ -49,7 +51,7 @@ class AnalogTriggerData {
   virtual void ResetData();
 
  private:
-  std::mutex m_registerMutex;
+  wpi::mutex m_registerMutex;
   std::atomic<HAL_Bool> m_initialized{0};
   std::shared_ptr<NotifyListenerVector> m_initializedCallbacks = nullptr;
   std::atomic<double> m_triggerLowerBound{0};

hal/src/main/native/sim/MockData/DIOData.cpp

@@ -32,7 +32,7 @@ int32_t DIOData::RegisterInitializedCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_initializedCallbacks = RegisterCallback(
         m_initializedCallbacks, "Initialized", callback, param, &newUid);
   }
@@ -67,7 +67,7 @@ int32_t DIOData::RegisterValueCallback(HAL_NotifyCallback callback, void* param,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_valueCallbacks =
         RegisterCallback(m_valueCallbacks, "Value", callback, param, &newUid);
   }
@@ -103,7 +103,7 @@ int32_t DIOData::RegisterPulseLengthCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_pulseLengthCallbacks = RegisterCallback(
         m_pulseLengthCallbacks, "PulseLength", callback, param, &newUid);
   }
@@ -138,7 +138,7 @@ int32_t DIOData::RegisterIsInputCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_isInputCallbacks = RegisterCallback(m_isInputCallbacks, "IsInput",
                                           callback, param, &newUid);
   }
@@ -174,7 +174,7 @@ int32_t DIOData::RegisterFilterIndexCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_filterIndexCallbacks = RegisterCallback(
         m_filterIndexCallbacks, "FilterIndex", callback, param, &newUid);
   }

hal/src/main/native/sim/MockData/DIODataInternal.h

@@ -10,6 +10,8 @@
 #include <atomic>
 #include <memory>
 
+#include <support/mutex.h>
+
 #include "MockData/DIOData.h"
 #include "MockData/NotifyListenerVector.h"
 
@@ -54,7 +56,7 @@ class DIOData {
   virtual void ResetData();
 
  private:
-  std::mutex m_registerMutex;
+  wpi::mutex m_registerMutex;
   std::atomic<HAL_Bool> m_initialized{false};
   std::shared_ptr<NotifyListenerVector> m_initializedCallbacks = nullptr;
   std::atomic<HAL_Bool> m_value{true};

hal/src/main/native/sim/MockData/DigitalPWMData.cpp

@@ -28,7 +28,7 @@ int32_t DigitalPWMData::RegisterInitializedCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_initializedCallbacks = RegisterCallback(
         m_initializedCallbacks, "Initialized", callback, param, &newUid);
   }
@@ -64,7 +64,7 @@ int32_t DigitalPWMData::RegisterDutyCycleCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_dutyCycleCallbacks = RegisterCallback(m_dutyCycleCallbacks, "DutyCycle",
                                             callback, param, &newUid);
   }
@@ -100,7 +100,7 @@ int32_t DigitalPWMData::RegisterPinCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_pinCallbacks =
         RegisterCallback(m_pinCallbacks, "Pin", callback, param, &newUid);
   }

hal/src/main/native/sim/MockData/DigitalPWMDataInternal.h

@@ -10,6 +10,8 @@
 #include <atomic>
 #include <memory>
 
+#include <support/mutex.h>
+
 #include "MockData/DigitalPWMData.h"
 #include "MockData/NotifyListenerVector.h"
 
@@ -40,7 +42,7 @@ class DigitalPWMData {
   virtual void ResetData();
 
  private:
-  std::mutex m_registerMutex;
+  wpi::mutex m_registerMutex;
   std::atomic<HAL_Bool> m_initialized{false};
   std::shared_ptr<NotifyListenerVector> m_initializedCallbacks = nullptr;
   std::atomic<double> m_dutyCycle{false};

hal/src/main/native/sim/MockData/DriverStationData.cpp

@@ -49,7 +49,7 @@ void DriverStationData::ResetData() {
   m_dsAttachedCallbacks = nullptr;
 
   {
-    std::lock_guard<std::mutex> lock(m_joystickDataMutex);
+    std::lock_guard<wpi::mutex> lock(m_joystickDataMutex);
     m_joystickAxes = std::make_unique<HAL_JoystickAxes[]>(6);
     m_joystickPOVs = std::make_unique<HAL_JoystickPOVs[]>(6);
     m_joystickButtons = std::make_unique<HAL_JoystickButtons[]>(6);
@@ -66,7 +66,7 @@ void DriverStationData::ResetData() {
     }
   }
   {
-    std::lock_guard<std::mutex> lock(m_matchInfoMutex);
+    std::lock_guard<wpi::mutex> lock(m_matchInfoMutex);
 
     m_matchInfo = std::make_unique<MatchInfoDataStore>();
   }
@@ -79,7 +79,7 @@ int32_t DriverStationData::RegisterEnabledCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_enabledCallbacks = RegisterCallback(m_enabledCallbacks, "Enabled",
                                           callback, param, &newUid);
   }
@@ -114,7 +114,7 @@ int32_t DriverStationData::RegisterAutonomousCallback(
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_autonomousCallbacks = RegisterCallback(
         m_autonomousCallbacks, "Autonomous", callback, param, &newUid);
   }
@@ -150,7 +150,7 @@ int32_t DriverStationData::RegisterTestCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_testCallbacks =
         RegisterCallback(m_testCallbacks, "Test", callback, param, &newUid);
   }
@@ -186,7 +186,7 @@ int32_t DriverStationData::RegisterEStopCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_eStopCallbacks =
         RegisterCallback(m_eStopCallbacks, "EStop", callback, param, &newUid);
   }
@@ -221,7 +221,7 @@ int32_t DriverStationData::RegisterFmsAttachedCallback(
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_fmsAttachedCallbacks = RegisterCallback(
         m_fmsAttachedCallbacks, "FmsAttached", callback, param, &newUid);
   }
@@ -256,7 +256,7 @@ int32_t DriverStationData::RegisterDsAttachedCallback(
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_dsAttachedCallbacks = RegisterCallback(
         m_dsAttachedCallbacks, "DsAttached", callback, param, &newUid);
   }
@@ -291,7 +291,7 @@ int32_t DriverStationData::RegisterAllianceStationIdCallback(
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_allianceStationIdCallbacks =
         RegisterCallback(m_allianceStationIdCallbacks, "AllianceStationId",
                          callback, param, &newUid);
@@ -332,7 +332,7 @@ int32_t DriverStationData::RegisterMatchTimeCallback(
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_matchTimeCallbacks = RegisterCallback(m_matchTimeCallbacks, "MatchTime",
                                             callback, param, &newUid);
   }
@@ -363,22 +363,22 @@ void DriverStationData::SetMatchTime(double matchTime) {
 
 void DriverStationData::GetJoystickAxes(int32_t joystickNum,
                                         HAL_JoystickAxes* axes) {
-  std::lock_guard<std::mutex> lock(m_joystickDataMutex);
+  std::lock_guard<wpi::mutex> lock(m_joystickDataMutex);
   *axes = m_joystickAxes[joystickNum];
 }
 void DriverStationData::GetJoystickPOVs(int32_t joystickNum,
                                         HAL_JoystickPOVs* povs) {
-  std::lock_guard<std::mutex> lock(m_joystickDataMutex);
+  std::lock_guard<wpi::mutex> lock(m_joystickDataMutex);
   *povs = m_joystickPOVs[joystickNum];
 }
 void DriverStationData::GetJoystickButtons(int32_t joystickNum,
                                            HAL_JoystickButtons* buttons) {
-  std::lock_guard<std::mutex> lock(m_joystickDataMutex);
+  std::lock_guard<wpi::mutex> lock(m_joystickDataMutex);
   *buttons = m_joystickButtons[joystickNum];
 }
 void DriverStationData::GetJoystickDescriptor(
     int32_t joystickNum, HAL_JoystickDescriptor* descriptor) {
-  std::lock_guard<std::mutex> lock(m_joystickDataMutex);
+  std::lock_guard<wpi::mutex> lock(m_joystickDataMutex);
   *descriptor = m_joystickDescriptor[joystickNum];
   // Always ensure name is null terminated
   descriptor->name[255] = '\0';
@@ -387,13 +387,13 @@ void DriverStationData::GetJoystickOutputs(int32_t joystickNum,
                                            int64_t* outputs,
                                            int32_t* leftRumble,
                                            int32_t* rightRumble) {
-  std::lock_guard<std::mutex> lock(m_joystickDataMutex);
+  std::lock_guard<wpi::mutex> lock(m_joystickDataMutex);
   *leftRumble = m_joystickOutputs[joystickNum].leftRumble;
   *outputs = m_joystickOutputs[joystickNum].outputs;
   *rightRumble = m_joystickOutputs[joystickNum].rightRumble;
 }
 void DriverStationData::GetMatchInfo(HAL_MatchInfo* info) {
-  std::lock_guard<std::mutex> lock(m_matchInfoMutex);
+  std::lock_guard<wpi::mutex> lock(m_matchInfoMutex);
   auto eventLen = m_matchInfo->eventName.size();
   info->eventName = static_cast<char*>(std::malloc(eventLen + 1));
   std::memcpy(info->eventName, m_matchInfo->eventName.c_str(), eventLen);
@@ -414,37 +414,37 @@ void DriverStationData::FreeMatchInfo(const HAL_MatchInfo* info) {
 
 void DriverStationData::SetJoystickAxes(int32_t joystickNum,
                                         const HAL_JoystickAxes* axes) {
-  std::lock_guard<std::mutex> lock(m_joystickDataMutex);
+  std::lock_guard<wpi::mutex> lock(m_joystickDataMutex);
   m_joystickAxes[joystickNum] = *axes;
 }
 void DriverStationData::SetJoystickPOVs(int32_t joystickNum,
                                         const HAL_JoystickPOVs* povs) {
-  std::lock_guard<std::mutex> lock(m_joystickDataMutex);
+  std::lock_guard<wpi::mutex> lock(m_joystickDataMutex);
   m_joystickPOVs[joystickNum] = *povs;
 }
 void DriverStationData::SetJoystickButtons(int32_t joystickNum,
                                            const HAL_JoystickButtons* buttons) {
-  std::lock_guard<std::mutex> lock(m_joystickDataMutex);
+  std::lock_guard<wpi::mutex> lock(m_joystickDataMutex);
   m_joystickButtons[joystickNum] = *buttons;
 }
 
 void DriverStationData::SetJoystickDescriptor(
     int32_t joystickNum, const HAL_JoystickDescriptor* descriptor) {
-  std::lock_guard<std::mutex> lock(m_joystickDataMutex);
+  std::lock_guard<wpi::mutex> lock(m_joystickDataMutex);
   m_joystickDescriptor[joystickNum] = *descriptor;
 }
 
 void DriverStationData::SetJoystickOutputs(int32_t joystickNum, int64_t outputs,
                                            int32_t leftRumble,
                                            int32_t rightRumble) {
-  std::lock_guard<std::mutex> lock(m_joystickDataMutex);
+  std::lock_guard<wpi::mutex> lock(m_joystickDataMutex);
   m_joystickOutputs[joystickNum].leftRumble = leftRumble;
   m_joystickOutputs[joystickNum].outputs = outputs;
   m_joystickOutputs[joystickNum].rightRumble = rightRumble;
 }
 
 void DriverStationData::SetMatchInfo(const HAL_MatchInfo* info) {
-  std::lock_guard<std::mutex> lock(m_matchInfoMutex);
+  std::lock_guard<wpi::mutex> lock(m_matchInfoMutex);
   m_matchInfo->eventName = info->eventName;
   m_matchInfo->gameSpecificMessage = info->gameSpecificMessage;
   m_matchInfo->matchNumber = info->matchNumber;

hal/src/main/native/sim/MockData/DriverStationDataInternal.h

@@ -11,6 +11,8 @@
 #include <atomic>
 #include <memory>
 
+#include <support/mutex.h>
+
 #include "MockData/DriverStationData.h"
 #include "MockData/NotifyListenerVector.h"
 
@@ -103,7 +105,7 @@ class DriverStationData {
   void NotifyNewData();
 
  private:
-  std::mutex m_registerMutex;
+  wpi::mutex m_registerMutex;
   std::atomic<HAL_Bool> m_enabled{false};
   std::shared_ptr<NotifyListenerVector> m_enabledCallbacks = nullptr;
   std::atomic<HAL_Bool> m_autonomous{false};
@@ -122,8 +124,8 @@ class DriverStationData {
   std::atomic<double> m_matchTime{0.0};
   std::shared_ptr<NotifyListenerVector> m_matchTimeCallbacks = nullptr;
 
-  std::mutex m_joystickDataMutex;
-  std::mutex m_matchInfoMutex;
+  wpi::mutex m_joystickDataMutex;
+  wpi::mutex m_matchInfoMutex;
 
   std::unique_ptr<HAL_JoystickAxes[]> m_joystickAxes;
   std::unique_ptr<HAL_JoystickPOVs[]> m_joystickPOVs;

hal/src/main/native/sim/MockData/EncoderData.cpp

@@ -38,7 +38,7 @@ int32_t EncoderData::RegisterInitializedCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_initializedCallbacks = RegisterCallback(
         m_initializedCallbacks, "Initialized", callback, param, &newUid);
   }
@@ -74,7 +74,7 @@ int32_t EncoderData::RegisterCountCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_countCallbacks =
         RegisterCallback(m_countCallbacks, "Count", callback, param, &newUid);
   }
@@ -110,7 +110,7 @@ int32_t EncoderData::RegisterPeriodCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_periodCallbacks =
         RegisterCallback(m_periodCallbacks, "Period", callback, param, &newUid);
   }
@@ -146,7 +146,7 @@ int32_t EncoderData::RegisterResetCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_resetCallbacks =
         RegisterCallback(m_resetCallbacks, "Reset", callback, param, &newUid);
   }
@@ -182,7 +182,7 @@ int32_t EncoderData::RegisterMaxPeriodCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_maxPeriodCallbacks = RegisterCallback(m_maxPeriodCallbacks, "MaxPeriod",
                                             callback, param, &newUid);
   }
@@ -218,7 +218,7 @@ int32_t EncoderData::RegisterDirectionCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_directionCallbacks = RegisterCallback(m_directionCallbacks, "Direction",
                                             callback, param, &newUid);
   }
@@ -253,7 +253,7 @@ int32_t EncoderData::RegisterReverseDirectionCallback(
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_reverseDirectionCallbacks =
         RegisterCallback(m_reverseDirectionCallbacks, "ReverseDirection",
                          callback, param, &newUid);
@@ -290,7 +290,7 @@ int32_t EncoderData::RegisterSamplesToAverageCallback(
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_samplesToAverageCallbacks =
         RegisterCallback(m_samplesToAverageCallbacks, "SamplesToAverage",
                          callback, param, &newUid);

hal/src/main/native/sim/MockData/EncoderDataInternal.h

@@ -11,6 +11,8 @@
 #include <limits>
 #include <memory>
 
+#include <support/mutex.h>
+
 #include "MockData/EncoderData.h"
 #include "MockData/NotifyListenerVector.h"
 
@@ -76,7 +78,7 @@ class EncoderData {
   virtual void ResetData();
 
  private:
-  std::mutex m_registerMutex;
+  wpi::mutex m_registerMutex;
   std::atomic<HAL_Bool> m_initialized{false};
   std::shared_ptr<NotifyListenerVector> m_initializedCallbacks = nullptr;
   std::atomic<int32_t> m_count{0};

hal/src/main/native/sim/MockData/I2CData.cpp

@@ -34,7 +34,7 @@ int32_t I2CData::RegisterInitializedCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_initializedCallbacks = RegisterCallback(
         m_initializedCallbacks, "Initialized", callback, param, &newUid);
   }
@@ -69,7 +69,7 @@ int32_t I2CData::RegisterReadCallback(HAL_BufferCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_readCallbacks =
         RegisterCallback(m_readCallbacks, "Read", callback, param, &newUid);
   }
@@ -86,7 +86,7 @@ int32_t I2CData::RegisterWriteCallback(HAL_BufferCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_writeCallbacks =
         RegisterCallback(m_writeCallbacks, "Write", callback, param, &newUid);
   }
@@ -99,11 +99,11 @@ void I2CData::CancelWriteCallback(int32_t uid) {
 
 void I2CData::Write(int32_t deviceAddress, uint8_t* dataToSend,
                     int32_t sendSize) {
-  std::lock_guard<std::mutex> lock(m_dataMutex);
+  std::lock_guard<wpi::mutex> lock(m_dataMutex);
   InvokeCallback(m_writeCallbacks, "Write", dataToSend, sendSize);
 }
 void I2CData::Read(int32_t deviceAddress, uint8_t* buffer, int32_t count) {
-  std::lock_guard<std::mutex> lock(m_dataMutex);
+  std::lock_guard<wpi::mutex> lock(m_dataMutex);
   InvokeCallback(m_readCallbacks, "Read", buffer, count);
 }
 

hal/src/main/native/sim/MockData/I2CDataInternal.h

@@ -11,6 +11,8 @@
 #include <limits>
 #include <memory>
 
+#include <support/mutex.h>
+
 #include "MockData/I2CData.h"
 #include "MockData/NotifyListenerVector.h"
 
@@ -39,8 +41,8 @@ class I2CData {
   void ResetData();
 
  private:
-  std::mutex m_registerMutex;
-  std::mutex m_dataMutex;
+  wpi::mutex m_registerMutex;
+  wpi::mutex m_dataMutex;
   std::atomic<HAL_Bool> m_initialized{false};
   std::shared_ptr<NotifyListenerVector> m_initializedCallbacks = nullptr;
   std::shared_ptr<BufferListenerVector> m_readCallbacks = nullptr;

hal/src/main/native/sim/MockData/PCMData.cpp

@@ -38,7 +38,7 @@ int32_t PCMData::RegisterSolenoidInitializedCallback(
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_solenoidInitializedCallbacks[channel] =
         RegisterCallback(m_solenoidInitializedCallbacks[channel],
                          "SolenoidInitialized", callback, param, &newUid);
@@ -84,7 +84,7 @@ int32_t PCMData::RegisterSolenoidOutputCallback(int32_t channel,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_solenoidOutputCallbacks[channel] =
         RegisterCallback(m_solenoidOutputCallbacks[channel], "SolenoidOutput",
                          callback, param, &newUid);
@@ -123,7 +123,7 @@ int32_t PCMData::RegisterCompressorInitializedCallback(
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_compressorInitializedCallbacks =
         RegisterCallback(m_compressorInitializedCallbacks,
                          "CompressorInitialized", callback, param, &newUid);
@@ -162,7 +162,7 @@ int32_t PCMData::RegisterCompressorOnCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_compressorOnCallbacks = RegisterCallback(
         m_compressorOnCallbacks, "CompressorOn", callback, param, &newUid);
   }
@@ -198,7 +198,7 @@ int32_t PCMData::RegisterClosedLoopEnabledCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_closedLoopEnabledCallbacks =
         RegisterCallback(m_closedLoopEnabledCallbacks, "ClosedLoopEnabled",
                          callback, param, &newUid);
@@ -236,7 +236,7 @@ int32_t PCMData::RegisterPressureSwitchCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_pressureSwitchCallbacks = RegisterCallback(
         m_pressureSwitchCallbacks, "PressureSwitch", callback, param, &newUid);
   }
@@ -272,7 +272,7 @@ int32_t PCMData::RegisterCompressorCurrentCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_compressorCurrentCallbacks =
         RegisterCallback(m_compressorCurrentCallbacks, "CompressorCurrent",
                          callback, param, &newUid);

hal/src/main/native/sim/MockData/PCMDataInternal.h

@@ -10,6 +10,8 @@
 #include <atomic>
 #include <memory>
 
+#include <support/mutex.h>
+
 #include "../PortsInternal.h"
 #include "MockData/NotifyListenerVector.h"
 #include "MockData/PCMData.h"
@@ -75,7 +77,7 @@ class PCMData {
   virtual void ResetData();
 
  private:
-  std::mutex m_registerMutex;
+  wpi::mutex m_registerMutex;
   std::atomic<HAL_Bool> m_solenoidInitialized[kNumSolenoidChannels];
   std::shared_ptr<NotifyListenerVector>
       m_solenoidInitializedCallbacks[kNumSolenoidChannels];

hal/src/main/native/sim/MockData/PDPData.cpp

@@ -32,7 +32,7 @@ int32_t PDPData::RegisterInitializedCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_initializedCallbacks = RegisterCallback(
         m_initializedCallbacks, "Initialized", callback, param, &newUid);
   }
@@ -68,7 +68,7 @@ int32_t PDPData::RegisterTemperatureCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_temperatureCallbacks = RegisterCallback(
         m_temperatureCallbacks, "Temperature", callback, param, &newUid);
   }
@@ -103,7 +103,7 @@ int32_t PDPData::RegisterVoltageCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_voltageCallbacks = RegisterCallback(m_voltageCallbacks, "Voltage",
                                           callback, param, &newUid);
   }
@@ -139,7 +139,7 @@ int32_t PDPData::RegisterCurrentCallback(int32_t channel,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_currentCallbacks[channel] = RegisterCallback(
         m_currentCallbacks[channel], "Current", callback, param, &newUid);
   }

hal/src/main/native/sim/MockData/PDPDataInternal.h

@@ -10,6 +10,8 @@
 #include <atomic>
 #include <memory>
 
+#include <support/mutex.h>
+
 #include "../PortsInternal.h"
 #include "MockData/NotifyListenerVector.h"
 #include "MockData/PDPData.h"
@@ -48,7 +50,7 @@ class PDPData {
   virtual void ResetData();
 
  private:
-  std::mutex m_registerMutex;
+  wpi::mutex m_registerMutex;
   std::atomic<HAL_Bool> m_initialized{false};
   std::shared_ptr<NotifyListenerVector> m_initializedCallbacks = nullptr;
   std::atomic<double> m_temperature{0.0};

hal/src/main/native/sim/MockData/PWMData.cpp

@@ -34,7 +34,7 @@ int32_t PWMData::RegisterInitializedCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_initializedCallbacks = RegisterCallback(
         m_initializedCallbacks, "Initialized", callback, param, &newUid);
   }
@@ -69,7 +69,7 @@ int32_t PWMData::RegisterRawValueCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_rawValueCallbacks = RegisterCallback(m_rawValueCallbacks, "RawValue",
                                            callback, param, &newUid);
   }
@@ -104,7 +104,7 @@ int32_t PWMData::RegisterSpeedCallback(HAL_NotifyCallback callback, void* param,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_speedCallbacks =
         RegisterCallback(m_speedCallbacks, "Speed", callback, param, &newUid);
   }
@@ -139,7 +139,7 @@ int32_t PWMData::RegisterPositionCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_positionCallbacks = RegisterCallback(m_positionCallbacks, "Position",
                                            callback, param, &newUid);
   }
@@ -175,7 +175,7 @@ int32_t PWMData::RegisterPeriodScaleCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_periodScaleCallbacks = RegisterCallback(
         m_periodScaleCallbacks, "PeriodScale", callback, param, &newUid);
   }
@@ -211,7 +211,7 @@ int32_t PWMData::RegisterZeroLatchCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_zeroLatchCallbacks = RegisterCallback(m_zeroLatchCallbacks, "ZeroLatch",
                                             callback, param, &newUid);
   }

hal/src/main/native/sim/MockData/PWMDataInternal.h

@@ -10,6 +10,8 @@
 #include <atomic>
 #include <memory>
 
+#include <support/mutex.h>
+
 #include "MockData/NotifyListenerVector.h"
 #include "MockData/PWMData.h"
 
@@ -61,7 +63,7 @@ class PWMData {
   virtual void ResetData();
 
  private:
-  std::mutex m_registerMutex;
+  wpi::mutex m_registerMutex;
   std::atomic<HAL_Bool> m_initialized{false};
   std::shared_ptr<NotifyListenerVector> m_initializedCallbacks = nullptr;
   std::atomic<int32_t> m_rawValue{0};

hal/src/main/native/sim/MockData/RelayData.cpp

@@ -29,7 +29,7 @@ int32_t RelayData::RegisterInitializedForwardCallback(
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_initializedForwardCallbacks =
         RegisterCallback(m_initializedForwardCallbacks, "InitializedForward",
                          callback, param, &newUid);
@@ -66,7 +66,7 @@ int32_t RelayData::RegisterInitializedReverseCallback(
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_initializedReverseCallbacks =
         RegisterCallback(m_initializedReverseCallbacks, "InitializedReverse",
                          callback, param, &newUid);
@@ -104,7 +104,7 @@ int32_t RelayData::RegisterForwardCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_forwardCallbacks = RegisterCallback(m_forwardCallbacks, "Forward",
                                           callback, param, &newUid);
   }
@@ -140,7 +140,7 @@ int32_t RelayData::RegisterReverseCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_reverseCallbacks = RegisterCallback(m_reverseCallbacks, "Reverse",
                                           callback, param, &newUid);
   }

hal/src/main/native/sim/MockData/RelayDataInternal.h

@@ -10,6 +10,8 @@
 #include <atomic>
 #include <memory>
 
+#include <support/mutex.h>
+
 #include "MockData/NotifyListenerVector.h"
 #include "MockData/RelayData.h"
 
@@ -49,7 +51,7 @@ class RelayData {
   virtual void ResetData();
 
  private:
-  std::mutex m_registerMutex;
+  wpi::mutex m_registerMutex;
   std::atomic<HAL_Bool> m_initializedForward{false};
   std::shared_ptr<NotifyListenerVector> m_initializedForwardCallbacks = nullptr;
   std::atomic<HAL_Bool> m_initializedReverse{false};

hal/src/main/native/sim/MockData/RoboRioData.cpp

@@ -52,7 +52,7 @@ int32_t RoboRioData::RegisterFPGAButtonCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_fPGAButtonCallbacks = RegisterCallback(
         m_fPGAButtonCallbacks, "FPGAButton", callback, param, &newUid);
   }
@@ -88,7 +88,7 @@ int32_t RoboRioData::RegisterVInVoltageCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_vInVoltageCallbacks = RegisterCallback(
         m_vInVoltageCallbacks, "VInVoltage", callback, param, &newUid);
   }
@@ -124,7 +124,7 @@ int32_t RoboRioData::RegisterVInCurrentCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_vInCurrentCallbacks = RegisterCallback(
         m_vInCurrentCallbacks, "VInCurrent", callback, param, &newUid);
   }
@@ -160,7 +160,7 @@ int32_t RoboRioData::RegisterUserVoltage6VCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_userVoltage6VCallbacks = RegisterCallback(
         m_userVoltage6VCallbacks, "UserVoltage6V", callback, param, &newUid);
   }
@@ -196,7 +196,7 @@ int32_t RoboRioData::RegisterUserCurrent6VCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_userCurrent6VCallbacks = RegisterCallback(
         m_userCurrent6VCallbacks, "UserCurrent6V", callback, param, &newUid);
   }
@@ -232,7 +232,7 @@ int32_t RoboRioData::RegisterUserActive6VCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_userActive6VCallbacks = RegisterCallback(
         m_userActive6VCallbacks, "UserActive6V", callback, param, &newUid);
   }
@@ -268,7 +268,7 @@ int32_t RoboRioData::RegisterUserVoltage5VCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_userVoltage5VCallbacks = RegisterCallback(
         m_userVoltage5VCallbacks, "UserVoltage5V", callback, param, &newUid);
   }
@@ -304,7 +304,7 @@ int32_t RoboRioData::RegisterUserCurrent5VCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_userCurrent5VCallbacks = RegisterCallback(
         m_userCurrent5VCallbacks, "UserCurrent5V", callback, param, &newUid);
   }
@@ -340,7 +340,7 @@ int32_t RoboRioData::RegisterUserActive5VCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_userActive5VCallbacks = RegisterCallback(
         m_userActive5VCallbacks, "UserActive5V", callback, param, &newUid);
   }
@@ -376,7 +376,7 @@ int32_t RoboRioData::RegisterUserVoltage3V3Callback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_userVoltage3V3Callbacks = RegisterCallback(
         m_userVoltage3V3Callbacks, "UserVoltage3V3", callback, param, &newUid);
   }
@@ -412,7 +412,7 @@ int32_t RoboRioData::RegisterUserCurrent3V3Callback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_userCurrent3V3Callbacks = RegisterCallback(
         m_userCurrent3V3Callbacks, "UserCurrent3V3", callback, param, &newUid);
   }
@@ -448,7 +448,7 @@ int32_t RoboRioData::RegisterUserActive3V3Callback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_userActive3V3Callbacks = RegisterCallback(
         m_userActive3V3Callbacks, "UserActive3V3", callback, param, &newUid);
   }
@@ -484,7 +484,7 @@ int32_t RoboRioData::RegisterUserFaults6VCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_userFaults6VCallbacks = RegisterCallback(
         m_userFaults6VCallbacks, "UserFaults6V", callback, param, &newUid);
   }
@@ -520,7 +520,7 @@ int32_t RoboRioData::RegisterUserFaults5VCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_userFaults5VCallbacks = RegisterCallback(
         m_userFaults5VCallbacks, "UserFaults5V", callback, param, &newUid);
   }
@@ -556,7 +556,7 @@ int32_t RoboRioData::RegisterUserFaults3V3Callback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_userFaults3V3Callbacks = RegisterCallback(
         m_userFaults3V3Callbacks, "UserFaults3V3", callback, param, &newUid);
   }

hal/src/main/native/sim/MockData/RoboRioDataInternal.h

@@ -10,6 +10,8 @@
 #include <atomic>
 #include <memory>
 
+#include <support/mutex.h>
+
 #include "MockData/NotifyListenerVector.h"
 #include "MockData/RoboRioData.h"
 
@@ -124,7 +126,7 @@ class RoboRioData {
   virtual void ResetData();
 
  private:
-  std::mutex m_registerMutex;
+  wpi::mutex m_registerMutex;
   std::atomic<HAL_Bool> m_fPGAButton{false};
   std::shared_ptr<NotifyListenerVector> m_fPGAButtonCallbacks = nullptr;
   std::atomic<double> m_vInVoltage{0.0};

hal/src/main/native/sim/MockData/SPIAccelerometerData.cpp

@@ -31,7 +31,7 @@ int32_t SPIAccelerometerData::RegisterActiveCallback(
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_activeCallbacks =
         RegisterCallback(m_activeCallbacks, "Active", callback, param, &newUid);
   }
@@ -67,7 +67,7 @@ int32_t SPIAccelerometerData::RegisterRangeCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_rangeCallbacks =
         RegisterCallback(m_rangeCallbacks, "Range", callback, param, &newUid);
   }
@@ -103,7 +103,7 @@ int32_t SPIAccelerometerData::RegisterXCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_xCallbacks =
         RegisterCallback(m_xCallbacks, "X", callback, param, &newUid);
   }
@@ -139,7 +139,7 @@ int32_t SPIAccelerometerData::RegisterYCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_yCallbacks =
         RegisterCallback(m_yCallbacks, "Y", callback, param, &newUid);
   }
@@ -175,7 +175,7 @@ int32_t SPIAccelerometerData::RegisterZCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_zCallbacks =
         RegisterCallback(m_zCallbacks, "Z", callback, param, &newUid);
   }

hal/src/main/native/sim/MockData/SPIAccelerometerDataInternal.h

@@ -10,6 +10,8 @@
 #include <atomic>
 #include <memory>
 
+#include <support/mutex.h>
+
 #include "MockData/NotifyListenerVector.h"
 #include "MockData/SPIAccelerometerData.h"
 
@@ -54,7 +56,7 @@ class SPIAccelerometerData {
   virtual void ResetData();
 
  private:
-  std::mutex m_registerMutex;
+  wpi::mutex m_registerMutex;
   std::atomic<HAL_Bool> m_active{false};
   std::shared_ptr<NotifyListenerVector> m_activeCallbacks = nullptr;
   std::atomic<int32_t> m_range{0};

hal/src/main/native/sim/MockData/SPIData.cpp

@@ -35,7 +35,7 @@ int32_t SPIData::RegisterInitializedCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_initializedCallbacks = RegisterCallback(
         m_initializedCallbacks, "Initialized", callback, param, &newUid);
   }
@@ -70,7 +70,7 @@ int32_t SPIData::RegisterReadCallback(HAL_BufferCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_readCallbacks =
         RegisterCallback(m_readCallbacks, "Read", callback, param, &newUid);
   }
@@ -88,7 +88,7 @@ int32_t SPIData::RegisterWriteCallback(HAL_BufferCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_writeCallbacks =
         RegisterCallback(m_writeCallbacks, "Write", callback, param, &newUid);
   }
@@ -107,7 +107,7 @@ int32_t SPIData::RegisterResetAccumulatorCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_resetAccumulatorCallback =
         RegisterCallback(m_resetAccumulatorCallback, "ResetAccumulator",
                          callback, param, &newUid);
@@ -131,7 +131,7 @@ int32_t SPIData::RegisterAccumulatorCallback(HAL_NotifyCallback callback,
   if (callback == nullptr) return -1;
   int32_t newUid = 0;
   {
-    std::lock_guard<std::mutex> lock(m_registerMutex);
+    std::lock_guard<wpi::mutex> lock(m_registerMutex);
     m_setAccumulatorCallback = RegisterCallback(
         m_setAccumulatorCallback, "SetAccumulator", callback, param, &newUid);
   }
@@ -161,14 +161,14 @@ void SPIData::SetAccumulatorValue(int64_t value) {
 int64_t SPIData::GetAccumulatorValue() { return m_accumulatorValue; }
 
 int32_t SPIData::Read(uint8_t* buffer, int32_t count) {
-  std::lock_guard<std::mutex> lock(m_dataMutex);
+  std::lock_guard<wpi::mutex> lock(m_dataMutex);
   InvokeCallback(m_readCallbacks, "Read", buffer, count);
 
   return count;
 }
 
 int32_t SPIData::Write(uint8_t* dataToSend, int32_t sendSize) {
-  std::lock_guard<std::mutex> lock(m_dataMutex);
+  std::lock_guard<wpi::mutex> lock(m_dataMutex);
   InvokeCallback(m_writeCallbacks, "Write", dataToSend, sendSize);
 
   return sendSize;
@@ -176,7 +176,7 @@ int32_t SPIData::Write(uint8_t* dataToSend, int32_t sendSize) {
 
 int32_t SPIData::Transaction(uint8_t* dataToSend, uint8_t* dataReceived,
                              int32_t size) {
-  std::lock_guard<std::mutex> lock(m_dataMutex);
+  std::lock_guard<wpi::mutex> lock(m_dataMutex);
   return size;
 }
 

hal/src/main/native/sim/MockData/SPIDataInternal.h

@@ -11,6 +11,8 @@
 #include <limits>
 #include <memory>
 
+#include <support/mutex.h>
+
 #include "MockData/NotifyListenerVector.h"
 #include "MockData/SPIData.h"
 
@@ -52,8 +54,8 @@ class SPIData {
   void ResetData();
 
  private:
-  std::mutex m_registerMutex;
-  std::mutex m_dataMutex;
+  wpi::mutex m_registerMutex;
+  wpi::mutex m_dataMutex;
   std::atomic<HAL_Bool> m_initialized{false};
   std::atomic<int64_t> m_accumulatorValue{false};
   std::shared_ptr<NotifyListenerVector> m_initializedCallbacks = nullptr;