move handleCapturedInterrupt etc back to internal

Former-commit-id: 7d022f7aee18106896083f3113a8c9028c98b278
Former-commit-id: 00dd01d

SwerveRoboticsLibrary/src/main/java/org/swerverobotics/library/exceptions/SwerveRuntimeException.java

@@ -32,32 +32,6 @@ public static RuntimeException wrap(Exception e)
         return new RuntimeException(e);
         }
 
-    //----------------------------------------------------------------------------------------------
-    // Dealing with captured exceptions
-    //
-    // That InterruptedException is a non-runtime exception is, I believe, a bug: I could go
-    // on at great length here about that, but for the moment will refrain and defer until another
-    // time: the issue is a lengthy discussion.
-    //
-    // But we have the issue of what to do. That the fellow has captured the interrupt means that
-    // he doesn't want an InterruptedException to propagate. Yet somehow we must in effect do so:
-    // the thread needs to be torn down. Ergo, we seem to have no choice but to throw a runtime
-    // version of the interrupt.
-    //----------------------------------------------------------------------------------------------
-
-    public static void handleCapturedInterrupt(InterruptedException e)
-        {
-        handleCapturedException((Exception)e);
-        }
-
-    public static void handleCapturedException(Exception e)
-        {
-        if (e instanceof InterruptedException || e instanceof RuntimeInterruptedException);
-            Thread.currentThread().interrupt();
-
-        throw wrap(e);
-        }
-
     //----------------------------------------------------------------------------------------------
     // Construction
     //----------------------------------------------------------------------------------------------

SwerveRoboticsLibrary/src/main/java/org/swerverobotics/library/internal/AdaFruitBNO055IMU.java

@@ -716,7 +716,7 @@ private void delayLore(int ms)
             }
         catch (InterruptedException e)
             {
-            SwerveRuntimeException.handleCapturedInterrupt(e);
+            handleCapturedInterrupt(e);
             }
         }
 
@@ -733,7 +733,7 @@ private void delay(int ms)
             }
         catch (InterruptedException e)
             {
-            SwerveRuntimeException.handleCapturedInterrupt(e);
+            handleCapturedInterrupt(e);
             }
         }
 

SwerveRoboticsLibrary/src/main/java/org/swerverobotics/library/internal/HandshakeThreadStarter.java

@@ -1,7 +1,5 @@
 package org.swerverobotics.library.internal;
 
-import org.swerverobotics.library.exceptions.*;
-
 /**
  * A class that helps us start a thread and interlock with its actual starting up.
  *
@@ -80,7 +78,7 @@ public synchronized void start()
             this.started = true;    // so stop() will work
             stop();
 
-            SwerveRuntimeException.handleCapturedException(e);
+            Util.handleCapturedException(e);
             }
         }
 
@@ -112,7 +110,7 @@ public synchronized void stop(int msWait)
                 }
             catch (Exception e)
                 {
-                SwerveRuntimeException.handleCapturedException(e);
+                Util.handleCapturedException(e);
                 }
             finally
                 {

SwerveRoboticsLibrary/src/main/java/org/swerverobotics/library/internal/I2cDeviceClient.java

@@ -240,7 +240,7 @@ public void disarm()
             }
         catch (InterruptedException e)
             {
-            SwerveRuntimeException.handleCapturedInterrupt(e);
+            handleCapturedInterrupt(e);
             }
         }
 
@@ -442,7 +442,7 @@ public void close()
             }
         catch (InterruptedException e)
             {
-            SwerveRuntimeException.handleCapturedInterrupt(e);
+            handleCapturedInterrupt(e);
 
             // Can't return (no data to return!) so we must throw
             throw SwerveRuntimeException.wrap(e);
@@ -522,7 +522,7 @@ public void close()
             }
         catch (InterruptedException e)
             {
-            SwerveRuntimeException.handleCapturedInterrupt(e);
+            handleCapturedInterrupt(e);
             }
         }
 

SwerveRoboticsLibrary/src/main/java/org/swerverobotics/library/internal/SwerveFtcEventLoop.java

@@ -9,8 +9,6 @@
 import com.qualcomm.robotcore.exception.RobotCoreException;
 import com.qualcomm.robotcore.robocol.Command;
 
-import org.swerverobotics.library.exceptions.SwerveRuntimeException;
-
 import java.util.concurrent.Semaphore;
 
 /**
@@ -47,7 +45,7 @@ public void init(EventLoopManager eventLoopManager) throws RobotCoreException, I
             }
         catch (InterruptedException e)
             {
-            SwerveRuntimeException.handleCapturedInterrupt(e);
+            Util.handleCapturedInterrupt(e);
             }
         super.processCommand(command);
         }

SwerveRoboticsLibrary/src/main/java/org/swerverobotics/library/internal/ThunkForReading.java

@@ -64,7 +64,7 @@ public T doUntrackedReadOperation(IInterruptableRunnable actionBeforeDispatch)
                 // Our signature (and that of our caller) doesn't allow us to throw
                 // InterruptedException. But we can't actually return a value to our caller,
                 // as we have nothing to return. So, we do the best we can, and throw SOMETHING.
-                SwerveRuntimeException.handleCapturedException(e);
+                Util.handleCapturedException(e);
                 }
             return this.result;
             }

SwerveRoboticsLibrary/src/main/java/org/swerverobotics/library/internal/ThunkForWriting.java

@@ -1,6 +1,5 @@
 package org.swerverobotics.library.internal;
 
-import org.swerverobotics.library.exceptions.*;
 import org.swerverobotics.library.interfaces.*;
 
 /**
@@ -52,7 +51,7 @@ protected void doUntrackedWriteOperation(IInterruptableRunnable actionBeforeDisp
                 }
             catch (Exception e)
                 {
-                SwerveRuntimeException.handleCapturedException(e);
+                Util.handleCapturedException(e);
                 }
             }
         }

SwerveRoboticsLibrary/src/main/java/org/swerverobotics/library/internal/ThunkedDCMotorController.java

@@ -2,7 +2,6 @@
 
 import com.qualcomm.robotcore.hardware.*;
 import org.swerverobotics.library.*;
-import org.swerverobotics.library.exceptions.*;
 
 /**
  * An implementation of DcMotorController that talks to a non-thunking target implementation
@@ -174,7 +173,7 @@ private void waitForWritesToChannelToDrain(int channel)
             }
         catch (InterruptedException e)
             {
-            SwerveRuntimeException.handleCapturedInterrupt(e);
+            Util.handleCapturedInterrupt(e);
             }
         }
 

SwerveRoboticsLibrary/src/main/java/org/swerverobotics/library/internal/Util.java

@@ -388,4 +388,30 @@ static public void setPrivateDoubleField(Object target, int iField, double value
             throw SwerveRuntimeException.wrap(e);
             }
         }
+
+    //----------------------------------------------------------------------------------------------
+    // Dealing with captured exceptions
+    //
+    // That InterruptedException is a non-runtime exception is, I believe, a bug: I could go
+    // on at great length here about that, but for the moment will refrain and defer until another
+    // time: the issue is a lengthy discussion.
+    //
+    // But we have the issue of what to do. That the fellow has captured the interrupt means that
+    // he doesn't want an InterruptedException to propagate. Yet somehow we must in effect do so:
+    // the thread needs to be torn down. Ergo, we seem to have no choice but to throw a runtime
+    // version of the interrupt.
+    //----------------------------------------------------------------------------------------------
+
+    public static void handleCapturedInterrupt(InterruptedException e)
+        {
+        handleCapturedException((Exception)e);
+        }
+
+    public static void handleCapturedException(Exception e)
+        {
+        if (e instanceof InterruptedException || e instanceof RuntimeInterruptedException);
+            Thread.currentThread().interrupt();
+
+        throw SwerveRuntimeException.wrap(e);
+        }
     }