Changeset 39031

Timestamp:

2024-05-17T22:44:25+12:00 (3 weeks ago)

Author:

anupama

Message:

Lots of important changes after talking to Dr Bainbridge: the public invokeOnEDT() variants are now the regaular case invokeInEDT_replacesProceedInCurrThread() and the special case where we have to start the Thread param if we've switched off the EDT changes: invokeInEDT_replacesThreadStart(). If bypassing on a case by case basis, then for each case (each instance of calling invokeInEDT variant) there's also printing of the calling thread name and any Thread param name (if a Thread was passed in). Can clean it up a little more.

File:

• main/trunk/gli/src/org/greenstone/gatherer/Gatherer.java (modified) (3 diffs)

main/trunk/gli/src/org/greenstone/gatherer/Gatherer.java

@@ -172 +172 @@
     
     //******************* CODE FOR IMPORTANT HELPER FUNCTIONS FOR GUI TESTING *****************
-    
+
     // Changes made to GLI execute GUI code in the Event Dispatch Thread (EDT) allowing GUI
     // testing with AssertJ Swing can be beneficial for GLI overall. In case it breaks GLI
     // or you suspect it has, set this to true. There's still extra method invocations, but
     // it's otherwise the same linear sequence and gets executed on the same thread as originally
-    static public boolean TURN_OFF_EVENTDISPATCH_CHANGES = false;
-
+    public static final boolean TURN_OFF_EVENTDISPATCH_CHANGES = false;
+    public static boolean PRINT_THREAD_NAMES = false; // verbose info for debugging, can change
+    
     // SYNC executes code with invokeAndWait on the EDT (waiting until termination of the runnable)
     // ASYNC calls invokeLater() which is the same as calling aThread.start(), not waiting for
     // any result of the code being executed.
-    static public boolean SYNC = true;
-    static public boolean ASYNC = false;
+    public static final boolean SYNC = true;
+    public static final boolean ASYNC = false;
     // If you know some changes are undesirable for regular GLI, but they're needed for
-    // testing to not throw EDT exceptions, pass in DO_NOT_BYPASS_FOR_TESTING as 3rd arg
-    // to Gatherer.invokeInDispatchThread()
-    static public boolean BYPASS_IF_NOT_TESTING = true;
-    static public boolean DO_NOT_BYPASS_IF_NOT_TESTING = false;
-
-    // Idea taken from
-    // https://stackoverflow.com/questions/2684049/check-if-thread-is-edt-is-necessary
-    // TODO: Allow extra parameter if any EDT call made for testing should Never be applied
-    // to GLI in non-testing mode
-    public static void invokeInDispatchThread(boolean invokeAs, Runnable runnable) {
-    invokeInDispatchThread("", invokeAs, DO_NOT_BYPASS_IF_NOT_TESTING, runnable);
+    // testing, to not throw EDT exceptions, then pass in DO_NOT_BYPASS_FOR_TESTING as 3rd arg
+    // to Gatherer.invokeInEDT...()
+    public static final boolean BYPASS_WHEN_NOT_TESTING = true;
+    public static final boolean DO_NOT_BYPASS_WHEN_NOT_TESTING = false;
+
+    // When turning off event dispatch changes globally (with TURN_OFF_EVENTDISPATCH_CHANGES
+    // set to true) or when bypassing EDT changes on a case by case call to invokeInEDT...
+    // we need to know what the *original* behaviour of GLI was that was replaced by the
+    // invokeInEDT call, so that we return to running it in the same thread as GLI did,
+    // instead of on the EDT.
+    // So we need to know if GLI ran the Runnable code in the new Runnable Thread (passed in
+    // as param Runnable) by calling start() on it, or whether GLI ran the Runnable code in
+    // whatever the current thread was at the time/whatever the thread was before switch to EDT.
+    private static final int RUN_IN_THREAD_PARAM_WITH_START = 1;
+    private static final int PROCEED_IN_CURRENT_THREAD = 2;
+    
+    /*
+    public static void invokeInEDT(boolean invokeAs, Runnable runnable) {
+    invokeInDispatchThread("", invokeAs, DO_NOT_BYPASS_WHEN_NOT_TESTING,
+                   PROCEED_IN_CURRENT_THREAD, runnable);
+    }    
+    public static void invokeInEDT(String callerDescription, boolean invokeAs, Runnable runnable)
+    {
+    invokeInDispatchThread(callerDescription, invokeAs, DO_NOT_BYPASS_WHEN_NOT_TESTING, PROCEED_IN_CURRENT_THREAD, runnable);
     }
+    */
     // Call like:
     /*
-      Gatherer.invokeInDispatchThread("Gatherer.init()", Gatherer.<SYNC|ASYNC>, new Runnable() {
+      Gatherer.invokeInEDT_replacesProceedInCurrThread("Gatherer.init()", Gatherer.<SYNC|ASYNC>, new Runnable() {
          public void run() {
             .... some GUI/event code that should happen on EDT
@@ -206 +221 @@
     */
     // BEWARE: in the code you embed in run() on rewriting any existing code,
-    // change any this references to <Outerclass>.this
-    public static void invokeInDispatchThread(String callerDescription, boolean invokeAs, Runnable runnable) {
-    invokeInDispatchThread(callerDescription, invokeAs, DO_NOT_BYPASS_IF_NOT_TESTING, runnable);
+    // change any This references to <Outerclass>.this
+    
+    
+    // Versions that replace (new MyThreadSubclass()).start() coding pattern in GLI
+    // when it needs invoking on EDT. If EDT changes are turned off globally or bypassed on
+    // a case by case basis, the Runnable code will be run on the thread passed in as param, as
+    // happens by calling start() on the thread instead of running the code on the calling thread
+    public static void invokeInEDT_replacesThreadStart(String callerDescription,
+           boolean invokeAs, boolean bypassIfNotTesting, Thread newThread)
+    {
+    invokeInDispatchThread(callerDescription, invokeAs, bypassIfNotTesting,
+                   RUN_IN_THREAD_PARAM_WITH_START, newThread);
     }
-    public static void invokeInDispatchThread(String callerDescription, boolean invokeAs,
-                          boolean bypassIfNotTesting, Runnable runnable) {
+    public static void invokeInEDT_replacesThreadStart(String callerDescription,
+           boolean invokeAs, Thread newThread)
+    {
+    invokeInDispatchThread(callerDescription, invokeAs, DO_NOT_BYPASS_WHEN_NOT_TESTING,
+                   RUN_IN_THREAD_PARAM_WITH_START, newThread);
+    }
+    
+    // The more common alternative: versions of invokeInEDT_replacesProceedInCurrThread().
+    // This version replaces any block of code Runnable code to be run in the Event Dispatch
+    // Thread, EDT (unless changes for testing are turned off globally or bypassed on a case by
+    // basis, in which case the block of Runnable code gets run in whatever is the calling thread)
+    public static void invokeInEDT_replacesProceedInCurrThread(String callerDescription,
+                                   boolean invokeAs, boolean bypassIfNotTesting, Runnable runnable)
+    {
+    invokeInDispatchThread(callerDescription, invokeAs, bypassIfNotTesting, PROCEED_IN_CURRENT_THREAD, runnable);
+    }
+    public static void invokeInEDT_replacesProceedInCurrThread(String callerDescription,
+           boolean invokeAs, Runnable runnable)
+    {
+    invokeInDispatchThread(callerDescription, invokeAs, DO_NOT_BYPASS_WHEN_NOT_TESTING,
+                   PROCEED_IN_CURRENT_THREAD, runnable);
+    }
+    
+    // Skeleton structure and basic idea of function taken from
+    // https://stackoverflow.com/questions/2684049/check-if-thread-is-edt-is-necessary
+    // DONE: Allows extra parameter bypass... if any EDT call made for testing should
+    // Never be applied to GLI in non-testing mode
+    private static void invokeInDispatchThread(String callerDescription, boolean invokeAs,
+           boolean bypassIfNotTesting, int runVariant, Runnable runnable)
+    {
+    if(PRINT_THREAD_NAMES) {
+        // https://stackoverflow.com/questions/467224/renaming-threads-in-java
+        Map<Thread,StackTraceElement[]> threadsInfo = Thread.getAllStackTraces();
+        Set<Thread> allActiveThreads = threadsInfo.keySet();
+        //for(Map.Entry<Thread,StackTraceElement[]> : threadsInfo) {
+        for(Thread aThread : allActiveThreads) {
+        System.err.println("thread name: " + aThread.getName()
+                   + " - class " + aThread.getClass().getName());
+        }
+    }
+
+    // print calling thread's name
+    if(bypassIfNotTesting) {
+        System.err.println("Calling thread name: " + Thread.currentThread().getName()
+                   + " - class " + Thread.currentThread().getClass().getName());
+        if(runnable instanceof Thread) {
+        Thread t = (Thread)runnable;
+        System.err.println("\tRunnable thread name: " + t.getName()
+                   + " - class " + t.getClass().getName());
+        }
+    }
+    
     if(TURN_OFF_EVENTDISPATCH_CHANGES
        || (bypassIfNotTesting && !TestingPreparation.TEST_MODE)
-       || EventQueue.isDispatchThread()) {
+       || EventQueue.isDispatchThread()) {    
+        
         if (bypassIfNotTesting && !TestingPreparation.TEST_MODE) {
-        System.err.println(callerDescription + " - Bypassing EDT change");
+        System.err.println("@@@@" + callerDescription + " - Bypassing EDT change");
         }
-        runnable.run();
-    } else {
+        if(!EventQueue.isDispatchThread()) {
+        System.err.println("@@@@" + callerDescription + "\n"
+                   + "\tExpected to be on the Event Dispatch Thread but not so."
+                   + "\n\tThis is potentially dangerous!!!");
+        }
+        
+        if(TURN_OFF_EVENTDISPATCH_CHANGES
+           || (bypassIfNotTesting && !TestingPreparation.TEST_MODE)) {
+        
+        // run it as before the EDT changes to GLI:
+        if(runVariant == RUN_IN_THREAD_PARAM_WITH_START) {
+            // start off the param thread to run the runnable in thread of param
+            // instead of whatever the current thread of the calling function is
+            Thread runInThread = (Thread)runnable;
+            runInThread.start(); // async by nature 
+        } else if(runVariant == PROCEED_IN_CURRENT_THREAD) {
+            // run the Runnable code (whether Thread object or not) in
+            // whatever the current thread of the calling function is
+            runnable.run(); // synchronous by nature of runable code running on current thread
+        }
+        } else { // If we want the EDT changes to GLI active and we're in the Dispatch Thread
+        // So just run the Runnable code in the Dispatch thread, regardless of how GLI
+        // used run it. Specifically, don't call start() on any Thread param to run
+        // the code in the non-EDT thread param
+        runnable.run();     
+        }
+        
+    } else { // whether the Runnable is a new Thread or other Runnable object
+        // whether GLI before EDT changes launched it with start() in its own Thread
+        // or it was code run in whatever the current thread was, we run it on the
+        // Dispatch Thread (Event Dispatch Thread, EDT)
         if(invokeAs == ASYNC) {
         SwingUtilities.invokeLater(runnable); // asynchronous
         } else {
         try {
+            System.err.println("\tXXXXX SYNC.");
             SwingUtilities.invokeAndWait(runnable); // synchronous
         } catch(Exception e) {
@@ -236 +341 @@
     }
     }
+    
     //**********************END CODE ORIGINALLY MADE FOR GUI TESTING************************