Changeset 420 for Dev/branches/rest-dojo-ui/client/qed/lib/async.js

Timestamp:

12/16/12 20:07:35 (12 years ago)

Author:

hendrikvanantwerpen

Message:

We can store answers for surveys now!

Introduces SurveyRun?, which can be edited. Workflow not quite clear yet. A
running survey can be accessed to leave a response. When the response
has an ID, it is loaded (used for closed surveys and continuations). A
researcher cannot create responses yet. He should also be able to add
comments to responses (that he creates).

Introduced caching of store requests.

Factored out path matching and formatting.

Put object creation in separate classes, to localize model/storage
dependency. Not consistent at the moment.

Location:

Dev/branches/rest-dojo-ui/client/qed/lib

Files:

• . (added)
• async.js (moved) (moved from Dev/branches/rest-dojo-ui/server/couchdb-admin/config/util/async.js) (1 diff)

Dev/branches/rest-dojo-ui/client/qed/lib/async.js

@@ -1 +1 @@
 define([
-     'dojo/Deferred',
-],function(Deferred){
+     'dojo/_base/array',
+     'dojo/_base/lang',
+     'dojo/when',
+     'dojo/Deferred'
+],function(array,lang,when,Deferred){
 
-    function seq(functions) {
+    /** Execute possible async functions in sequence
+     * Execute functions in order. When a function returns a Promise,
+     * the next function is only executed when the promise resolves.
+     * If the function returns a value, the next function is executed
+     * synchronously. The return value of every function is passed as argument
+     * to the next.
+     * Returns the return value of the last function in the chain.
+     */
+    function seq(functions,ctx) {
         var d = new Deferred();
-        (function stepper(fs,arg) {
+
+        var cancelled = false;
+        var running = null;
+        function cancel(err) {
+            if ( cancelled ) return;
+            cancelled = true;
+            running && running.cancel && !running.isFulfilled() && running.cancel();
+            d.reject(err);
+        }
+
+        function update(fs,arg) {
+            if ( cancelled ) return;
             if ( fs.length > 0 ) {
                 try {
                     var f = fs.shift();
-                    var ret = f(arg);
-                    if ( ret && ret.then ) {
-                        ret.then(function(ret){
-                            stepper(fs,ret);
-                        });
-                    } else {
-                        stepper(fs,ret);
-                    }
+                    running = when(f.call(ctx,arg))
+                    .then(function(res){
+                        update(fs,res);
+                    },function(err){
+                        cancel(err);
+                    });
                 } catch(err) {
-                    d.reject(err);
+                    cancel(err);
                 }
             } else {
-                d.resolve();
+                d.resolve(arg);
             }
-        })(functions);
+        }
+
+        update(functions);
+
         return d.promise;
     }
 
+    /** Execute possible async functions in parallel
+     * Execute all functions in parallel, resolve only when all have resolved.
+     * NB. When a function is not async, it will fully complete before the next
+     * async function is started. If you mix async and non async functions, put
+     * the sync functions last to fully exploit the async ones.
+     * Return an array with all the return values of the functions.
+     */
+    function par(functions,ctx) {
+        var d = new Deferred(cancel);
+
+        var cancelled = false;
+        var running = [];
+        function cancel(err) {
+            if (cancelled) return;
+            cancelled = true;
+            array.forEach(running,function(running){
+                running && running.cancel && !running.isFulfilled() && running.cancel();
+            });
+            d.reject(err);
+        }
+
+        var results = [];
+        var left = functions.length;
+        function update(res,idx) {
+            if (cancelled) return;
+            results[idx] = res;
+            left -= 1; // Works because/as long as AJAX/JS is single-threaded.
+            if ( left === 0 ) {
+                d.resolve(results);
+            }
+        }
+
+        array.forEach(functions,function(f,idx){
+            if (cancelled) return;
+            try {
+                running.push(when(f.call(ctx)).then(function(res){
+                    update(res,idx);
+                },function(err){
+                    cancel(err);
+                }));
+            } catch (err) {
+                cancel();
+            }
+        });
+
+        return d.promise;
+    }
+
+    /** Iterate over an array with async callback
+     * Execute the callback and if it's async, wait until it's finished before
+     * executing the next one.
+     */
     function forEach(list,callback,ctx) {
-        var d = new Deferred();
-        (function stepper(list,idx){
-            if ( list.length > 0 ) {
-                var el = list.shift();
-                var ret = callback.call(ctx,el,idx);
-                if ( ret && ret.then ) {
-                    ret.then(function(){
-                        stepper(list,idx+1);
-                    });
-                } else {
-                    stepper(list,idx+1);
-                }
-            } else {
-                d.resolve();
-            }
-        })(list,0);
-        return d.promise;
+        var fs = array.map(list,function(item,index,items){
+            return lang.hitch(ctx,callback,item,index,items);
+        });
+        return seq(fs);
+    }
+
+    /** Map a list, possible async
+     * Map every element of a list, returning a promise to the mapped list.
+     */
+    function map(list,callback,ctx) {
+        var fs = array.map(list,function(item,index,items){
+            return lang.hitch(ctx,callback,item,index,items);
+        });
+        return par(fs);
     }
 
     return {
         seq: seq,
-        forEach: forEach
+        par: par,
+        forEach: forEach,
+        map: map
     };