Adding Function and FunctionTask extending RunnableTask functionality

Function allows passing arguments and having a return value in contrast to Runnable,
where FunctionTask allows a Function to be invoked and waited for.

1 files changed, 137 insertions, 0 deletions

diff --git a/src/java/com/jogamp/common/util/TaskBase.java b/src/java/com/jogamp/common/util/TaskBase.java
new file mode 100644
index 0000000..e9366c2
--- /dev/null
+++ b/src/java/com/jogamp/common/util/TaskBase.java
@@ -0,0 +1,137 @@
+/**
+ * Copyright 2010 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ * 
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ * 
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+ 
+package com.jogamp.common.util;
+
+/**
+ * Helper class to provide a Runnable queue implementation with a Runnable wrapper
+ * which notifies after execution for the <code>invokeAndWait()</code> semantics.
+ */
+public abstract class TaskBase implements Runnable {
+    protected final Object syncObject;
+    protected final boolean catchExceptions;
+    
+    protected Object attachment;
+    protected Throwable runnableException;
+    protected long tCreated, tStarted;
+    protected volatile long tExecuted;
+    protected volatile boolean isFlushed;
+
+    protected TaskBase(Object syncObject, boolean catchExceptions) {
+        this.syncObject = syncObject ;
+        this.catchExceptions = catchExceptions ;
+        tCreated = System.currentTimeMillis();
+        tStarted = 0;
+        tExecuted = 0;
+        isFlushed = false;
+    }
+
+    /** 
+     * Return the synchronization object if any.
+     * @see #RunnableTask(Runnable, Object, boolean) 
+     */
+    public Object getSyncObject() {
+        return syncObject;
+    }
+    
+    /** 
+     * Attach a custom object to this task. 
+     * Useful to piggybag further information, ie tag a task final. 
+     */
+    public void setAttachment(Object o) {
+        attachment = o;
+    }
+
+    /** 
+     * Return the attachment object if any.
+     * @see #setAttachment(Object) 
+     */
+    public Object getAttachment() {
+        return attachment;
+    }
+
+    @Override
+    public abstract void run();
+    
+    /** 
+     * Simply flush this task and notify a waiting executor.
+     * The executor which might have been blocked until notified
+     * will be unblocked and the task removed from the queue.
+     * 
+     * @see #isFlushed()
+     * @see #isInQueue()
+     */ 
+    public void flush() {
+        if(!isExecuted() && hasWaiter()) {
+            synchronized (syncObject) {
+                isFlushed = true;
+                syncObject.notifyAll();                
+            }
+        }
+    }
+
+    /**
+     * @return !{@link #isExecuted()} && !{@link #isFlushed()}
+     */
+    public boolean isInQueue() { return 0 != tExecuted && !isFlushed; }
+    
+    /**
+     * @return True if executed, otherwise false;
+     */
+    public boolean isExecuted() { return 0 != tExecuted ; }
+
+    /**
+     * @return True if flushed, otherwise false;
+     */
+    public boolean isFlushed() { return isFlushed; }
+
+    /**
+     * @return True if invoking thread waits until done, 
+     *         ie a <code>notifyObject</code> was passed, otherwise false;
+     */
+    public boolean hasWaiter() { return null != syncObject; }
+
+    /**
+     * @return A thrown exception while execution of the user action, if any and if catched
+     * @see #RunnableTask(Runnable, Object, boolean)
+     */
+    public Throwable getThrowable() { return runnableException; }
+
+    public long getTimestampCreate() { return tCreated; }
+    public long getTimestampBeforeExec() { return tStarted; }
+    public long getTimestampAfterExec() { return tExecuted; }
+    public long getDurationInQueue() { return tStarted - tCreated; }
+    public long getDurationInExec() { return tExecuted - tStarted; }
+    public long getDurationTotal() { return tExecuted - tCreated; }
+
+    @Override
+    public String toString() {
+        return "RunnableTask[executed "+isExecuted()+", t2-t0 "+getDurationTotal()+", t2-t1 "+getDurationInExec()+", t1-t0 "+getDurationInQueue()+", throwable "+getThrowable()+", Attachment "+attachment+"]";
+    }
+}
+