Run wpiformat on merged repo (#1021)

hal/src/main/native/sim/jni/AccelerometerDataJNI.cpp

@@ -13,148 +13,266 @@
 
 extern "C" {
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI
+ * Method:    registerActiveCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_registerActiveCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_registerActiveCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterAccelerometerActiveCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI
+ * Method:    cancelActiveCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_cancelActiveCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_cancelActiveCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelAccelerometerActiveCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI
+ * Method:    getActive
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_getActive(JNIEnv*,
-                                                                   jclass,
-                                                                   jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_getActive
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetAccelerometerActive(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI
+ * Method:    setActive
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_setActive(
-    JNIEnv*, jclass, jint index, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_setActive
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetAccelerometerActive(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI
+ * Method:    registerRangeCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_registerRangeCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_registerRangeCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterAccelerometerRangeCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI
+ * Method:    cancelRangeCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_cancelRangeCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_cancelRangeCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelAccelerometerRangeCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI
+ * Method:    getRange
+ * Signature: (I)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_getRange(JNIEnv*,
-                                                                  jclass,
-                                                                  jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_getRange
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetAccelerometerRange(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI
+ * Method:    setRange
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_setRange(JNIEnv*,
-                                                                  jclass,
-                                                                  jint index,
-                                                                  jint value) {
+Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_setRange
+  (JNIEnv*, jclass, jint index, jint value)
+{
   HALSIM_SetAccelerometerRange(index,
                                static_cast<HAL_AccelerometerRange>(value));
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI
+ * Method:    registerXCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_registerXCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_registerXCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterAccelerometerXCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI
+ * Method:    cancelXCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_cancelXCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_cancelXCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelAccelerometerXCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI
+ * Method:    getX
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_getX(JNIEnv*, jclass,
-                                                              jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_getX
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetAccelerometerX(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI
+ * Method:    setX
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_setX(JNIEnv*, jclass,
-                                                              jint index,
-                                                              jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_setX
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetAccelerometerX(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI
+ * Method:    registerYCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_registerYCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_registerYCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterAccelerometerYCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI
+ * Method:    cancelYCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_cancelYCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_cancelYCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelAccelerometerYCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI
+ * Method:    getY
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_getY(JNIEnv*, jclass,
-                                                              jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_getY
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetAccelerometerY(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI
+ * Method:    setY
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_setY(JNIEnv*, jclass,
-                                                              jint index,
-                                                              jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_setY
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetAccelerometerY(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI
+ * Method:    registerZCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_registerZCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_registerZCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterAccelerometerZCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI
+ * Method:    cancelZCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_cancelZCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_cancelZCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelAccelerometerZCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI
+ * Method:    getZ
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_getZ(JNIEnv*, jclass,
-                                                              jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_getZ
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetAccelerometerZ(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI
+ * Method:    setZ
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_setZ(JNIEnv*, jclass,
-                                                              jint index,
-                                                              jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_setZ
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetAccelerometerZ(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI
+ * Method:    resetData
+ * Signature: (I)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_resetData(JNIEnv*,
-                                                                   jclass,
-                                                                   jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_AccelerometerDataJNI_resetData
+  (JNIEnv*, jclass, jint index)
+{
   HALSIM_ResetAccelerometerData(index);
 }
 

hal/src/main/native/sim/jni/AnalogGyroDataJNI.cpp

@@ -13,89 +13,165 @@
 
 extern "C" {
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI
+ * Method:    registerAngleCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_registerAngleCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_registerAngleCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterAnalogGyroAngleCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI
+ * Method:    cancelAngleCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_cancelAngleCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_cancelAngleCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelAnalogGyroAngleCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI
+ * Method:    getAngle
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_getAngle(JNIEnv*, jclass,
-                                                               jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_getAngle
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetAnalogGyroAngle(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI
+ * Method:    setAngle
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_setAngle(JNIEnv*, jclass,
-                                                               jint index,
-                                                               jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_setAngle
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetAnalogGyroAngle(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI
+ * Method:    registerRateCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_registerRateCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_registerRateCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterAnalogGyroRateCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI
+ * Method:    cancelRateCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_cancelRateCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_cancelRateCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelAnalogGyroRateCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI
+ * Method:    getRate
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_getRate(JNIEnv*, jclass,
-                                                              jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_getRate
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetAnalogGyroRate(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI
+ * Method:    setRate
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_setRate(JNIEnv*, jclass,
-                                                              jint index,
-                                                              jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_setRate
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetAnalogGyroRate(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI
+ * Method:    registerInitializedCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_registerInitializedCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_registerInitializedCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterAnalogGyroInitializedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI
+ * Method:    cancelInitializedCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_cancelInitializedCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_cancelInitializedCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelAnalogGyroInitializedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI
+ * Method:    getInitialized
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_getInitialized(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_getInitialized
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetAnalogGyroInitialized(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI
+ * Method:    setInitialized
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_setInitialized(
-    JNIEnv*, jclass, jint index, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_setInitialized
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetAnalogGyroInitialized(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI
+ * Method:    resetData
+ * Signature: (I)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_resetData(JNIEnv*, jclass,
-                                                                jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogGyroDataJNI_resetData
+  (JNIEnv*, jclass, jint index)
+{
   HALSIM_ResetAnalogGyroData(index);
 }
 

hal/src/main/native/sim/jni/AnalogInDataJNI.cpp

@@ -13,253 +13,470 @@
 
 extern "C" {
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    registerInitializedCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_registerInitializedCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_registerInitializedCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterAnalogInInitializedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    cancelInitializedCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_cancelInitializedCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_cancelInitializedCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelAnalogInInitializedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    getInitialized
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_getInitialized(JNIEnv*,
-                                                                   jclass,
-                                                                   jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_getInitialized
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetAnalogInInitialized(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    setInitialized
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_setInitialized(
-    JNIEnv*, jclass, jint index, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_setInitialized
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetAnalogInInitialized(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    registerAverageBitsCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_registerAverageBitsCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_registerAverageBitsCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterAnalogInAverageBitsCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    cancelAverageBitsCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_cancelAverageBitsCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_cancelAverageBitsCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelAnalogInAverageBitsCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    getAverageBits
+ * Signature: (I)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_getAverageBits(JNIEnv*,
-                                                                   jclass,
-                                                                   jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_getAverageBits
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetAnalogInAverageBits(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    setAverageBits
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_setAverageBits(JNIEnv*,
-                                                                   jclass,
-                                                                   jint index,
-                                                                   jint value) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_setAverageBits
+  (JNIEnv*, jclass, jint index, jint value)
+{
   HALSIM_SetAnalogInAverageBits(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    registerOversampleBitsCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_registerOversampleBitsCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_registerOversampleBitsCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterAnalogInOversampleBitsCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    cancelOversampleBitsCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_cancelOversampleBitsCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_cancelOversampleBitsCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelAnalogInOversampleBitsCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    getOversampleBits
+ * Signature: (I)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_getOversampleBits(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_getOversampleBits
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetAnalogInOversampleBits(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    setOversampleBits
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_setOversampleBits(
-    JNIEnv*, jclass, jint index, jint value) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_setOversampleBits
+  (JNIEnv*, jclass, jint index, jint value)
+{
   HALSIM_SetAnalogInOversampleBits(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    registerVoltageCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_registerVoltageCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_registerVoltageCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterAnalogInVoltageCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    cancelVoltageCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_cancelVoltageCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_cancelVoltageCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelAnalogInVoltageCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    getVoltage
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_getVoltage(JNIEnv*, jclass,
-                                                               jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_getVoltage
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetAnalogInVoltage(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    setVoltage
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_setVoltage(JNIEnv*, jclass,
-                                                               jint index,
-                                                               jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_setVoltage
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetAnalogInVoltage(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    registerAccumulatorInitializedCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_registerAccumulatorInitializedCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_registerAccumulatorInitializedCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(
       env, index, callback, initialNotify,
       &HALSIM_RegisterAnalogInAccumulatorInitializedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    cancelAccumulatorInitializedCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_cancelAccumulatorInitializedCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_cancelAccumulatorInitializedCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(
       env, handle, index, &HALSIM_CancelAnalogInAccumulatorInitializedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    getAccumulatorInitialized
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_getAccumulatorInitialized(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_getAccumulatorInitialized
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetAnalogInAccumulatorInitialized(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    setAccumulatorInitialized
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_setAccumulatorInitialized(
-    JNIEnv*, jclass, jint index, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_setAccumulatorInitialized
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetAnalogInAccumulatorInitialized(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    registerAccumulatorValueCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_registerAccumulatorValueCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_registerAccumulatorValueCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(
       env, index, callback, initialNotify,
       &HALSIM_RegisterAnalogInAccumulatorValueCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    cancelAccumulatorValueCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_cancelAccumulatorValueCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_cancelAccumulatorValueCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelAnalogInAccumulatorValueCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    getAccumulatorValue
+ * Signature: (I)J
+ */
 JNIEXPORT jlong JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_getAccumulatorValue(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_getAccumulatorValue
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetAnalogInAccumulatorValue(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    setAccumulatorValue
+ * Signature: (IJ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_setAccumulatorValue(
-    JNIEnv*, jclass, jint index, jlong value) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_setAccumulatorValue
+  (JNIEnv*, jclass, jint index, jlong value)
+{
   HALSIM_SetAnalogInAccumulatorValue(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    registerAccumulatorCountCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_registerAccumulatorCountCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_registerAccumulatorCountCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(
       env, index, callback, initialNotify,
       &HALSIM_RegisterAnalogInAccumulatorCountCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    cancelAccumulatorCountCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_cancelAccumulatorCountCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_cancelAccumulatorCountCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelAnalogInAccumulatorCountCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    getAccumulatorCount
+ * Signature: (I)J
+ */
 JNIEXPORT jlong JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_getAccumulatorCount(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_getAccumulatorCount
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetAnalogInAccumulatorCount(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    setAccumulatorCount
+ * Signature: (IJ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_setAccumulatorCount(
-    JNIEnv*, jclass, jint index, jlong value) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_setAccumulatorCount
+  (JNIEnv*, jclass, jint index, jlong value)
+{
   HALSIM_SetAnalogInAccumulatorCount(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    registerAccumulatorCenterCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_registerAccumulatorCenterCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_registerAccumulatorCenterCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(
       env, index, callback, initialNotify,
       &HALSIM_RegisterAnalogInAccumulatorCenterCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    cancelAccumulatorCenterCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_cancelAccumulatorCenterCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_cancelAccumulatorCenterCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelAnalogInAccumulatorCenterCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    getAccumulatorCenter
+ * Signature: (I)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_getAccumulatorCenter(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_getAccumulatorCenter
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetAnalogInAccumulatorCenter(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    setAccumulatorCenter
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_setAccumulatorCenter(
-    JNIEnv*, jclass, jint index, jint value) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_setAccumulatorCenter
+  (JNIEnv*, jclass, jint index, jint value)
+{
   HALSIM_SetAnalogInAccumulatorCenter(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    registerAccumulatorDeadbandCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_registerAccumulatorDeadbandCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_registerAccumulatorDeadbandCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(
       env, index, callback, initialNotify,
       &HALSIM_RegisterAnalogInAccumulatorDeadbandCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    cancelAccumulatorDeadbandCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_cancelAccumulatorDeadbandCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_cancelAccumulatorDeadbandCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelAnalogInAccumulatorDeadbandCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    getAccumulatorDeadband
+ * Signature: (I)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_getAccumulatorDeadband(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_getAccumulatorDeadband
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetAnalogInAccumulatorDeadband(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    setAccumulatorDeadband
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_setAccumulatorDeadband(
-    JNIEnv*, jclass, jint index, jint value) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_setAccumulatorDeadband
+  (JNIEnv*, jclass, jint index, jint value)
+{
   HALSIM_SetAnalogInAccumulatorDeadband(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI
+ * Method:    resetData
+ * Signature: (I)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_resetData(JNIEnv*, jclass,
-                                                              jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogInDataJNI_resetData
+  (JNIEnv*, jclass, jint index)
+{
   HALSIM_ResetAnalogInData(index);
 }
 

hal/src/main/native/sim/jni/AnalogOutDataJNI.cpp

@@ -13,62 +13,115 @@
 
 extern "C" {
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI
+ * Method:    registerVoltageCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI_registerVoltageCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI_registerVoltageCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterAnalogOutVoltageCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI
+ * Method:    cancelVoltageCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI_cancelVoltageCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI_cancelVoltageCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelAnalogOutVoltageCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI
+ * Method:    getVoltage
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI_getVoltage(JNIEnv*, jclass,
-                                                                jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI_getVoltage
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetAnalogOutVoltage(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI
+ * Method:    setVoltage
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI_setVoltage(JNIEnv*, jclass,
-                                                                jint index,
-                                                                jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI_setVoltage
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetAnalogOutVoltage(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI
+ * Method:    registerInitializedCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI_registerInitializedCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI_registerInitializedCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterAnalogOutInitializedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI
+ * Method:    cancelInitializedCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI_cancelInitializedCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI_cancelInitializedCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelAnalogOutInitializedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI
+ * Method:    getInitialized
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI_getInitialized(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI_getInitialized
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetAnalogOutInitialized(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI
+ * Method:    setInitialized
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI_setInitialized(
-    JNIEnv*, jclass, jint index, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI_setInitialized
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetAnalogOutInitialized(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI
+ * Method:    resetData
+ * Signature: (I)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI_resetData(JNIEnv*, jclass,
-                                                               jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogOutDataJNI_resetData
+  (JNIEnv*, jclass, jint index)
+{
   HALSIM_ResetAnalogOutData(index);
 }
 

hal/src/main/native/sim/jni/AnalogTriggerDataJNI.cpp

@@ -13,91 +13,168 @@
 
 extern "C" {
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI
+ * Method:    registerInitializedCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_registerInitializedCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_registerInitializedCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(
       env, index, callback, initialNotify,
       &HALSIM_RegisterAnalogTriggerInitializedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI
+ * Method:    cancelInitializedCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_cancelInitializedCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_cancelInitializedCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelAnalogTriggerInitializedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI
+ * Method:    getInitialized
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_getInitialized(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_getInitialized
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetAnalogTriggerInitialized(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI
+ * Method:    setInitialized
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_setInitialized(
-    JNIEnv*, jclass, jint index, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_setInitialized
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetAnalogTriggerInitialized(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI
+ * Method:    registerTriggerLowerBoundCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_registerTriggerLowerBoundCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_registerTriggerLowerBoundCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(
       env, index, callback, initialNotify,
       &HALSIM_RegisterAnalogTriggerTriggerLowerBoundCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI
+ * Method:    cancelTriggerLowerBoundCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_cancelTriggerLowerBoundCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_cancelTriggerLowerBoundCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(
       env, handle, index, &HALSIM_CancelAnalogTriggerTriggerLowerBoundCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI
+ * Method:    getTriggerLowerBound
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_getTriggerLowerBound(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_getTriggerLowerBound
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetAnalogTriggerTriggerLowerBound(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI
+ * Method:    setTriggerLowerBound
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_setTriggerLowerBound(
-    JNIEnv*, jclass, jint index, jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_setTriggerLowerBound
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetAnalogTriggerTriggerLowerBound(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI
+ * Method:    registerTriggerUpperBoundCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_registerTriggerUpperBoundCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_registerTriggerUpperBoundCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(
       env, index, callback, initialNotify,
       &HALSIM_RegisterAnalogTriggerTriggerUpperBoundCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI
+ * Method:    cancelTriggerUpperBoundCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_cancelTriggerUpperBoundCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_cancelTriggerUpperBoundCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(
       env, handle, index, &HALSIM_CancelAnalogTriggerTriggerUpperBoundCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI
+ * Method:    getTriggerUpperBound
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_getTriggerUpperBound(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_getTriggerUpperBound
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetAnalogTriggerTriggerUpperBound(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI
+ * Method:    setTriggerUpperBound
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_setTriggerUpperBound(
-    JNIEnv*, jclass, jint index, jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_setTriggerUpperBound
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetAnalogTriggerTriggerUpperBound(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI
+ * Method:    resetData
+ * Signature: (I)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_resetData(JNIEnv*,
-                                                                   jclass,
-                                                                   jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_AnalogTriggerDataJNI_resetData
+  (JNIEnv*, jclass, jint index)
+{
   HALSIM_ResetAnalogTriggerData(index);
 }
 

hal/src/main/native/sim/jni/BufferCallbackStore.cpp

@@ -8,6 +8,7 @@
 #include "BufferCallbackStore.h"
 
 #include <jni.h>
+
 #include <wpi/jni_util.h>
 
 #include "HAL/Types.h"

hal/src/main/native/sim/jni/BufferCallbackStore.h

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <jni.h>
+
 #include <wpi/jni_util.h>
 
 #include "HAL/Types.h"

hal/src/main/native/sim/jni/CallbackStore.cpp

@@ -8,6 +8,7 @@
 #include "CallbackStore.h"
 
 #include <jni.h>
+
 #include <wpi/jni_util.h>
 
 #include "HAL/Types.h"

hal/src/main/native/sim/jni/CallbackStore.h

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <jni.h>
+
 #include <wpi/jni_util.h>
 
 #include "HAL/Types.h"

hal/src/main/native/sim/jni/ConstBufferCallbackStore.cpp

@@ -8,6 +8,7 @@
 #include "ConstBufferCallbackStore.h"
 
 #include <jni.h>
+
 #include <wpi/jni_util.h>
 
 #include "HAL/Types.h"

hal/src/main/native/sim/jni/ConstBufferCallbackStore.h

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <jni.h>
+
 #include <wpi/jni_util.h>
 
 #include "HAL/Types.h"

hal/src/main/native/sim/jni/DIODataJNI.cpp

@@ -13,140 +13,264 @@
 
 extern "C" {
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DIODataJNI
+ * Method:    registerInitializedCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_registerInitializedCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_registerInitializedCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterDIOInitializedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DIODataJNI
+ * Method:    cancelInitializedCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_cancelInitializedCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_cancelInitializedCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelDIOInitializedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DIODataJNI
+ * Method:    getInitialized
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_getInitialized(JNIEnv*, jclass,
-                                                              jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_getInitialized
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetDIOInitialized(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DIODataJNI
+ * Method:    setInitialized
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_setInitialized(JNIEnv*, jclass,
-                                                              jint index,
-                                                              jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_setInitialized
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetDIOInitialized(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DIODataJNI
+ * Method:    registerValueCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_registerValueCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_registerValueCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterDIOValueCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DIODataJNI
+ * Method:    cancelValueCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_cancelValueCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_cancelValueCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index, &HALSIM_CancelDIOValueCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DIODataJNI
+ * Method:    getValue
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_getValue(JNIEnv*, jclass,
-                                                        jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_getValue
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetDIOValue(index);
 }
 
-JNIEXPORT void JNICALL Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_setValue(
-    JNIEnv*, jclass, jint index, jboolean value) {
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DIODataJNI
+ * Method:    setValue
+ * Signature: (IZ)V
+ */
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_setValue
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetDIOValue(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DIODataJNI
+ * Method:    registerPulseLengthCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_registerPulseLengthCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_registerPulseLengthCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterDIOPulseLengthCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DIODataJNI
+ * Method:    cancelPulseLengthCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_cancelPulseLengthCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_cancelPulseLengthCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelDIOPulseLengthCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DIODataJNI
+ * Method:    getPulseLength
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_getPulseLength(JNIEnv*, jclass,
-                                                              jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_getPulseLength
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetDIOPulseLength(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DIODataJNI
+ * Method:    setPulseLength
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_setPulseLength(JNIEnv*, jclass,
-                                                              jint index,
-                                                              jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_setPulseLength
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetDIOPulseLength(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DIODataJNI
+ * Method:    registerIsInputCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_registerIsInputCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_registerIsInputCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterDIOIsInputCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DIODataJNI
+ * Method:    cancelIsInputCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_cancelIsInputCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_cancelIsInputCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelDIOIsInputCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DIODataJNI
+ * Method:    getIsInput
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_getIsInput(JNIEnv*, jclass,
-                                                          jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_getIsInput
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetDIOIsInput(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DIODataJNI
+ * Method:    setIsInput
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_setIsInput(JNIEnv*, jclass,
-                                                          jint index,
-                                                          jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_setIsInput
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetDIOIsInput(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DIODataJNI
+ * Method:    registerFilterIndexCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_registerFilterIndexCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_registerFilterIndexCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterDIOFilterIndexCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DIODataJNI
+ * Method:    cancelFilterIndexCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_cancelFilterIndexCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_cancelFilterIndexCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelDIOFilterIndexCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DIODataJNI
+ * Method:    getFilterIndex
+ * Signature: (I)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_getFilterIndex(JNIEnv*, jclass,
-                                                              jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_getFilterIndex
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetDIOFilterIndex(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DIODataJNI
+ * Method:    setFilterIndex
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_setFilterIndex(JNIEnv*, jclass,
-                                                              jint index,
-                                                              jint value) {
+Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_setFilterIndex
+  (JNIEnv*, jclass, jint index, jint value)
+{
   HALSIM_SetDIOFilterIndex(index, value);
 }
 
-JNIEXPORT void JNICALL Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_resetData(
-    JNIEnv*, jclass, jint index) {
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DIODataJNI
+ * Method:    resetData
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_hal_sim_mockdata_DIODataJNI_resetData
+  (JNIEnv*, jclass, jint index)
+{
   HALSIM_ResetDIOData(index);
 }
 

hal/src/main/native/sim/jni/DigitalPWMDataJNI.cpp

@@ -13,89 +13,165 @@
 
 extern "C" {
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI
+ * Method:    registerInitializedCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_registerInitializedCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_registerInitializedCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterDigitalPWMInitializedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI
+ * Method:    cancelInitializedCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_cancelInitializedCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_cancelInitializedCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelDigitalPWMInitializedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI
+ * Method:    getInitialized
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_getInitialized(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_getInitialized
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetDigitalPWMInitialized(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI
+ * Method:    setInitialized
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_setInitialized(
-    JNIEnv*, jclass, jint index, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_setInitialized
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetDigitalPWMInitialized(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI
+ * Method:    registerDutyCycleCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_registerDutyCycleCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_registerDutyCycleCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterDigitalPWMDutyCycleCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI
+ * Method:    cancelDutyCycleCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_cancelDutyCycleCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_cancelDutyCycleCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelDigitalPWMDutyCycleCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI
+ * Method:    getDutyCycle
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_getDutyCycle(JNIEnv*,
-                                                                   jclass,
-                                                                   jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_getDutyCycle
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetDigitalPWMDutyCycle(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI
+ * Method:    setDutyCycle
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_setDutyCycle(
-    JNIEnv*, jclass, jint index, jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_setDutyCycle
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetDigitalPWMDutyCycle(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI
+ * Method:    registerPinCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_registerPinCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_registerPinCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterDigitalPWMPinCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI
+ * Method:    cancelPinCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_cancelPinCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_cancelPinCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelDigitalPWMPinCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI
+ * Method:    getPin
+ * Signature: (I)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_getPin(JNIEnv*, jclass,
-                                                             jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_getPin
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetDigitalPWMPin(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI
+ * Method:    setPin
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_setPin(JNIEnv*, jclass,
-                                                             jint index,
-                                                             jint value) {
+Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_setPin
+  (JNIEnv*, jclass, jint index, jint value)
+{
   HALSIM_SetDigitalPWMPin(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI
+ * Method:    resetData
+ * Signature: (I)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_resetData(JNIEnv*, jclass,
-                                                                jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_DigitalPWMDataJNI_resetData
+  (JNIEnv*, jclass, jint index)
+{
   HALSIM_ResetDigitalPWMData(index);
 }
 

hal/src/main/native/sim/jni/DriverStationDataJNI.cpp

@@ -13,174 +13,319 @@
 
 extern "C" {
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
+ * Method:    registerEnabledCallback
+ * Signature: (Ljava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_registerEnabledCallback(
-    JNIEnv* env, jclass, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_registerEnabledCallback
+  (JNIEnv* env, jclass, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallbackNoIndex(
       env, callback, initialNotify,
       &HALSIM_RegisterDriverStationEnabledCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
+ * Method:    cancelEnabledCallback
+ * Signature: (I)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_cancelEnabledCallback(
-    JNIEnv* env, jclass, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_cancelEnabledCallback
+  (JNIEnv* env, jclass, jint handle)
+{
   return sim::FreeCallbackNoIndex(env, handle,
                                   &HALSIM_CancelDriverStationEnabledCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
+ * Method:    getEnabled
+ * Signature: ()Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_getEnabled(JNIEnv*,
-                                                                    jclass) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_getEnabled
+  (JNIEnv*, jclass)
+{
   return HALSIM_GetDriverStationEnabled();
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
+ * Method:    setEnabled
+ * Signature: (Z)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setEnabled(
-    JNIEnv*, jclass, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setEnabled
+  (JNIEnv*, jclass, jboolean value)
+{
   HALSIM_SetDriverStationEnabled(value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
+ * Method:    registerAutonomousCallback
+ * Signature: (Ljava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_registerAutonomousCallback(
-    JNIEnv* env, jclass, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_registerAutonomousCallback
+  (JNIEnv* env, jclass, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallbackNoIndex(
       env, callback, initialNotify,
       &HALSIM_RegisterDriverStationAutonomousCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
+ * Method:    cancelAutonomousCallback
+ * Signature: (I)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_cancelAutonomousCallback(
-    JNIEnv* env, jclass, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_cancelAutonomousCallback
+  (JNIEnv* env, jclass, jint handle)
+{
   return sim::FreeCallbackNoIndex(
       env, handle, &HALSIM_CancelDriverStationAutonomousCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
+ * Method:    getAutonomous
+ * Signature: ()Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_getAutonomous(JNIEnv*,
-                                                                       jclass) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_getAutonomous
+  (JNIEnv*, jclass)
+{
   return HALSIM_GetDriverStationAutonomous();
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
+ * Method:    setAutonomous
+ * Signature: (Z)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setAutonomous(
-    JNIEnv*, jclass, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setAutonomous
+  (JNIEnv*, jclass, jboolean value)
+{
   HALSIM_SetDriverStationAutonomous(value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
+ * Method:    registerTestCallback
+ * Signature: (Ljava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_registerTestCallback(
-    JNIEnv* env, jclass, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_registerTestCallback
+  (JNIEnv* env, jclass, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallbackNoIndex(
       env, callback, initialNotify, &HALSIM_RegisterDriverStationTestCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
+ * Method:    cancelTestCallback
+ * Signature: (I)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_cancelTestCallback(
-    JNIEnv* env, jclass, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_cancelTestCallback
+  (JNIEnv* env, jclass, jint handle)
+{
   return sim::FreeCallbackNoIndex(env, handle,
                                   &HALSIM_CancelDriverStationTestCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
+ * Method:    getTest
+ * Signature: ()Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_getTest(JNIEnv*,
-                                                                 jclass) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_getTest
+  (JNIEnv*, jclass)
+{
   return HALSIM_GetDriverStationTest();
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
+ * Method:    setTest
+ * Signature: (Z)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setTest(
-    JNIEnv*, jclass, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setTest
+  (JNIEnv*, jclass, jboolean value)
+{
   HALSIM_SetDriverStationTest(value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
+ * Method:    registerEStopCallback
+ * Signature: (Ljava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_registerEStopCallback(
-    JNIEnv* env, jclass, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_registerEStopCallback
+  (JNIEnv* env, jclass, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallbackNoIndex(
       env, callback, initialNotify, &HALSIM_RegisterDriverStationEStopCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
+ * Method:    cancelEStopCallback
+ * Signature: (I)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_cancelEStopCallback(
-    JNIEnv* env, jclass, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_cancelEStopCallback
+  (JNIEnv* env, jclass, jint handle)
+{
   return sim::FreeCallbackNoIndex(env, handle,
                                   &HALSIM_CancelDriverStationEStopCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
+ * Method:    getEStop
+ * Signature: ()Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_getEStop(JNIEnv*,
-                                                                  jclass) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_getEStop
+  (JNIEnv*, jclass)
+{
   return HALSIM_GetDriverStationEStop();
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
+ * Method:    setEStop
+ * Signature: (Z)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setEStop(
-    JNIEnv*, jclass, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setEStop
+  (JNIEnv*, jclass, jboolean value)
+{
   HALSIM_SetDriverStationEStop(value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
+ * Method:    registerFmsAttachedCallback
+ * Signature: (Ljava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_registerFmsAttachedCallback(
-    JNIEnv* env, jclass, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_registerFmsAttachedCallback
+  (JNIEnv* env, jclass, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallbackNoIndex(
       env, callback, initialNotify,
       &HALSIM_RegisterDriverStationFmsAttachedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
+ * Method:    cancelFmsAttachedCallback
+ * Signature: (I)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_cancelFmsAttachedCallback(
-    JNIEnv* env, jclass, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_cancelFmsAttachedCallback
+  (JNIEnv* env, jclass, jint handle)
+{
   return sim::FreeCallbackNoIndex(
       env, handle, &HALSIM_CancelDriverStationFmsAttachedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
+ * Method:    getFmsAttached
+ * Signature: ()Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_getFmsAttached(
-    JNIEnv*, jclass) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_getFmsAttached
+  (JNIEnv*, jclass)
+{
   return HALSIM_GetDriverStationFmsAttached();
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
+ * Method:    setFmsAttached
+ * Signature: (Z)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setFmsAttached(
-    JNIEnv*, jclass, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setFmsAttached
+  (JNIEnv*, jclass, jboolean value)
+{
   HALSIM_SetDriverStationFmsAttached(value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
+ * Method:    registerDsAttachedCallback
+ * Signature: (Ljava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_registerDsAttachedCallback(
-    JNIEnv* env, jclass, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_registerDsAttachedCallback
+  (JNIEnv* env, jclass, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallbackNoIndex(
       env, callback, initialNotify,
       &HALSIM_RegisterDriverStationDsAttachedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
+ * Method:    cancelDsAttachedCallback
+ * Signature: (I)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_cancelDsAttachedCallback(
-    JNIEnv* env, jclass, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_cancelDsAttachedCallback
+  (JNIEnv* env, jclass, jint handle)
+{
   return sim::FreeCallbackNoIndex(
       env, handle, &HALSIM_CancelDriverStationDsAttachedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
+ * Method:    getDsAttached
+ * Signature: ()Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_getDsAttached(JNIEnv*,
-                                                                       jclass) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_getDsAttached
+  (JNIEnv*, jclass)
+{
   return HALSIM_GetDriverStationDsAttached();
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
+ * Method:    setDsAttached
+ * Signature: (Z)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setDsAttached(
-    JNIEnv*, jclass, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setDsAttached
+  (JNIEnv*, jclass, jboolean value)
+{
   HALSIM_SetDriverStationDsAttached(value);
 }
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationSim
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
  * Method:    setJoystickAxes
  * Signature: (B[F)V
  */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setJoystickAxes(
-    JNIEnv* env, jclass, jbyte joystickNum, jfloatArray axesArray) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setJoystickAxes
+  (JNIEnv* env, jclass, jbyte joystickNum, jfloatArray axesArray)
+{
   HAL_JoystickAxes axes;
   {
     wpi::java::JFloatArrayRef jArrayRef(env, axesArray);
@@ -198,13 +343,14 @@ Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setJoystickAxes(
 }
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationSim
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
  * Method:    setJoystickPOVs
  * Signature: (B[S)V
  */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setJoystickPOVs(
-    JNIEnv* env, jclass, jbyte joystickNum, jshortArray povsArray) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setJoystickPOVs
+  (JNIEnv* env, jclass, jbyte joystickNum, jshortArray povsArray)
+{
   HAL_JoystickPOVs povs;
   {
     wpi::java::JShortArrayRef jArrayRef(env, povsArray);
@@ -222,13 +368,14 @@ Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setJoystickPOVs(
 }
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationSim
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
  * Method:    setJoystickButtons
  * Signature: (BII)V
  */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setJoystickButtons(
-    JNIEnv* env, jclass, jbyte joystickNum, jint buttons, jint count) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setJoystickButtons
+  (JNIEnv* env, jclass, jbyte joystickNum, jint buttons, jint count)
+{
   if (count > 32) {
     count = 32;
   }
@@ -239,22 +386,24 @@ Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setJoystickButtons(
 }
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationSim
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
  * Method:    setMatchInfo
- * Signature: (Ledu/wpi/first/wpilibj/hal/MatchInfoData;)V
+ * Signature: (Ljava/lang/Object;)V
  */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setMatchInfo(
-    JNIEnv* env, jclass, jobject info) {}
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_setMatchInfo
+  (JNIEnv* env, jclass, jobject info)
+{}
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationSim
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
  * Method:    registerAllCallbacks
- * Signature: (Ledu/wpi/first/hal/sim/NotifyCallback;Z)V
+ * Signature: (Ljava/lang/Object;Z)V
  */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_registerAllCallbacks(
-    JNIEnv* env, jclass, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_registerAllCallbacks
+  (JNIEnv* env, jclass, jobject callback, jboolean initialNotify)
+{
   sim::AllocateCallbackNoIndex(
       env, callback, initialNotify,
       [](HAL_NotifyCallback cb, void* param, HAL_Bool in) {
@@ -264,19 +413,26 @@ Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_registerAllCallbacks(
 }
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationSim
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
  * Method:    notifyNewData
  * Signature: ()V
  */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_notifyNewData(JNIEnv*,
-                                                                       jclass) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_notifyNewData
+  (JNIEnv*, jclass)
+{
   HALSIM_NotifyDriverStationNewData();
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI
+ * Method:    resetData
+ * Signature: ()V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_resetData(JNIEnv*,
-                                                                   jclass) {
+Java_edu_wpi_first_hal_sim_mockdata_DriverStationDataJNI_resetData
+  (JNIEnv*, jclass)
+{
   HALSIM_ResetDriverStationData();
 }
 

hal/src/main/native/sim/jni/EncoderDataJNI.cpp

@@ -13,222 +13,415 @@
 
 extern "C" {
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    registerInitializedCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_registerInitializedCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_registerInitializedCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterEncoderInitializedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    cancelInitializedCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_cancelInitializedCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_cancelInitializedCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelEncoderInitializedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    getInitialized
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_getInitialized(JNIEnv*,
-                                                                  jclass,
-                                                                  jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_getInitialized
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetEncoderInitialized(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    setInitialized
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_setInitialized(
-    JNIEnv*, jclass, jint index, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_setInitialized
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetEncoderInitialized(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    registerCountCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_registerCountCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_registerCountCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterEncoderCountCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    cancelCountCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_cancelCountCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_cancelCountCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelEncoderCountCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    getCount
+ * Signature: (I)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_getCount(JNIEnv*, jclass,
-                                                            jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_getCount
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetEncoderCount(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    setCount
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_setCount(JNIEnv*, jclass,
-                                                            jint index,
-                                                            jint value) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_setCount
+  (JNIEnv*, jclass, jint index, jint value)
+{
   HALSIM_SetEncoderCount(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    registerPeriodCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_registerPeriodCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_registerPeriodCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterEncoderPeriodCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    cancelPeriodCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_cancelPeriodCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_cancelPeriodCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelEncoderPeriodCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    getPeriod
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_getPeriod(JNIEnv*, jclass,
-                                                             jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_getPeriod
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetEncoderPeriod(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    setPeriod
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_setPeriod(JNIEnv*, jclass,
-                                                             jint index,
-                                                             jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_setPeriod
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetEncoderPeriod(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    registerResetCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_registerResetCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_registerResetCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterEncoderResetCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    cancelResetCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_cancelResetCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_cancelResetCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelEncoderResetCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    getReset
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_getReset(JNIEnv*, jclass,
-                                                            jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_getReset
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetEncoderReset(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    setReset
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_setReset(JNIEnv*, jclass,
-                                                            jint index,
-                                                            jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_setReset
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetEncoderReset(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    registerMaxPeriodCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_registerMaxPeriodCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_registerMaxPeriodCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterEncoderMaxPeriodCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    cancelMaxPeriodCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_cancelMaxPeriodCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_cancelMaxPeriodCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelEncoderMaxPeriodCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    getMaxPeriod
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_getMaxPeriod(JNIEnv*, jclass,
-                                                                jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_getMaxPeriod
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetEncoderMaxPeriod(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    setMaxPeriod
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_setMaxPeriod(JNIEnv*, jclass,
-                                                                jint index,
-                                                                jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_setMaxPeriod
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetEncoderMaxPeriod(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    registerDirectionCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_registerDirectionCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_registerDirectionCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterEncoderDirectionCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    cancelDirectionCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_cancelDirectionCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_cancelDirectionCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelEncoderDirectionCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    getDirection
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_getDirection(JNIEnv*, jclass,
-                                                                jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_getDirection
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetEncoderDirection(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    setDirection
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_setDirection(
-    JNIEnv*, jclass, jint index, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_setDirection
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetEncoderDirection(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    registerReverseDirectionCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_registerReverseDirectionCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_registerReverseDirectionCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterEncoderReverseDirectionCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    cancelReverseDirectionCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_cancelReverseDirectionCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_cancelReverseDirectionCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelEncoderReverseDirectionCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    getReverseDirection
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_getReverseDirection(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_getReverseDirection
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetEncoderReverseDirection(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    setReverseDirection
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_setReverseDirection(
-    JNIEnv*, jclass, jint index, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_setReverseDirection
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetEncoderReverseDirection(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    registerSamplesToAverageCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_registerSamplesToAverageCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_registerSamplesToAverageCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterEncoderSamplesToAverageCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    cancelSamplesToAverageCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_cancelSamplesToAverageCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_cancelSamplesToAverageCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelEncoderSamplesToAverageCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    getSamplesToAverage
+ * Signature: (I)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_getSamplesToAverage(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_getSamplesToAverage
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetEncoderSamplesToAverage(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    setSamplesToAverage
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_setSamplesToAverage(
-    JNIEnv*, jclass, jint index, jint value) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_setSamplesToAverage
+  (JNIEnv*, jclass, jint index, jint value)
+{
   HALSIM_SetEncoderSamplesToAverage(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_EncoderDataJNI
+ * Method:    resetData
+ * Signature: (I)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_resetData(JNIEnv*, jclass,
-                                                             jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_EncoderDataJNI_resetData
+  (JNIEnv*, jclass, jint index)
+{
   HALSIM_ResetEncoderData(index);
 }
 

hal/src/main/native/sim/jni/I2CDataJNI.cpp

@@ -16,108 +16,115 @@
 extern "C" {
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_I2CSim
+ * Class:     edu_wpi_first_hal_sim_mockdata_I2CDataJNI
  * Method:    registerInitializedCallback
- * Signature: (ILedu/wpi/first/hal/sim/NotifyCallback;Z)I
+ * Signature: (ILjava/lang/Object;Z)I
  */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_I2CDataJNI_registerInitializedCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_I2CDataJNI_registerInitializedCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterI2CInitializedCallback);
 }
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_I2CSim
+ * Class:     edu_wpi_first_hal_sim_mockdata_I2CDataJNI
  * Method:    cancelInitializedCallback
  * Signature: (II)V
  */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_I2CDataJNI_cancelInitializedCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_I2CDataJNI_cancelInitializedCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelI2CInitializedCallback);
 }
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_I2CSim
+ * Class:     edu_wpi_first_hal_sim_mockdata_I2CDataJNI
  * Method:    getInitialized
  * Signature: (I)Z
  */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_I2CDataJNI_getInitialized(JNIEnv*, jclass,
-                                                              jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_I2CDataJNI_getInitialized
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetI2CInitialized(index);
 }
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_I2CSim
+ * Class:     edu_wpi_first_hal_sim_mockdata_I2CDataJNI
  * Method:    setInitialized
  * Signature: (IZ)V
  */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_I2CDataJNI_setInitialized(JNIEnv*, jclass,
-                                                              jint index,
-                                                              jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_I2CDataJNI_setInitialized
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetI2CInitialized(index, value);
 }
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_I2CSim
+ * Class:     edu_wpi_first_hal_sim_mockdata_I2CDataJNI
  * Method:    registerReadCallback
- * Signature: (ILedu/wpi/first/hal/sim/BufferCallback;)I
+ * Signature: (ILjava/lang/Object;)I
  */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_I2CDataJNI_registerReadCallback(
-    JNIEnv* env, jclass, jint index, jobject callback) {
+Java_edu_wpi_first_hal_sim_mockdata_I2CDataJNI_registerReadCallback
+  (JNIEnv* env, jclass, jint index, jobject callback)
+{
   return sim::AllocateBufferCallback(env, index, callback,
                                      &HALSIM_RegisterI2CReadCallback);
 }
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_I2CSim
+ * Class:     edu_wpi_first_hal_sim_mockdata_I2CDataJNI
  * Method:    cancelReadCallback
  * Signature: (II)V
  */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_I2CDataJNI_cancelReadCallback(JNIEnv* env,
-                                                                  jclass,
-                                                                  jint index,
-                                                                  jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_I2CDataJNI_cancelReadCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   sim::FreeBufferCallback(env, handle, index, &HALSIM_CancelI2CReadCallback);
 }
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_I2CSim
+ * Class:     edu_wpi_first_hal_sim_mockdata_I2CDataJNI
  * Method:    registerWriteCallback
- * Signature: (ILedu/wpi/first/hal/sim/ConstBufferCallback;)I
+ * Signature: (ILjava/lang/Object;)I
  */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_I2CDataJNI_registerWriteCallback(
-    JNIEnv* env, jclass, jint index, jobject callback) {
+Java_edu_wpi_first_hal_sim_mockdata_I2CDataJNI_registerWriteCallback
+  (JNIEnv* env, jclass, jint index, jobject callback)
+{
   return sim::AllocateConstBufferCallback(env, index, callback,
                                           &HALSIM_RegisterI2CWriteCallback);
 }
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_I2CSim
+ * Class:     edu_wpi_first_hal_sim_mockdata_I2CDataJNI
  * Method:    cancelWriteCallback
  * Signature: (II)V
  */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_I2CDataJNI_cancelWriteCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_I2CDataJNI_cancelWriteCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   sim::FreeConstBufferCallback(env, handle, index,
                                &HALSIM_CancelI2CWriteCallback);
 }
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_I2CSim
+ * Class:     edu_wpi_first_hal_sim_mockdata_I2CDataJNI
  * Method:    resetData
  * Signature: (I)V
  */
-JNIEXPORT void JNICALL Java_edu_wpi_first_hal_sim_mockdata_I2CDataJNI_resetData(
-    JNIEnv*, jclass, jint index) {
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_hal_sim_mockdata_I2CDataJNI_resetData
+  (JNIEnv*, jclass, jint index)
+{
   HALSIM_ResetI2CData(index);
 }
 

hal/src/main/native/sim/jni/PCMDataJNI.cpp

@@ -13,205 +13,370 @@
 
 extern "C" {
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    registerSolenoidInitializedCallback
+ * Signature: (IILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerSolenoidInitializedCallback(
-    JNIEnv* env, jclass, jint index, jint channel, jobject callback,
-    jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerSolenoidInitializedCallback
+  (JNIEnv* env, jclass, jint index, jint channel, jobject callback,
+   jboolean initialNotify)
+{
   return sim::AllocateChannelCallback(
       env, index, channel, callback, initialNotify,
       &HALSIM_RegisterPCMSolenoidInitializedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    cancelSolenoidInitializedCallback
+ * Signature: (III)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_cancelSolenoidInitializedCallback(
-    JNIEnv* env, jclass, jint index, jint channel, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_cancelSolenoidInitializedCallback
+  (JNIEnv* env, jclass, jint index, jint channel, jint handle)
+{
   return sim::FreeChannelCallback(env, handle, index, channel,
                                   &HALSIM_CancelPCMSolenoidInitializedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    getSolenoidInitialized
+ * Signature: (II)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_getSolenoidInitialized(
-    JNIEnv*, jclass, jint index, jint channel) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_getSolenoidInitialized
+  (JNIEnv*, jclass, jint index, jint channel)
+{
   return HALSIM_GetPCMSolenoidInitialized(index, channel);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    setSolenoidInitialized
+ * Signature: (IIZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_setSolenoidInitialized(
-    JNIEnv*, jclass, jint index, jint channel, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_setSolenoidInitialized
+  (JNIEnv*, jclass, jint index, jint channel, jboolean value)
+{
   HALSIM_SetPCMSolenoidInitialized(index, channel, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    registerSolenoidOutputCallback
+ * Signature: (IILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerSolenoidOutputCallback(
-    JNIEnv* env, jclass, jint index, jint channel, jobject callback,
-    jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerSolenoidOutputCallback
+  (JNIEnv* env, jclass, jint index, jint channel, jobject callback,
+   jboolean initialNotify)
+{
   return sim::AllocateChannelCallback(
       env, index, channel, callback, initialNotify,
       &HALSIM_RegisterPCMSolenoidOutputCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    cancelSolenoidOutputCallback
+ * Signature: (III)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_cancelSolenoidOutputCallback(
-    JNIEnv* env, jclass, jint index, jint channel, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_cancelSolenoidOutputCallback
+  (JNIEnv* env, jclass, jint index, jint channel, jint handle)
+{
   return sim::FreeChannelCallback(env, handle, index, channel,
                                   &HALSIM_CancelPCMSolenoidOutputCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    getSolenoidOutput
+ * Signature: (II)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_getSolenoidOutput(JNIEnv*,
-                                                                 jclass,
-                                                                 jint index,
-                                                                 jint channel) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_getSolenoidOutput
+  (JNIEnv*, jclass, jint index, jint channel)
+{
   return HALSIM_GetPCMSolenoidOutput(index, channel);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    setSolenoidOutput
+ * Signature: (IIZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_setSolenoidOutput(
-    JNIEnv*, jclass, jint index, jint channel, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_setSolenoidOutput
+  (JNIEnv*, jclass, jint index, jint channel, jboolean value)
+{
   HALSIM_SetPCMSolenoidOutput(index, channel, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    registerCompressorInitializedCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerCompressorInitializedCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerCompressorInitializedCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(
       env, index, callback, initialNotify,
       &HALSIM_RegisterPCMCompressorInitializedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    cancelCompressorInitializedCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_cancelCompressorInitializedCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_cancelCompressorInitializedCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelPCMCompressorInitializedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    getCompressorInitialized
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_getCompressorInitialized(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_getCompressorInitialized
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetPCMCompressorInitialized(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    setCompressorInitialized
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_setCompressorInitialized(
-    JNIEnv*, jclass, jint index, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_setCompressorInitialized
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetPCMCompressorInitialized(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    registerCompressorOnCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerCompressorOnCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerCompressorOnCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterPCMCompressorOnCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    cancelCompressorOnCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_cancelCompressorOnCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_cancelCompressorOnCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelPCMCompressorOnCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    getCompressorOn
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_getCompressorOn(JNIEnv*, jclass,
-                                                               jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_getCompressorOn
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetPCMCompressorOn(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    setCompressorOn
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_setCompressorOn(JNIEnv*, jclass,
-                                                               jint index,
-                                                               jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_setCompressorOn
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetPCMCompressorOn(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    registerClosedLoopEnabledCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerClosedLoopEnabledCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerClosedLoopEnabledCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterPCMClosedLoopEnabledCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    cancelClosedLoopEnabledCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_cancelClosedLoopEnabledCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_cancelClosedLoopEnabledCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelPCMClosedLoopEnabledCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    getClosedLoopEnabled
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_getClosedLoopEnabled(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_getClosedLoopEnabled
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetPCMClosedLoopEnabled(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    setClosedLoopEnabled
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_setClosedLoopEnabled(
-    JNIEnv*, jclass, jint index, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_setClosedLoopEnabled
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetPCMClosedLoopEnabled(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    registerPressureSwitchCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerPressureSwitchCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerPressureSwitchCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterPCMPressureSwitchCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    cancelPressureSwitchCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_cancelPressureSwitchCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_cancelPressureSwitchCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelPCMPressureSwitchCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    getPressureSwitch
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_getPressureSwitch(JNIEnv*,
-                                                                 jclass,
-                                                                 jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_getPressureSwitch
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetPCMPressureSwitch(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    setPressureSwitch
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_setPressureSwitch(
-    JNIEnv*, jclass, jint index, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_setPressureSwitch
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetPCMPressureSwitch(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    registerCompressorCurrentCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerCompressorCurrentCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerCompressorCurrentCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterPCMCompressorCurrentCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    cancelCompressorCurrentCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_cancelCompressorCurrentCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_cancelCompressorCurrentCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelPCMCompressorCurrentCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    getCompressorCurrent
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_getCompressorCurrent(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_getCompressorCurrent
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetPCMCompressorCurrent(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    setCompressorCurrent
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_setCompressorCurrent(
-    JNIEnv*, jclass, jint index, jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_setCompressorCurrent
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetPCMCompressorCurrent(index, value);
 }
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_PCMSim
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
  * Method:    registerAllNonSolenoidCallbacks
- * Signature: (ILedu/wpi/first/hal/sim/NotifyCallback;Z)V
+ * Signature: (ILjava/lang/Object;Z)V
  */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerAllNonSolenoidCallbacks(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerAllNonSolenoidCallbacks
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   sim::AllocateCallback(
       env, index, callback, initialNotify,
       [](int32_t index, HAL_NotifyCallback cb, void* param, HAL_Bool in) {
@@ -221,14 +386,15 @@ Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerAllNonSolenoidCallbacks(
 }
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_PCMSim
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
  * Method:    registerAllSolenoidCallbacks
- * Signature: (IILedu/wpi/first/hal/sim/NotifyCallback;Z)V
+ * Signature: (IILjava/lang/Object;Z)V
  */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerAllSolenoidCallbacks(
-    JNIEnv* env, jclass, jint index, jint channel, jobject callback,
-    jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerAllSolenoidCallbacks
+  (JNIEnv* env, jclass, jint index, jint channel, jobject callback,
+   jboolean initialNotify)
+{
   sim::AllocateChannelCallback(
       env, index, channel, callback, initialNotify,
       [](int32_t index, int32_t channel, HAL_NotifyCallback cb, void* param,
@@ -238,8 +404,15 @@ Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_registerAllSolenoidCallbacks(
       });
 }
 
-JNIEXPORT void JNICALL Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_resetData(
-    JNIEnv*, jclass, jint index) {
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PCMDataJNI
+ * Method:    resetData
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_hal_sim_mockdata_PCMDataJNI_resetData
+  (JNIEnv*, jclass, jint index)
+{
   HALSIM_ResetPCMData(index);
 }
 

hal/src/main/native/sim/jni/PDPDataJNI.cpp

@@ -13,120 +13,217 @@
 
 extern "C" {
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PDPDataJNI
+ * Method:    registerInitializedCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_registerInitializedCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_registerInitializedCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterPDPInitializedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PDPDataJNI
+ * Method:    cancelInitializedCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_cancelInitializedCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_cancelInitializedCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelPDPInitializedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PDPDataJNI
+ * Method:    getInitialized
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_getInitialized(JNIEnv*, jclass,
-                                                              jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_getInitialized
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetPDPInitialized(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PDPDataJNI
+ * Method:    setInitialized
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_setInitialized(JNIEnv*, jclass,
-                                                              jint index,
-                                                              jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_setInitialized
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetPDPInitialized(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PDPDataJNI
+ * Method:    registerTemperatureCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_registerTemperatureCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_registerTemperatureCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterPDPTemperatureCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PDPDataJNI
+ * Method:    cancelTemperatureCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_cancelTemperatureCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_cancelTemperatureCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelPDPTemperatureCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PDPDataJNI
+ * Method:    getTemperature
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_getTemperature(JNIEnv*, jclass,
-                                                              jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_getTemperature
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetPDPTemperature(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PDPDataJNI
+ * Method:    setTemperature
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_setTemperature(JNIEnv*, jclass,
-                                                              jint index,
-                                                              jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_setTemperature
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetPDPTemperature(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PDPDataJNI
+ * Method:    registerVoltageCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_registerVoltageCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_registerVoltageCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterPDPVoltageCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PDPDataJNI
+ * Method:    cancelVoltageCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_cancelVoltageCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_cancelVoltageCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelPDPVoltageCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PDPDataJNI
+ * Method:    getVoltage
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_getVoltage(JNIEnv*, jclass,
-                                                          jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_getVoltage
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetPDPVoltage(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PDPDataJNI
+ * Method:    setVoltage
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_setVoltage(JNIEnv*, jclass,
-                                                          jint index,
-                                                          jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_setVoltage
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetPDPVoltage(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PDPDataJNI
+ * Method:    registerCurrentCallback
+ * Signature: (IILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_registerCurrentCallback(
-    JNIEnv* env, jclass, jint index, jint channel, jobject callback,
-    jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_registerCurrentCallback
+  (JNIEnv* env, jclass, jint index, jint channel, jobject callback,
+   jboolean initialNotify)
+{
   return sim::AllocateChannelCallback(env, index, channel, callback,
                                       initialNotify,
                                       &HALSIM_RegisterPDPCurrentCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PDPDataJNI
+ * Method:    cancelCurrentCallback
+ * Signature: (III)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_cancelCurrentCallback(
-    JNIEnv* env, jclass, jint index, jint channel, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_cancelCurrentCallback
+  (JNIEnv* env, jclass, jint index, jint channel, jint handle)
+{
   return sim::FreeChannelCallback(env, handle, index, channel,
                                   &HALSIM_CancelPDPCurrentCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PDPDataJNI
+ * Method:    getCurrent
+ * Signature: (II)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_getCurrent(JNIEnv*, jclass,
-                                                          jint index,
-                                                          jint channel) {
+Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_getCurrent
+  (JNIEnv*, jclass, jint index, jint channel)
+{
   return HALSIM_GetPDPCurrent(index, channel);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PDPDataJNI
+ * Method:    setCurrent
+ * Signature: (IID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_setCurrent(JNIEnv*, jclass,
-                                                          jint index,
-                                                          jint channel,
-                                                          jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_setCurrent
+  (JNIEnv*, jclass, jint index, jint channel, jdouble value)
+{
   HALSIM_SetPDPCurrent(index, channel, value);
 }
 
-JNIEXPORT void JNICALL Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_resetData(
-    JNIEnv*, jclass, jint index) {
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PDPDataJNI
+ * Method:    resetData
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_hal_sim_mockdata_PDPDataJNI_resetData
+  (JNIEnv*, jclass, jint index)
+{
   HALSIM_ResetPDPData(index);
 }
 

hal/src/main/native/sim/jni/PWMDataJNI.cpp

@@ -13,167 +13,314 @@
 
 extern "C" {
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PWMDataJNI
+ * Method:    registerInitializedCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_registerInitializedCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_registerInitializedCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterPWMInitializedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PWMDataJNI
+ * Method:    cancelInitializedCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_cancelInitializedCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_cancelInitializedCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelPWMInitializedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PWMDataJNI
+ * Method:    getInitialized
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_getInitialized(JNIEnv*, jclass,
-                                                              jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_getInitialized
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetPWMInitialized(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PWMDataJNI
+ * Method:    setInitialized
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_setInitialized(JNIEnv*, jclass,
-                                                              jint index,
-                                                              jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_setInitialized
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetPWMInitialized(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PWMDataJNI
+ * Method:    registerRawValueCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_registerRawValueCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_registerRawValueCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterPWMRawValueCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PWMDataJNI
+ * Method:    cancelRawValueCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_cancelRawValueCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_cancelRawValueCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelPWMRawValueCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PWMDataJNI
+ * Method:    getRawValue
+ * Signature: (I)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_getRawValue(JNIEnv*, jclass,
-                                                           jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_getRawValue
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetPWMRawValue(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PWMDataJNI
+ * Method:    setRawValue
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_setRawValue(JNIEnv*, jclass,
-                                                           jint index,
-                                                           jint value) {
+Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_setRawValue
+  (JNIEnv*, jclass, jint index, jint value)
+{
   HALSIM_SetPWMRawValue(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PWMDataJNI
+ * Method:    registerSpeedCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_registerSpeedCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_registerSpeedCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterPWMSpeedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PWMDataJNI
+ * Method:    cancelSpeedCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_cancelSpeedCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_cancelSpeedCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index, &HALSIM_CancelPWMSpeedCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PWMDataJNI
+ * Method:    getSpeed
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_getSpeed(JNIEnv*, jclass,
-                                                        jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_getSpeed
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetPWMSpeed(index);
 }
 
-JNIEXPORT void JNICALL Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_setSpeed(
-    JNIEnv*, jclass, jint index, jdouble value) {
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PWMDataJNI
+ * Method:    setSpeed
+ * Signature: (ID)V
+ */
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_setSpeed
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetPWMSpeed(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PWMDataJNI
+ * Method:    registerPositionCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_registerPositionCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_registerPositionCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterPWMPositionCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PWMDataJNI
+ * Method:    cancelPositionCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_cancelPositionCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_cancelPositionCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelPWMPositionCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PWMDataJNI
+ * Method:    getPosition
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_getPosition(JNIEnv*, jclass,
-                                                           jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_getPosition
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetPWMPosition(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PWMDataJNI
+ * Method:    setPosition
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_setPosition(JNIEnv*, jclass,
-                                                           jint index,
-                                                           jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_setPosition
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetPWMPosition(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PWMDataJNI
+ * Method:    registerPeriodScaleCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_registerPeriodScaleCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_registerPeriodScaleCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterPWMPeriodScaleCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PWMDataJNI
+ * Method:    cancelPeriodScaleCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_cancelPeriodScaleCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_cancelPeriodScaleCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelPWMPeriodScaleCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PWMDataJNI
+ * Method:    getPeriodScale
+ * Signature: (I)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_getPeriodScale(JNIEnv*, jclass,
-                                                              jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_getPeriodScale
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetPWMPeriodScale(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PWMDataJNI
+ * Method:    setPeriodScale
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_setPeriodScale(JNIEnv*, jclass,
-                                                              jint index,
-                                                              jint value) {
+Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_setPeriodScale
+  (JNIEnv*, jclass, jint index, jint value)
+{
   HALSIM_SetPWMPeriodScale(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PWMDataJNI
+ * Method:    registerZeroLatchCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_registerZeroLatchCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_registerZeroLatchCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterPWMZeroLatchCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PWMDataJNI
+ * Method:    cancelZeroLatchCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_cancelZeroLatchCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_cancelZeroLatchCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelPWMZeroLatchCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PWMDataJNI
+ * Method:    getZeroLatch
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_getZeroLatch(JNIEnv*, jclass,
-                                                            jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_getZeroLatch
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetPWMZeroLatch(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PWMDataJNI
+ * Method:    setZeroLatch
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_setZeroLatch(JNIEnv*, jclass,
-                                                            jint index,
-                                                            jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_setZeroLatch
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetPWMZeroLatch(index, value);
 }
 
-JNIEXPORT void JNICALL Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_resetData(
-    JNIEnv*, jclass, jint index) {
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_PWMDataJNI
+ * Method:    resetData
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_hal_sim_mockdata_PWMDataJNI_resetData
+  (JNIEnv*, jclass, jint index)
+{
   HALSIM_ResetPWMData(index);
 }
 

hal/src/main/native/sim/jni/RelayDataJNI.cpp

@@ -13,115 +13,215 @@
 
 extern "C" {
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RelayDataJNI
+ * Method:    registerInitializedForwardCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_registerInitializedForwardCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_registerInitializedForwardCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterRelayInitializedForwardCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RelayDataJNI
+ * Method:    cancelInitializedForwardCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_cancelInitializedForwardCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_cancelInitializedForwardCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelRelayInitializedForwardCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RelayDataJNI
+ * Method:    getInitializedForward
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_getInitializedForward(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_getInitializedForward
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetRelayInitializedForward(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RelayDataJNI
+ * Method:    setInitializedForward
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_setInitializedForward(
-    JNIEnv*, jclass, jint index, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_setInitializedForward
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetRelayInitializedForward(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RelayDataJNI
+ * Method:    registerInitializedReverseCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_registerInitializedReverseCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_registerInitializedReverseCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterRelayInitializedReverseCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RelayDataJNI
+ * Method:    cancelInitializedReverseCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_cancelInitializedReverseCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_cancelInitializedReverseCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelRelayInitializedReverseCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RelayDataJNI
+ * Method:    getInitializedReverse
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_getInitializedReverse(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_getInitializedReverse
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetRelayInitializedReverse(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RelayDataJNI
+ * Method:    setInitializedReverse
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_setInitializedReverse(
-    JNIEnv*, jclass, jint index, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_setInitializedReverse
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetRelayInitializedReverse(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RelayDataJNI
+ * Method:    registerForwardCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_registerForwardCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_registerForwardCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterRelayForwardCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RelayDataJNI
+ * Method:    cancelForwardCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_cancelForwardCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_cancelForwardCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelRelayForwardCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RelayDataJNI
+ * Method:    getForward
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_getForward(JNIEnv*, jclass,
-                                                            jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_getForward
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetRelayForward(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RelayDataJNI
+ * Method:    setForward
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_setForward(JNIEnv*, jclass,
-                                                            jint index,
-                                                            jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_setForward
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetRelayForward(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RelayDataJNI
+ * Method:    registerReverseCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_registerReverseCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_registerReverseCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterRelayReverseCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RelayDataJNI
+ * Method:    cancelReverseCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_cancelReverseCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_cancelReverseCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelRelayReverseCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RelayDataJNI
+ * Method:    getReverse
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_getReverse(JNIEnv*, jclass,
-                                                            jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_getReverse
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetRelayReverse(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RelayDataJNI
+ * Method:    setReverse
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_setReverse(JNIEnv*, jclass,
-                                                            jint index,
-                                                            jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_setReverse
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetRelayReverse(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RelayDataJNI
+ * Method:    resetData
+ * Signature: (I)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_resetData(JNIEnv*, jclass,
-                                                           jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_RelayDataJNI_resetData
+  (JNIEnv*, jclass, jint index)
+{
   HALSIM_ResetRelayData(index);
 }
 

hal/src/main/native/sim/jni/RoboRioDataJNI.cpp

@@ -13,410 +13,765 @@
 
 extern "C" {
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    registerFPGAButtonCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerFPGAButtonCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerFPGAButtonCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterRoboRioFPGAButtonCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    cancelFPGAButtonCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelFPGAButtonCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelFPGAButtonCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelRoboRioFPGAButtonCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    getFPGAButton
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getFPGAButton(JNIEnv*,
-                                                                 jclass,
-                                                                 jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getFPGAButton
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetRoboRioFPGAButton(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    setFPGAButton
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setFPGAButton(
-    JNIEnv*, jclass, jint index, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setFPGAButton
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetRoboRioFPGAButton(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    registerVInVoltageCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerVInVoltageCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerVInVoltageCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterRoboRioVInVoltageCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    cancelVInVoltageCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelVInVoltageCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelVInVoltageCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelRoboRioVInVoltageCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    getVInVoltage
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getVInVoltage(JNIEnv*,
-                                                                 jclass,
-                                                                 jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getVInVoltage
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetRoboRioVInVoltage(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    setVInVoltage
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setVInVoltage(
-    JNIEnv*, jclass, jint index, jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setVInVoltage
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetRoboRioVInVoltage(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    registerVInCurrentCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerVInCurrentCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerVInCurrentCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterRoboRioVInCurrentCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    cancelVInCurrentCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelVInCurrentCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelVInCurrentCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelRoboRioVInCurrentCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    getVInCurrent
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getVInCurrent(JNIEnv*,
-                                                                 jclass,
-                                                                 jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getVInCurrent
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetRoboRioVInCurrent(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    setVInCurrent
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setVInCurrent(
-    JNIEnv*, jclass, jint index, jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setVInCurrent
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetRoboRioVInCurrent(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    registerUserVoltage6VCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserVoltage6VCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserVoltage6VCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterRoboRioUserVoltage6VCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    cancelUserVoltage6VCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserVoltage6VCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserVoltage6VCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelRoboRioUserVoltage6VCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    getUserVoltage6V
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserVoltage6V(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserVoltage6V
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetRoboRioUserVoltage6V(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    setUserVoltage6V
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserVoltage6V(
-    JNIEnv*, jclass, jint index, jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserVoltage6V
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetRoboRioUserVoltage6V(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    registerUserCurrent6VCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserCurrent6VCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserCurrent6VCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterRoboRioUserCurrent6VCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    cancelUserCurrent6VCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserCurrent6VCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserCurrent6VCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelRoboRioUserCurrent6VCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    getUserCurrent6V
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserCurrent6V(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserCurrent6V
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetRoboRioUserCurrent6V(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    setUserCurrent6V
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserCurrent6V(
-    JNIEnv*, jclass, jint index, jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserCurrent6V
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetRoboRioUserCurrent6V(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    registerUserActive6VCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserActive6VCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserActive6VCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterRoboRioUserActive6VCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    cancelUserActive6VCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserActive6VCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserActive6VCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelRoboRioUserActive6VCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    getUserActive6V
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserActive6V(JNIEnv*,
-                                                                   jclass,
-                                                                   jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserActive6V
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetRoboRioUserActive6V(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    setUserActive6V
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserActive6V(
-    JNIEnv*, jclass, jint index, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserActive6V
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetRoboRioUserActive6V(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    registerUserVoltage5VCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserVoltage5VCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserVoltage5VCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterRoboRioUserVoltage5VCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    cancelUserVoltage5VCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserVoltage5VCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserVoltage5VCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelRoboRioUserVoltage5VCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    getUserVoltage5V
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserVoltage5V(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserVoltage5V
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetRoboRioUserVoltage5V(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    setUserVoltage5V
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserVoltage5V(
-    JNIEnv*, jclass, jint index, jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserVoltage5V
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetRoboRioUserVoltage5V(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    registerUserCurrent5VCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserCurrent5VCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserCurrent5VCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterRoboRioUserCurrent5VCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    cancelUserCurrent5VCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserCurrent5VCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserCurrent5VCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelRoboRioUserCurrent5VCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    getUserCurrent5V
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserCurrent5V(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserCurrent5V
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetRoboRioUserCurrent5V(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    setUserCurrent5V
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserCurrent5V(
-    JNIEnv*, jclass, jint index, jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserCurrent5V
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetRoboRioUserCurrent5V(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    registerUserActive5VCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserActive5VCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserActive5VCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterRoboRioUserActive5VCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    cancelUserActive5VCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserActive5VCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserActive5VCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelRoboRioUserActive5VCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    getUserActive5V
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserActive5V(JNIEnv*,
-                                                                   jclass,
-                                                                   jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserActive5V
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetRoboRioUserActive5V(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    setUserActive5V
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserActive5V(
-    JNIEnv*, jclass, jint index, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserActive5V
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetRoboRioUserActive5V(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    registerUserVoltage3V3Callback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserVoltage3V3Callback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserVoltage3V3Callback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterRoboRioUserVoltage3V3Callback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    cancelUserVoltage3V3Callback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserVoltage3V3Callback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserVoltage3V3Callback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelRoboRioUserVoltage3V3Callback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    getUserVoltage3V3
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserVoltage3V3(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserVoltage3V3
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetRoboRioUserVoltage3V3(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    setUserVoltage3V3
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserVoltage3V3(
-    JNIEnv*, jclass, jint index, jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserVoltage3V3
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetRoboRioUserVoltage3V3(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    registerUserCurrent3V3Callback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserCurrent3V3Callback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserCurrent3V3Callback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterRoboRioUserCurrent3V3Callback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    cancelUserCurrent3V3Callback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserCurrent3V3Callback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserCurrent3V3Callback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelRoboRioUserCurrent3V3Callback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    getUserCurrent3V3
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserCurrent3V3(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserCurrent3V3
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetRoboRioUserCurrent3V3(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    setUserCurrent3V3
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserCurrent3V3(
-    JNIEnv*, jclass, jint index, jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserCurrent3V3
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetRoboRioUserCurrent3V3(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    registerUserActive3V3Callback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserActive3V3Callback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserActive3V3Callback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterRoboRioUserActive3V3Callback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    cancelUserActive3V3Callback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserActive3V3Callback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserActive3V3Callback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelRoboRioUserActive3V3Callback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    getUserActive3V3
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserActive3V3(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserActive3V3
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetRoboRioUserActive3V3(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    setUserActive3V3
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserActive3V3(
-    JNIEnv*, jclass, jint index, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserActive3V3
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetRoboRioUserActive3V3(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    registerUserFaults6VCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserFaults6VCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserFaults6VCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterRoboRioUserFaults6VCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    cancelUserFaults6VCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserFaults6VCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserFaults6VCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelRoboRioUserFaults6VCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    getUserFaults6V
+ * Signature: (I)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserFaults6V(JNIEnv*,
-                                                                   jclass,
-                                                                   jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserFaults6V
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetRoboRioUserFaults6V(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    setUserFaults6V
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserFaults6V(JNIEnv*,
-                                                                   jclass,
-                                                                   jint index,
-                                                                   jint value) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserFaults6V
+  (JNIEnv*, jclass, jint index, jint value)
+{
   HALSIM_SetRoboRioUserFaults6V(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    registerUserFaults5VCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserFaults5VCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserFaults5VCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterRoboRioUserFaults5VCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    cancelUserFaults5VCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserFaults5VCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserFaults5VCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelRoboRioUserFaults5VCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    getUserFaults5V
+ * Signature: (I)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserFaults5V(JNIEnv*,
-                                                                   jclass,
-                                                                   jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserFaults5V
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetRoboRioUserFaults5V(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    setUserFaults5V
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserFaults5V(JNIEnv*,
-                                                                   jclass,
-                                                                   jint index,
-                                                                   jint value) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserFaults5V
+  (JNIEnv*, jclass, jint index, jint value)
+{
   HALSIM_SetRoboRioUserFaults5V(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    registerUserFaults3V3Callback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserFaults3V3Callback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_registerUserFaults3V3Callback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterRoboRioUserFaults3V3Callback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    cancelUserFaults3V3Callback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserFaults3V3Callback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_cancelUserFaults3V3Callback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelRoboRioUserFaults3V3Callback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    getUserFaults3V3
+ * Signature: (I)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserFaults3V3(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_getUserFaults3V3
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetRoboRioUserFaults3V3(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    setUserFaults3V3
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserFaults3V3(
-    JNIEnv*, jclass, jint index, jint value) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_setUserFaults3V3
+  (JNIEnv*, jclass, jint index, jint value)
+{
   HALSIM_SetRoboRioUserFaults3V3(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI
+ * Method:    resetData
+ * Signature: (I)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_resetData(JNIEnv*, jclass,
-                                                             jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_RoboRioDataJNI_resetData
+  (JNIEnv*, jclass, jint index)
+{
   HALSIM_ResetRoboRioData(index);
 }
 

hal/src/main/native/sim/jni/SPIAccelerometerDataJNI.cpp

@@ -13,142 +13,265 @@
 
 extern "C" {
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI
+ * Method:    registerActiveCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_registerActiveCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_registerActiveCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterSPIAccelerometerActiveCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI
+ * Method:    cancelActiveCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_cancelActiveCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_cancelActiveCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelSPIAccelerometerActiveCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI
+ * Method:    getActive
+ * Signature: (I)Z
+ */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_getActive(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_getActive
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetSPIAccelerometerActive(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI
+ * Method:    setActive
+ * Signature: (IZ)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_setActive(
-    JNIEnv*, jclass, jint index, jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_setActive
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetSPIAccelerometerActive(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI
+ * Method:    registerRangeCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_registerRangeCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_registerRangeCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterSPIAccelerometerRangeCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI
+ * Method:    cancelRangeCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_cancelRangeCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_cancelRangeCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelSPIAccelerometerRangeCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI
+ * Method:    getRange
+ * Signature: (I)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_getRange(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_getRange
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetSPIAccelerometerRange(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI
+ * Method:    setRange
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_setRange(
-    JNIEnv*, jclass, jint index, jint value) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_setRange
+  (JNIEnv*, jclass, jint index, jint value)
+{
   HALSIM_SetSPIAccelerometerRange(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI
+ * Method:    registerXCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_registerXCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_registerXCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterSPIAccelerometerXCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI
+ * Method:    cancelXCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_cancelXCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_cancelXCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelSPIAccelerometerXCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI
+ * Method:    getX
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_getX(JNIEnv*,
-                                                                 jclass,
-                                                                 jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_getX
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetSPIAccelerometerX(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI
+ * Method:    setX
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_setX(
-    JNIEnv*, jclass, jint index, jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_setX
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetSPIAccelerometerX(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI
+ * Method:    registerYCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_registerYCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_registerYCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterSPIAccelerometerYCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI
+ * Method:    cancelYCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_cancelYCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_cancelYCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelSPIAccelerometerYCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI
+ * Method:    getY
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_getY(JNIEnv*,
-                                                                 jclass,
-                                                                 jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_getY
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetSPIAccelerometerY(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI
+ * Method:    setY
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_setY(
-    JNIEnv*, jclass, jint index, jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_setY
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetSPIAccelerometerY(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI
+ * Method:    registerZCallback
+ * Signature: (ILjava/lang/Object;Z)I
+ */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_registerZCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_registerZCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterSPIAccelerometerZCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI
+ * Method:    cancelZCallback
+ * Signature: (II)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_cancelZCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_cancelZCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelSPIAccelerometerZCallback);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI
+ * Method:    getZ
+ * Signature: (I)D
+ */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_getZ(JNIEnv*,
-                                                                 jclass,
-                                                                 jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_getZ
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetSPIAccelerometerZ(index);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI
+ * Method:    setZ
+ * Signature: (ID)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_setZ(
-    JNIEnv*, jclass, jint index, jdouble value) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_setZ
+  (JNIEnv*, jclass, jint index, jdouble value)
+{
   HALSIM_SetSPIAccelerometerZ(index, value);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI
+ * Method:    resetData
+ * Signature: (I)V
+ */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_resetData(
-    JNIEnv*, jclass, jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIAccelerometerDataJNI_resetData
+  (JNIEnv*, jclass, jint index)
+{
   HALSIM_ResetSPIAccelerometerData(index);
 }
 

hal/src/main/native/sim/jni/SPIDataJNI.cpp

@@ -17,132 +17,141 @@
 extern "C" {
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_SPISim
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIDataJNI
  * Method:    registerInitializedCallback
- * Signature: (ILedu/wpi/first/hal/sim/NotifyCallback;Z)I
+ * Signature: (ILjava/lang/Object;Z)I
  */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_registerInitializedCallback(
-    JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_registerInitializedCallback
+  (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
+{
   return sim::AllocateCallback(env, index, callback, initialNotify,
                                &HALSIM_RegisterSPIInitializedCallback);
 }
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_SPISim
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIDataJNI
  * Method:    cancelInitializedCallback
  * Signature: (II)V
  */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_cancelInitializedCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_cancelInitializedCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   return sim::FreeCallback(env, handle, index,
                            &HALSIM_CancelSPIInitializedCallback);
 }
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_SPISim
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIDataJNI
  * Method:    getInitialized
  * Signature: (I)Z
  */
 JNIEXPORT jboolean JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_getInitialized(JNIEnv*, jclass,
-                                                              jint index) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_getInitialized
+  (JNIEnv*, jclass, jint index)
+{
   return HALSIM_GetSPIInitialized(index);
 }
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_SPISim
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIDataJNI
  * Method:    setInitialized
  * Signature: (IZ)V
  */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_setInitialized(JNIEnv*, jclass,
-                                                              jint index,
-                                                              jboolean value) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_setInitialized
+  (JNIEnv*, jclass, jint index, jboolean value)
+{
   HALSIM_SetSPIInitialized(index, value);
 }
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_SPISim
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIDataJNI
  * Method:    registerReadCallback
- * Signature: (ILedu/wpi/first/hal/sim/BufferCallback;)I
+ * Signature: (ILjava/lang/Object;)I
  */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_registerReadCallback(
-    JNIEnv* env, jclass, jint index, jobject callback) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_registerReadCallback
+  (JNIEnv* env, jclass, jint index, jobject callback)
+{
   return sim::AllocateBufferCallback(env, index, callback,
                                      &HALSIM_RegisterSPIReadCallback);
 }
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_SPISim
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIDataJNI
  * Method:    cancelReadCallback
  * Signature: (II)V
  */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_cancelReadCallback(JNIEnv* env,
-                                                                  jclass,
-                                                                  jint index,
-                                                                  jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_cancelReadCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   sim::FreeBufferCallback(env, handle, index, &HALSIM_CancelSPIReadCallback);
 }
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_SPISim
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIDataJNI
  * Method:    registerWriteCallback
- * Signature: (ILedu/wpi/first/hal/sim/ConstBufferCallback;)I
+ * Signature: (ILjava/lang/Object;)I
  */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_registerWriteCallback(
-    JNIEnv* env, jclass, jint index, jobject callback) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_registerWriteCallback
+  (JNIEnv* env, jclass, jint index, jobject callback)
+{
   return sim::AllocateConstBufferCallback(env, index, callback,
                                           &HALSIM_RegisterSPIWriteCallback);
 }
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_SPISim
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIDataJNI
  * Method:    cancelWriteCallback
  * Signature: (II)V
  */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_cancelWriteCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_cancelWriteCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   sim::FreeConstBufferCallback(env, handle, index,
                                &HALSIM_CancelSPIWriteCallback);
 }
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_SPISim
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIDataJNI
  * Method:    registerReadAutoReceiveBufferCallback
- * Signature: (ILedu/wpi/first/hal/sim/SpiReadAutoReceiveBufferCallback;)I
+ * Signature: (ILjava/lang/Object;)I
  */
 JNIEXPORT jint JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_registerReadAutoReceiveBufferCallback(
-    JNIEnv* env, jclass, jint index, jobject callback) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_registerReadAutoReceiveBufferCallback
+  (JNIEnv* env, jclass, jint index, jobject callback)
+{
   return sim::AllocateSpiBufferCallback(
       env, index, callback, &HALSIM_RegisterSPIReadAutoReceivedDataCallback);
 }
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_SPISim
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIDataJNI
  * Method:    cancelReadAutoReceiveBufferCallback
  * Signature: (II)V
  */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_cancelReadAutoReceiveBufferCallback(
-    JNIEnv* env, jclass, jint index, jint handle) {
+Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_cancelReadAutoReceiveBufferCallback
+  (JNIEnv* env, jclass, jint index, jint handle)
+{
   sim::FreeSpiBufferCallback(env, handle, index,
                              &HALSIM_CancelSPIReadAutoReceivedDataCallback);
 }
 
 /*
- * Class:     edu_wpi_first_hal_sim_mockdata_SPISim
+ * Class:     edu_wpi_first_hal_sim_mockdata_SPIDataJNI
  * Method:    resetData
  * Signature: (I)V
  */
-JNIEXPORT void JNICALL Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_resetData(
-    JNIEnv*, jclass, jint index) {
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_hal_sim_mockdata_SPIDataJNI_resetData
+  (JNIEnv*, jclass, jint index)
+{
   HALSIM_ResetSPIData(index);
 }
 

hal/src/main/native/sim/jni/SimulatorJNI.cpp

@@ -5,6 +5,8 @@
 /* the project.                                                               */
 /*----------------------------------------------------------------------------*/
 
+#include "SimulatorJNI.h"
+
 #include "BufferCallbackStore.h"
 #include "CallbackStore.h"
 #include "ConstBufferCallbackStore.h"
@@ -12,7 +14,6 @@
 #include "HAL/cpp/Log.h"
 #include "HAL/handles/HandlesInternal.h"
 #include "MockData/MockHooks.h"
-#include "SimulatorJNI.h"
 #include "SpiReadAutoReceiveBufferCallbackStore.h"
 #include "edu_wpi_first_hal_sim_mockdata_SimulatorJNI.h"
 
@@ -112,8 +113,9 @@ extern "C" {
  * Signature: ()V
  */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SimulatorJNI_waitForProgramStart(JNIEnv*,
-                                                                     jclass) {
+Java_edu_wpi_first_hal_sim_mockdata_SimulatorJNI_waitForProgramStart
+  (JNIEnv*, jclass)
+{
   HALSIM_WaitForProgramStart();
 }
 
@@ -123,8 +125,9 @@ Java_edu_wpi_first_hal_sim_mockdata_SimulatorJNI_waitForProgramStart(JNIEnv*,
  * Signature: ()V
  */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SimulatorJNI_setProgramStarted(JNIEnv*,
-                                                                   jclass) {
+Java_edu_wpi_first_hal_sim_mockdata_SimulatorJNI_setProgramStarted
+  (JNIEnv*, jclass)
+{
   HALSIM_SetProgramStarted();
 }
 
@@ -134,8 +137,9 @@ Java_edu_wpi_first_hal_sim_mockdata_SimulatorJNI_setProgramStarted(JNIEnv*,
  * Signature: ()V
  */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SimulatorJNI_restartTiming(JNIEnv*,
-                                                               jclass) {
+Java_edu_wpi_first_hal_sim_mockdata_SimulatorJNI_restartTiming
+  (JNIEnv*, jclass)
+{
   HALSIM_RestartTiming();
 }
 
@@ -145,7 +149,9 @@ Java_edu_wpi_first_hal_sim_mockdata_SimulatorJNI_restartTiming(JNIEnv*,
  * Signature: ()V
  */
 JNIEXPORT void JNICALL
-Java_edu_wpi_first_hal_sim_mockdata_SimulatorJNI_resetHandles(JNIEnv*, jclass) {
+Java_edu_wpi_first_hal_sim_mockdata_SimulatorJNI_resetHandles
+  (JNIEnv*, jclass)
+{
   hal::HandleBase::ResetGlobalHandles();
 }
 }  // extern "C"

hal/src/main/native/sim/jni/SpiReadAutoReceiveBufferCallbackStore.cpp

@@ -8,6 +8,7 @@
 #include "SpiReadAutoReceiveBufferCallbackStore.h"
 
 #include <jni.h>
+
 #include <wpi/jni_util.h>
 
 #include "HAL/Types.h"

hal/src/main/native/sim/jni/SpiReadAutoReceiveBufferCallbackStore.h

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <jni.h>
+
 #include <wpi/jni_util.h>
 
 #include "HAL/Types.h"