ranger-compiler 2.1.70 → 3.0.3

package/dist/lib/lib/JinxProcess.rgr

@@ -0,0 +1,838 @@
+
+Import "JSON.rgr"
+Import "Timers.rgr"
+; Import "immutableVector.rgr"
+
+systemunion ProcessTypeUnion ( JinxProcess )
+
+Enum processType ( Process Attribute Block Exithandler )
+
+operators {
+    http_get _:void ( path:string port:int cb:(_:void (data:string) )) {
+        templates {
+            es6  (
+        "require('http').get({ host : " (e 1) ", path: " (e 2) ", port:" (e 3) "}, (response) => {" nl I  
+            "var body='';" nl
+            "response.on('data', (d) => { body += d });" nl
+            "response.on('end', () => { (" (e 4)")(body) }) " nl
+            i
+        "})" nl i
+    )
+
+        }
+    }
+}
+
+operator type:string es6 {
+    fn http_get:void ( path:string port:int cb:(_:void (data:string) )) (
+        "require('http').get({ host : " (e 1) ", path: " (e 2) ", port:" (e 3) "}, (response) => {" nl I  
+            "var body='';" nl
+            "response.on('data', (d) => { body += d });" nl
+            "response.on('end', () => { (" (e 4)")(body) }) " nl
+            i
+        "})" nl i
+    )
+    fn https_get:void ( path:string cb:(_:void (data:string) )) (
+        "require('https').get({ host : " (e 1) ", path: " (e 2) "}, (response) => {" nl I  
+            "var body='';" nl
+            "response.on('data', (d) => { body += d });" nl
+            "response.on('end', () => { (" (e 3)")(body) }) " nl
+            i
+        "})" nl i
+    )
+}
+
+operator type:string all {
+    fn createProcess:JinxProcess () {
+        def p (new JinxProcess)
+        p.name = self
+        return p
+    }
+    fn process:JinxProcess ( ) {
+        def p (new JinxProcess)
+        p.name = self
+        return p
+    }
+    ; (process (task ))
+    ;    (task ...)
+    ;    (process ...)
+    ;    (process ...)
+
+}
+
+operator type:JinxProcess all {
+    fn add@(weak):JinxProcess ( task@(strong):JinxProcess ) {
+        push self.children task
+        return self
+    }    
+    fn wait@(weak):JinxProcess ( ms:int ) {
+        def t (new JinxWaitTask)
+        t.ms = ms
+        push self.children t
+        return self
+    }    
+    fn func@(weak):JinxProcess ( cb@(strong):(_:JinxProcessCtx (ctx:JinxProcessCtx))) {
+        def t (new JinxFuncCallBack)
+        t.callback = cb
+        push self.children t
+        return self        
+    }
+    fn call@(weak):JinxProcess ( cb@(strong):(_:void (ctx:JinxProcessCtx))) {
+        def t (new JinxCallBack)
+        t.callback = cb
+        push self.children t
+        return self        
+    }
+    fn async@(weak):JinxProcess ( cb@(strong):(_:void (process:JinxProcess ctx:JinxProcessCtx))) {
+        def t (new JinxAsyncCallBack)
+        t.callback = cb
+        push self.children t
+        return self        
+    }
+    fn fetch@(weak):JinxProcess ( server:string path:string port:int cb@(strong):(_:JinxProcessCtx (res:JSONDataObject ctx:JinxProcessCtx))) {
+        def t (new JinxAjaxHttpFetchTask)
+        t.callback = cb
+        t.server = server
+        t.path = path
+        t.port = port
+        push self.children t
+        return self        
+    }
+}
+
+
+
+;operators {
+;    process _:JinxProcess (name:string) {
+;        templates {
+;            * @macro(true) ("( json_obj " nl I ( repeat 1 (  (block 1) ) ) i nl ")")
+;        }        
+;    }
+;    attr cmdvdomEL:vdomAttr ( name:string value:string ) {
+;        templates {
+;            * @macro(true) ("vdom.newAttr(" (e 1) " " (e 2) ")")
+;        }
+;    }        
+;}
+
+
+class JinxCtxEventHandler {
+    def callback@(weak):(_:void ( ctx:JinxProcessCtx ))
+    fn fire(ctx:JinxProcessCtx) {
+        def cb:(_:void ( ctx:JinxProcessCtx )) (unwrap callback)
+        if(!null? callback) {
+            cb(ctx)
+        }
+    }
+}
+
+class JinxEventHandlerCollection@(immutable) {
+    def list:Vector@(JinxCtxEventHandler) (new Vector@(JinxCtxEventHandler))
+    fn add:JinxEventHandlerCollection (handler@(strong):JinxCtxEventHandler) {
+        list = (push list handler)
+        return this
+    }
+    fn fire (ctx:JinxProcessCtx) {
+        list.forEach({
+            item.fire(ctx)
+        })
+    }
+}
+; tasks can have the context information and use it to signal things
+class JinxProcessCtx@(immutable) {
+    
+    def allKeys:Map@(string boolean) (new Map@(string boolean))   
+    def strValues:Map@(string string) (new Map@(string string))    
+    def intValues:Map@(string int) (new Map@(string int)) 
+    ; def dictValues:Map@(string JSONDataObject) (new Map@(string JSONDataObject))  
+    def subCtxs:Map@(string JinxProcessCtx) (new Map@(string JinxProcessCtx)) 
+    def handlers:Map@(string JinxEventHandlerCollection) (new Map@(string JinxEventHandlerCollection))
+    def anyValues:Map@(string Any) (new Map@(string Any)) 
+
+    fn fire (name:string) {
+        if( has handlers name ) {
+            def h (get handlers name)
+            h.fire(this)
+        }
+    }
+    fn onValue:JinxProcessCtx (name:string cb@(strong lives):(_:void (ctx:JinxProcessCtx))) {
+        def result this
+        def hdlrs:JinxEventHandlerCollection
+        if( false == (has result.handlers name)) {
+            def h (new JinxCtxEventHandler)
+            h.callback = cb
+            def newHandler@(temp) (new JinxEventHandlerCollection)
+            newHandler.list = (push newHandler.list h)
+            result = (result.set_handlers( (set result.handlers name newHandler) ))
+        } {
+            def h (new JinxCtxEventHandler)
+            h.callback = cb
+            def coll (unwrap ( get handlers name ))
+            coll.list = (push coll.list h)
+            result = (result.set_handlers( (set result.handlers name coll) ))
+        }
+        return result
+    }
+
+}
+
+
+operator type:JinxProcessCtx all {
+    fn has:boolean (name:string) {
+        return (has self.allKeys name) 
+    }
+    fn keys:[string] () {
+        return (keys self.allKeys)
+    }
+    fn set:JinxProcessCtx (name:string value:JinxProcessCtx) {
+        def c ( self.set_subCtxs( (set self.subCtxs name value) ) )
+        c = (c.set_allKeys( (set self.allKeys name true)) )
+        c.fire(name)
+        return c
+    }
+    fn getCtx@(optional):JinxProcessCtx (name:string ) {
+        return ( get self.subCtxs name  )
+    }
+    fn set:JinxProcessCtx (name:string value:string) {
+        def c ( self.set_strValues( (set self.strValues name value) ) )
+        c = (c.set_allKeys( (set self.allKeys name true)) )
+        c.fire(name)
+        return c
+    }
+    fn getStr@(optional):string (name:string ) {
+        return ( get self.strValues name  )
+    }
+    fn getString@(optional):string (name:string ) {
+        return ( get self.strValues name  )
+    }
+    fn set:JinxProcessCtx (name:string value:int) {
+        def c ( self.set_intValues( (set self.intValues name value) ) )
+        c = (c.set_allKeys( (set self.allKeys name true)) )
+        c.fire(name)
+        return c
+    }
+    fn getInt@(optional):int (name:string ) {
+        return ( get self.intValues name  )
+    }
+    fn set:JinxProcessCtx (name:string value:JSONDataObject) {
+        def c ( self.set_dictValues( (set self.dictValues name value) ) )
+        c = (c.set_allKeys( (set self.allKeys name true)) )
+        c.fire(name)
+        return c
+    }
+    fn getDict@(optional):JSONDataObject (name:string ) {
+        return ( get self.dictValues name  )
+    }
+  
+}
+
+
+trait task {
+    fn isProcess:boolean () {
+        return false
+    }
+    fn isTask:boolean () {
+        return true
+    }
+}
+
+class JinxProcess {
+    
+    def pType:processType processType.Process
+    def attrs:[string:string]
+
+    def is_cleaned false
+    def is_running:boolean false
+    def is_background false
+    def is_aborted false
+    def is_loop false
+    def is_exithandler false
+    def is_exit_run false
+    def is_persistent false
+    def index -1
+    def buffer_index 0
+    def name ""
+    
+    ; different process types on this process...
+    def backgroundProcesses@(weak):[JinxProcess]
+    def errorHandlers:[JinxProcess]
+    def exitHandlers:[JinxProcess]
+
+    def children:[JinxProcess]
+    def parent@(weak):JinxProcess
+    def myCtx@(weak):JinxProcessCtx
+    ; if returns true exits immediately
+
+    fn getName:string() {
+        return ""
+    }
+    fn getValue:string() {
+        return ""
+    }
+
+    ; --> dispatch change to the processes running things...
+;    fn sendChange( method:(_:JinxProcessCtx (previous:JinxProcessCtx))) {
+;        if(!null? myCtx) {
+;            myCtx = (method( (unwrap myCtx)))
+;        }
+;        if(!null? parent) {
+;            parent.sendChange(method)
+;        }
+;    }
+
+    ; --------- error handler ------- 
+    fn generateError ( ctx:JinxProcessCtx ) {
+        if( ( array_length errorHandlers) > 0 ) {
+            this.abort(ctx)
+            for errorHandlers pc:JinxProcess i {
+                pc.start( ctx )
+            }
+        } {
+            this.abort(ctx)
+            if(!null? parent) {
+                parent.generateError(ctx)
+            }
+        }
+    }
+
+    fn isProcess:boolean () {
+        return true
+    }
+    
+    fn isTask:boolean () {
+        return false
+    }
+
+    fn isGenerator:boolean () {
+        return false
+    }
+
+    fn generate:JinxProcess ( ctx:JinxProcessCtx ) {
+        return (new JinxProcess)
+    }
+
+    fn isBackgroundProcess:boolean () {
+        return is_background
+    }
+
+    ; funtion to override
+    fn cleanup() {
+
+    }
+
+    fn cancelTask () {
+    }
+
+    fn start (ctx:JinxProcessCtx) {
+        if(is_running) {
+            if( index < buffer_index) {
+                this.abort(ctx)
+            } {
+                return            
+            }
+        }
+        myCtx = ctx
+        is_running = true
+        is_aborted = false
+        for children ch:JinxProcess i {
+            if(ch.is_exithandler) {
+                ch.is_exit_run = false
+            }
+        }
+        this.step(ctx)
+    }
+    fn done:void (ctx:JinxProcessCtx) {
+        def findLast:JinxProcess (this)
+        while( (!null? findLast.parent) ) {
+            if(findLast.is_persistent) {
+                break
+            }
+            findLast = (unwrap findLast.parent)
+        }
+        findLast.returnSuccess(ctx)
+    }
+    fn run:boolean (ctx:JinxProcessCtx execParent:JinxProcess) {
+        parent = execParent
+        this.start( ctx )
+        return false
+    }
+    fn runTask:boolean (ctx:JinxProcessCtx execParent:JinxProcess) {        
+        if( is_exithandler ) {
+            return true
+        }
+        parent = execParent
+        if(this.isProcess()) {
+            this.start( ctx )
+            return false            
+        } 
+        if(is_running) {
+            return false
+        }
+        myCtx = ctx
+        is_running = true
+        is_aborted = false
+        def is_done ( this.run( ctx execParent ) )
+        if( is_done ) {
+            is_running = false
+            is_aborted = false
+        }
+        return is_done
+    }
+    fn returnSuccess (ctx:JinxProcessCtx) {
+        if(is_running == false || is_aborted) {
+            return
+        }
+        this.endStep(ctx)
+        if(!null? parent) {
+            def p (unwrap parent)
+            p.step(ctx)
+        }
+    }
+    fn canRun:boolean () {
+        if(null? parent) {
+            return false
+        }
+        def p (unwrap parent)
+        if( p.index >= 0) {
+            def activeTask (itemAt p.children p.index)
+            if( this == activeTask ) {
+                return true
+            }            
+        }
+        return false
+    }
+
+    fn spawnBackground ( ctx:JinxProcessCtx p:JinxProcess ) {
+        if( (p.isProcess()) && is_running ) {
+            p.is_background = true
+            print ">>> background process is starting"
+            p.parent = this
+            push backgroundProcesses p
+            p.start(ctx)
+            return
+        }        
+    }
+
+    ; process is immutable and context contains the parameters which the process tasks need for the
+    ; actual processing...
+    fn step(ctx:JinxProcessCtx) {
+        if ( is_aborted || (is_running == false ) ) {
+            return
+        }
+        if( index >= (array_length children) ) {
+            print "*** TASK ERROR ***"
+            is_aborted = true
+            is_running = false
+            return
+        }
+        if (index >= 0) {
+            def activeTask (itemAt children index)
+            if(activeTask.is_running && (activeTask.is_background == false)) {
+                print "--- active task was running... sorry"
+                return
+            }
+        }
+        index = index + 1
+        if( index >= (array_length children) ) {
+            ; print "--> should exit the process " + name
+            if is_loop {
+                index = -1
+                this.step((unwrap myCtx))
+                return
+            }
+            if(is_persistent) {
+                ; do not exit persistent process until it has specific exit command...
+                return
+            }
+            this.returnSuccess(ctx)
+            return
+        }
+        def p@(lives) (itemAt children index)
+        
+        ; the generator task or process
+        if(p.isGenerator()) {
+            p = p.generate(ctx)
+        }
+        p.parent = this
+        if( (p.isProcess()) &&  (p.isBackgroundProcess()) ) {
+            push backgroundProcesses p
+            p.runTask( ctx this)
+            this.step(ctx)
+            return
+        }
+        ; if run return "true" continue immediately
+        if( p.runTask( ctx this) ) {
+            this.step(ctx)
+        }
+    }
+    fn callExitHandlers(ctx:JinxProcessCtx) {
+        for children ch:JinxProcess i {
+            if(ch.is_exithandler && (false == ch.is_exit_run)) {
+                ch.is_exit_run = true
+                ch.start(ctx)
+            }
+        }        
+    }
+    fn cancel(ctx:JinxProcessCtx) {
+        is_aborted = true
+        if is_running {
+            this.end(ctx)
+            is_aborted = true
+            for children ch:JinxProcess i {
+                ch.cancel(ctx)
+                ; cleanup the task event handlers
+                if(ch.isTask()) {
+                    ch.doTaskCleanup()
+                    ch.cancelTask()
+                    ch.is_running = false
+                    ch.is_aborted = true
+                } {
+                    is_running = false
+                }
+                this.callExitHandlers(ctx)
+            }
+            for backgroundProcesses bProcess:JinxProcess i {
+                bProcess.cancel(ctx)
+            }
+            is_running = false
+        } {
+            print "stopped, clearing bg processes..."
+            for backgroundProcesses bProcess:JinxProcess i {
+                bProcess.cancel(ctx)
+            }
+        }
+    }
+    fn doTaskCleanup() {
+        if( (this.isTask())  && (is_cleaned == false ) ) {
+            is_cleaned = true
+            this.cleanup()
+        }
+    }
+
+    ; after a step ends run this...
+    fn endStep(ctx:JinxProcessCtx) {
+        if(is_running == false) {
+            return
+        }
+        is_running = false
+        index = -1
+        for backgroundProcesses bProcess:JinxProcess i {
+            bProcess.cancel(ctx)
+        }
+        for children ch:JinxProcess i {
+            ch.end(ctx)
+            this.callExitHandlers(ctx)
+        }        
+        clear backgroundProcesses
+    }
+
+    fn end(ctx:JinxProcessCtx) {
+        if(is_running == false) {
+            this.doTaskCleanup()
+            return
+        }
+        is_running = false
+        index = -1
+
+        this.doTaskCleanup()
+
+        ; shutdown the background processing
+        for backgroundProcesses bProcess:JinxProcess i {
+            bProcess.cancel(ctx)
+        }
+        ; cleaning up the child processes...
+        for children ch:JinxProcess i {
+            ch.end(ctx)
+        }        
+        this.callExitHandlers(ctx)
+        clear backgroundProcesses
+    }
+    fn abort(ctx:JinxProcessCtx) {
+        if(is_running) {
+            this.cancel(ctx)
+        }
+    }
+
+    fn addItem (pItem:JinxProcess) {
+        switch pItem.pType {
+            case processType.Attribute {
+                if( (pItem.getName()) == "background") {
+                    this.is_background = true
+                }
+                if( (pItem.getName()) == "loop") {
+                    this.is_loop = true
+                }
+                if( (pItem.getName()) == "exit") {
+                    this.is_exithandler = true
+                }
+                if( (pItem.getName()) == "persistent") {
+                    this.is_persistent = true
+                }
+            }
+            case processType.Process {
+                this.add(pItem)
+            }
+            case processType.Block {
+                pItem.children.forEach({
+                    this.add(item)
+                })
+;                this.add(pItem)
+            }
+            default {
+
+            }
+        }
+    }
+
+    sfn p1:JinxProcess (name:string) {
+        def p (new JinxProcess)
+        p.name = name
+        return p
+    }
+
+    sfn p2:JinxProcess (name:string childP:JinxProcess) {
+        def p (new JinxProcess)
+        p.name = name
+        p.addItem( childP )
+        return p
+    }
+
+    sfn fromList:JinxProcess (list:[JinxProcess]) {
+        def p (new JinxProcess)
+        for list task:JinxProcess i {
+            p.addItem( task )
+        }
+        return p
+    }
+    sfn fromList2:JinxProcess (name:string list:[JinxProcess]) {
+        def p (new JinxProcess)
+        p.name = name
+        for list task:JinxProcess i {
+            p.addItem( task )
+        }
+        return p
+    }
+}
+
+; fetch data from "somewhere"
+
+; fn fetch:JSONDataObject (url:string)
+; -> just set the value to "__R"
+; -> then read the "__R"
+; -> if many calls just pick the __R from several calls when they arrive
+;   callsomeFn( (fetch url1) (fetch url2))
+; -> task should have it's own context set
+; -> you can then read the return values
+
+
+; fn wait (amount:double)
+class JinxWaitTask {
+    def ms 0
+    def waitTimeout:TimeOutID
+    Extends (JinxProcess)
+    does task
+    fn cancelTask () {
+        if(!null? this.waitTimeout) {
+            clearTimeout (unwrap this.waitTimeout)
+        }
+    }
+    fn run:boolean (ctx:JinxProcessCtx execParent:JinxProcess) {
+        def timeout (setTimeout ms {
+            if( is_aborted == false) {
+                this.returnSuccess( ctx )
+            }
+        })
+        this.waitTimeout = timeout
+        return false
+    }    
+}
+
+; TODO: callback as member variable does not work currently....
+class JinxGeneratorTask {
+    def callback:(_:JinxProcess (ctx:JinxProcessCtx ))
+    does task
+    Extends (JinxProcess)
+    fn generate:JinxProcess (ctx:JinxProcessCtx) {
+        def cbFn (unwrap callback)
+        return ( cbFn( ctx ) )
+    }
+    fn isGenerator:boolean () {
+        return true
+    }
+    fn run:boolean (ctx:JinxProcessCtx execParent:JinxProcess) {
+        return true
+    }    
+}
+
+class JinxFuncCallBack {
+    def callback:(_:JinxProcessCtx (ctx:JinxProcessCtx))
+    does task
+    Extends (JinxProcess)
+    fn run:boolean (ctx:JinxProcessCtx execParent:JinxProcess) {
+        def cb (unwrap callback)
+        def nextCtx (cb(ctx))
+        this.returnSuccess( nextCtx )
+        return false
+    }    
+}
+class JinxCallBack {
+    def callback:(_:void (ctx:JinxProcessCtx process:JinxProcess))
+    does task
+    Extends (JinxProcess)
+    fn run:boolean (ctx:JinxProcessCtx execParent:JinxProcess) {
+        def cb (unwrap callback)
+        cb(ctx execParent)
+        return true
+    }    
+}
+
+class JinxAsyncCallBack {
+    def callback:(_:void ( process:JinxAsyncCallBack ctx:JinxProcessCtx ))
+    does task
+    Extends (JinxProcess)
+    fn run:boolean (ctx:JinxProcessCtx execParent:JinxProcess) {
+        print "callback is called "        
+        def cb (unwrap callback)
+        cb(this ctx)
+        return false
+    }    
+}
+
+
+class processAttr {
+    Extends (JinxProcess)
+    def name ""
+    def value ""
+    fn getName:string () {
+        return name
+    }
+    fn getValue:string () {
+        return value
+    }
+}
+
+class JinxProcessBlock {
+    
+    Extends (JinxProcess)
+    ; def items@(weak):[JinxProcess]
+
+    static fn fromList:JinxProcess ( list:[JinxProcess]) {
+        def o (new JinxProcessBlock)
+        o.pType = processType.Block
+        def list2@(lives temp) list
+        o.children = list2
+        return o
+    }
+}
+
+
+operators {
+    process _:JinxProcess ( n:string ) {
+        templates {
+            * @macro(true) ("JinxProcess.p1(" (e 1) ")")
+        }
+    }    
+    process _:JinxProcess ( n:string v:vdom ) {
+        templates {
+            * @macro(true) ("JinxProcess.p2(" (e 1) " " (e 2) ")")
+        }
+    }    
+    process _@(expands):JinxProcess ( v:JinxProcess el2:JinxProcess ) {
+        templates {
+            * @macro(true) ("(JinxProcess.fromList( ([] _:JinxProcess (" nl I
+                ( repeat 1 ( nl (e 1) nl ) ) i nl
+                "))))")
+        }
+    }       
+    process _@(expands):JinxProcess ( n:string el2:JinxProcess ) {
+        templates {
+            * @macro(true) ("(JinxProcess.fromList2( " (e 1) " ([] _:JinxProcess (" nl I
+                ( repeat 2 ( nl (e 1) nl ) ) i nl
+                "))))")
+        }
+    }       
+    process.block _@(expands):JinxProcess ( el2:[JinxProcess] ) {
+        templates {
+            * @macro(true) ("(JinxProcessBlock.fromList( " (e 1) " ))")
+        }
+    }       
+    process.block _@(expands):JinxProcess ( el2:JinxProcess ) {
+        templates {
+            * @macro(true) ("(JinxProcessBlock.fromList( " (e 1) " ([] _:JinxProcess (" nl I
+                ( repeat 2 ( nl (e 1) nl ) ) i nl
+                "))))")
+        }
+    }       
+}
+operator type:JinxProcess all {
+    fn getAttr:string (name:string) {
+
+    }
+}
+operator type:void all {
+    fn task.func:JinxProcess ( callback@(strong):(_:JinxProcessCtx (ctx:JinxProcessCtx)) ) {
+        def t (new JinxFuncCallBack)
+        t.callback = callback
+        return t        
+    }       
+    ; JinxGeneratorTask
+    fn task.generate:JinxProcess ( callback@(strong):(_:JinxProcess (ctx:JinxProcessCtx) ) ) {
+        def t (new JinxGeneratorTask)
+        t.callback = callback
+        return t        
+    }
+    fn task.call:JinxProcess ( callback@(strong):(_:void (ctx:JinxProcessCtx process:JinxProcess)) ) {
+        def t (new JinxCallBack)
+        t.callback = callback
+        return t        
+    }
+    fn task.callback:JinxProcess ( callback@(strong):(_:void (ctx:JinxProcessCtx)) ) {
+        def t (new JinxCallBack)
+        t.callback = callback
+        return t        
+    }
+}
+operator type:string all {
+    fn process () {
+        def p (new JinxProcess)
+        p.name = self
+        return p
+    }
+    fn process.attr:JinxProcess (value:string) {
+        def pa (new processAttr)
+        pa.name = self
+        pa.value = value
+        pa.pType = processType.Attribute
+        return pa
+    }
+    fn task.func:JinxProcess ( callback@(strong):(_:JinxProcessCtx (ctx:JinxProcessCtx)) ) {
+        def t (new JinxFuncCallBack)
+        t.callback = callback
+        return t        
+    }    
+    fn task_func:JinxProcess ( callback@(strong):(_:JinxProcessCtx (ctx:JinxProcessCtx)) ) {
+        def t (new JinxFuncCallBack)
+        t.callback = callback
+        return t        
+    }    
+    fn task.callback:JinxProcess ( callback@(strong):(_:void (ctx:JinxProcessCtx)) ) {
+        def t (new JinxCallBack)
+        t.callback = callback
+        return t        
+    }
+    fn task.fancy:JinxProcess () {
+        return (process 
+                    "OK task...."
+                    (task.wait 0.4)
+                )
+    }
+    
+}
+
+operator type:void all {
+    fn task.wait:JinxProcess ( ms:double ) {
+        def t (new JinxWaitTask)
+        t.ms = (to_int (1000.0 * ms ))
+        return t        
+    }
+}