/ - Diff - EDIT - EDIT Project Management

cdmlib-commons/src/main/java/eu/etaxonomy/cdm/common/monitor/DefaultProgressMonitor.java
136	136	}
137	137
138	138
	139	/**
	140	* {@inheritDoc}
	141	*/
	142	@Override
	143	public void waitForFeedback() {
	144
	145	}
	146
	147
139	148
140	149	}

     	 */
     	public void warning(String message, Throwable throwable);
     	/**
     	 * Waits for external feedback during the lifetime of the
     	 * operation
     	 */
     	public void waitForFeedback();
+    }

          */
         public void setOwner(String owner);
         public void setFeedback(Object feedback);
         public boolean isWaitingForFeedback();
+    }

     /**
+     *
+     *
      */
     package eu.etaxonomy.cdm.common.monitor;
     /**
      * Empty default implementation
+     *
+     *
      * @author n.hoffmann
+     *
      */
-...
     	@Override
     	public void internalWorked(double work) {
     		//  do nothing
     		//  do nothing
+    	}
         /**
          * {@inheritDoc}
          */
         @Override
         public void waitForFeedback() {
         //  do nothing
+        }
+    }

         private Object result;
         private List<String> reports = new ArrayList<String>();
         private String owner;
         private Object feedback;
         private boolean isWaitingForFeedback = false;
         /**
-...
             this.owner = owner;
+        }
         /**
          * {@inheritDoc}
          */
         @Override
         public void waitForFeedback() {
             synchronized (feedback) {
                 feedback = null;
                 while(feedback == null) {
                     isWaitingForFeedback = true;
                     try {
                         feedback.wait();
                     } catch (InterruptedException ie) {
                         throw new IllegalStateException(ie);
+                    }
+                }
+            }
+        }
         /**
          * {@inheritDoc}
          */
         @Override
         public void setFeedback(Object feedback) {
             synchronized (feedback) {
                 this.feedback = feedback;
                 this.feedback.notifyAll();
                 isWaitingForFeedback = false;
+              }
+        }
         /**
          * {@inheritDoc}
          */
         @Override
         public boolean isWaitingForFeedback() {
             return isWaitingForFeedback;
+        }
+    }

              * are made available under the terms of the Eclipse Public License v1.0
              * which accompanies this distribution, and is available at
              * http://www.eclipse.org/legal/epl-v10.html
+             *
+             *
              * Contributors:
              *     IBM Corporation - initial API and implementation
              *******************************************************************************/
-...
     /**
      * For new implementations consider using {@link SubMonitor}.
+     *
+     *
      * A progress monitor that uses a given amount of work ticks
      * from a parent monitor. It can be used as follows:
      * <pre>
-...
      * </p><p>
      * This class may be instantiated or subclassed by clients.
      * </p>
+     *
+     *
      * @see SubMonitor
      */
     public class SubProgressMonitor extends ProgressMonitorWrapper {
-...
          */
         public static final int SUPPRESS_SUBTASK_LABEL = 1 << 1;
         /**
          * Style constant indicating that the main task label
          * Style constant indicating that the main task label
          * should be prepended to the subtask label.
+         *
          * @see #SubProgressMonitor(IProgressMonitor,int,int)
-...
         private String mainTaskLabel;
         /**
          * Creates a new sub-progress monitor for the given monitor. The sub
          * progress monitor uses the given number of work ticks from its
          * Creates a new sub-progress monitor for the given monitor. The sub
          * progress monitor uses the given number of work ticks from its
          * parent monitor.
+         *
          * @param monitor the parent progress monitor
-...
+        }
         /**
          * Creates a new sub-progress monitor for the given monitor. The sub
          * progress monitor uses the given number of work ticks from its
          * Creates a new sub-progress monitor for the given monitor. The sub
          * progress monitor uses the given number of work ticks from its
          * parent monitor.
+         *
          * @param monitor the parent progress monitor
-...
+         *
          * Starts a new main task. Since this progress monitor is a sub
          * progress monitor, the given name will NOT be used to update
          * the progress bar's main task label. That means the given
          * the progress bar's main task label. That means the given
          * string will be ignored. If style <code>PREPEND_MAIN_LABEL_TO_SUBTASK
          * <code> is specified, then the given string will be prepended to
          * every string passed to <code>subTask(String)</code>.
          */
         @Override
         public void beginTask(String name, int totalWork) {
             nestedBeginTasks++;
             // Ignore nested begin task calls.
             if (nestedBeginTasks > 1) {
                 return;
+            }
             // be safe:  if the argument would cause math errors (zero or
             // be safe:  if the argument would cause math errors (zero or
             // negative), just use 0 as the scale.  This disables progress for
             // this submonitor.
             // this submonitor.
             scale = totalWork <= 0 ? 0 : (double) parentTicks
                     / (double) totalWork;
             if ((style & PREPEND_MAIN_LABEL_TO_SUBTASK) != 0) {
-...
         /* (Intentionally not javadoc'd)
          * Implements the method <code>IProgressMonitor.done</code>.
          */
         @Override
         public void done() {
             // Ignore if more done calls than beginTask calls or if we are still
             // in some nested beginTasks
             if (nestedBeginTasks == 0 || --nestedBeginTasks > 0)
             if (nestedBeginTasks == 0 || --nestedBeginTasks > 0) {
                 return;
+            }
             // Send any remaining ticks and clear out the subtask text
             double remaining = parentTicks - sentToParent;
             if (remaining > 0)
             if (remaining > 0) {
                 super.internalWorked(remaining);
+            }
             //clear the sub task if there was one
             if (hasSubTask)
+             {
                 subTask(""); //$NON-NLS-1$
+            }
             sentToParent = 0;
+        }
-...
         /* (Intentionally not javadoc'd)
          * Implements the method <code>IProgressMonitor.subTask</code>.
          */
         @Override
         public void subTask(String name) {
             if ((style & SUPPRESS_SUBTASK_LABEL) != 0) {
                 return;
-...
         /* (Intentionally not javadoc'd)
          * Implements the method <code>IProgressMonitor.worked</code>.
          */
         @Override
         public void worked(int work) {
             internalWorked(work);
+        }
-...
     	@Override
     	public void warning(String message) {
     		// TODO Auto-generated method stub
+    	}
     	@Override
     	public void warning(String message, Throwable throwable) {
     		// TODO Auto-generated method stub
+    	}
         /**
          * {@inheritDoc}
          */
         @Override
         public void waitForFeedback() {
+        }
+    }

                 if (unitsList != null) {
                     String message = "nb units to insert: " + unitsList.getLength();
                     logger.info(message);
                     state.getConfig().getProgressMonitor().beginTask("Importing ABCD file", unitsList.getLength() + 2);
                     state.getConfig().getProgressMonitor().beginTask("Importing ABCD file", unitsList.getLength() + 3);
                     updateProgress(state, message);
                     state.setDataHolder(new Abcd206DataHolder());

          */
         public IRemotingProgressMonitor getRemotingMonitor(UUID uuid);
         /**
          * Sets the cancel flag to true for the monitor corresponding to the
          * given uuid
+         *
          * @param uuid of remoting monitor
          */
         public void cancel(UUID uuid);
         /**
          * Interrupt thread corresponding to remoting monitor with
          * given uuid

             if(monitorThread != null) {
                 monitorThread.interrupt();
+            }
+        }
         /**
-...
             return RemotingProgressMonitorThread.getMonitorThread(getRemotingMonitor(uuid)) != null;
+        }
         /**
          * {@inheritDoc}
          */
         @Override
         public void cancel(UUID uuid) {
             IRestServiceProgressMonitor monitor = progressMonitorManager.getMonitor(uuid);
             if(monitor != null) {
                 monitor.setCanceled(true);
                 monitor.done();
+            }
+        }
+    }

                 @Override
                 public Object doRun(IRemotingProgressMonitor monitor)  {
                     Object result = longRunningMethod(monitor, ex);
                     monitor.addReport("Report");
                     if(!monitor.isCanceled()) {
                         monitor.addReport("Report");
+                    }
                     return result;
+                }
             };
-...
                     if(i == stepToThrowException && ex != null) {
                         throw ex;
+                    }
                     if(monitor.isCanceled()) {
                         return "Cancelled";
+                    }
                 } catch (InterruptedException e) {
                     throw ex;
+                }

Project

General

Profile

EDIT

Revision 1c7b9181

Added by Cherian Mathew almost 9 years ago