source: gs3-extensions/web-audio/trunk/js-dsp/component/workflow-core.js@ 28388

// ******
// 'Component.java' helper enums
// ******


var FiringPolicy = {
    all: 0,
    any: 1
};

var Licenses = {
    UofINCSA: 0, 
    ASL_2: 1, 
    Other: 2
};

var Runnable = {
    java: 0,
    python: 1,
    lisp: 2,
    javascript: 3 // **** extension for OeRC work
};


// ******
// StringSerminator
// ******

var StringTerminator = function() {
    this.type = "terminator";
}

StringTerminator.isStreamTerminator = function (obj) {
    
    return ((obj.type!=null) && (obj.type == "terminator"));
}


// ******
// ComponentContext
// ******


var Component = function() {
    this.outputConnector = {};
    this.outputConnectorInputName = {};
}

Component.method('connectOutput', function(outputName, inputCpt, inputCptName) {
    
    this.outputConnector[outputName] = inputCpt;
    this.outputConnectorInputName[outputName] = inputCptName;

});


Component.method('setProperty', function(p,v) {

    this.getset[p] = v;
});


Component.method('getProperty', function(p) {

    return getset[p];
});




// ******
// ComponentContext
// ******


var _wfcPushDataCount = 0;

var ComponentContext = function(component) {
    this.component = component;
    this.outputConnectorContext = {};

    
    var cia = this.component.ComponentInputArray;
    var cia_len = cia.length;

    // Create an input set with all ComponentInputs set to null
    var input_set = {};

    for (var i=0; i<cia_len; i++) {

    input_set[name] = null;
    }

    this.inputSet = input_set;

    // now work through all the components linked through 'outputConnectors'
    // and recursively set up ComponentContexts for these as well

    for (var output_name in component.outputConnector) {
    
    var next_cpt = component.outputConnector[output_name];
    this.outputConnectorContext[output_name] = new ComponentContext(next_cpt)
    }
}


ComponentContext.prototype.findComponent = function(ca,name) {

    var ca_len = ca.length;

    var c = null;

    for (var i=0; i<ca_len; i++) {
    if (ca[i].name == name) {
        c = ca[i];
    }
    }

    return c;
}



ComponentContext.prototype.getDataComponentFromInput = function(name) {

    var ci = this.findComponent(this.component.ComponentInputArray,name);

    //console.log("*** getData input: name = " + name + " cpt type = " + Object.prototype.toString.call(this.component));

    if (ci==null) {
    // requested name does not exist
    throw "getDataComponentFromInput(): Input name '" + name + " 'is not defined for this '" 
        + Object.prototype.toString.call(this.component) + "' component";
    }
    
    var ci_data = this.inputSet[name]; // note: might be null if input 'name' has not yet arrived

    return ci_data;
}



ComponentContext.prototype.pushDataComponentToOutput = function(name, obj) {

    if ((_wfcPushDataCount%500)==0) {
    console.log("workflow-core::pushDataComponentToOutput() count: " + _wfcPushDataCount);
    }
    _wfcPushDataCount++;

    var co = this.findComponent(this.component.ComponentOutputArray,name);

    if (co==null) {
    // requested name does not exist
    throw "pushDataComponentToOutput(): Output name '" + name + " 'is not defined for '"
        + toType(this.component) + "' component";
    }


    // retrieve the destination Cpt specified by 'name' and its CC

    var next_cpt = this.component.outputConnector[name];
    var next_input_name = this.component.outputConnectorInputName[name];

    var next_cc = this.outputConnectorContext[name]; 

    var next_input_set = next_cc.inputSet;

    if (next_input_set[name] != null) {
    throw "pushDataComponentToOutput(): Input for '" + next_input_name + "' already exists";
    }

    next_input_set[next_input_name] = obj;

    // Now see if the component's executeCallBack method is due to be fired

    var fire_exec = true;

    var firing_policy = next_cpt.firingPolicy;

    //console.log("*** firing policy = " + firing_policy);

    if ((firing_policy!=null) && (firing_policy == FiringPolicy.all)) {
    
    for (var k in next_input_set) {
        if (next_input_set[k] == null) {
        // evidence that all inputs are not there yet
        fire_exec = false;
        break;
        }
    }
    }

    if (fire_exec) {
    // console.log("**** Away to call  executCallback");

    next_cpt.executeCallBack(next_cc);
    }
}


// ******
// Workflow
// ******

var Workflow = function(startingComponent) {
    this.startingComponent = startingComponent;

    var unique_list   = [ startingComponent ];
    var working_queue = [ startingComponent ];

    var visited_cpt   = {};
    visited_cpt[startingComponent.getHashCode] = true;

    while (working_queue.length>0) {
    var curr_cpt = working_queue.shift();
    
    curr_cpt.initializeCallBack();
    
    for (var outputName in this.outputConnector) {
        
        var next_cpt = this.outputConnector[outputName];
        var next_cpt_hashCode = next_cpt.getHashCode;

        if (!visited_cpt[next_cpt_hashCode]) {
        // haven't seen it before
        // => record as seen, and push on queue


        visited_cpt[next_cpt_hashCode] = true;
        working_queue.push(next_cpt);
        }       
    }
    }


    this.uniqueCptList = unique_list;

}

Workflow.prototype.initialize = function() {

    for (var i=0; i<this.uniqueCptList.length; i++) {
    var curr_cpt = this.uniqueCptList[i];
    curr_cpt.initializeCallBack();
    }
};


Workflow.prototype.pumpDataHead = function(name,data) {

    var cc = new ComponentContext(this.startingComponent);
    cc.inputSet[name] = data;

    this.startingComponent.executeCallBack(cc);
};


Workflow.prototype.dispose = function() {

    for (var i=0; i<this.uniqueCptList.length; i++) {
    var curr_cpt = this.uniqueCptList[i];
    curr_cpt.disposeCallBack();
    }
};