another [coll] to [pattr] js

It works by living in between [pattr] and [coll]. You can send it any command you would send a [coll] except for "delete", which is a reserved internal js function name (use "del" instead, it will forward the proper command to the [coll] it is connected to). It updates the pattr with the new coll every time it receives one of the messages it understands. There is a list of functions which it merely passes on to the coll, without making any changes in its internal structuring of the data. It is also capable of retrieving the information directly from [coll] if the two are connected properly. The first, second, and fourth outlets of the [coll] must be connected to the second, third and fourth inlets of [js coll_pattr.js] for [coll] to send its data to the [pattr]. The function "collect" will read the current data from the [coll] object.

If there is no need for collecting data from the [coll], then its only necessary to connect the output of the javascript to the input of the [coll] and send any message you would send to [coll] to the input of the javascript. As long as a [pattr] is connected to the first inlet of the javascript, and has "parameter mode" enabled, it will function nearly identically to the [coll] downstream from it and will store nearly identical data in the [pattr].

"Nearly"...what does that mean? I don't know yet. Some ordering will probably get lost....time will tell. Check it out.

autowatch=1;

inlets=5;

setinletassist(0, "pattr bind and incoming messages to coll");
setinletassist(1, "receives output from first inlet of bound coll");
setinletassist(2, "receives output from second inlet of bound coll");
setinletassist(3, "receives output from third and fourth inlet of bound coll");
setinletassist(4, "receives output from freebang object");
setoutletassist(0, "messages to bound coll");

var reg=0;
var data;
var new_data=[];
var coll=[];
var thru=["assoc", "deassoc", "dump", "end", "goto", "filetype", "flags", "length", "next", "max", "nth", "min", "prev", "open", "start", "store", "subsym", "read", "readagain", "refer", "wclose", "write", "writeagain"];

function collect()
{
    coll=[];
    outlet(0, "dump");
}

function clear()
{
    coll=[];
    notifyclients();
    outlet(0, "clear");
}

function del(num)
{
    var args=arrayfromargs(arguments);
    for(var i in coll)
    {
        if(coll[i][0]==num)
        {
            coll.splice(i,1);
        }
        if(typeof coll[i][0]=="number")
        {
            if(coll[i][0]>num)
            {
                coll[i][0]=coll[i][0]-1;
            }
        }
    }
    notifyclients();
    outlet(0, "delete", args);
}

function insert()
{
    var args=arrayfromargs(arguments);
    var num=args[0];
    for(var i in coll)
    {
        if((coll[i][0]>=num)&&(typeof coll[i][0]=="number"))
        {
            coll[i][0]=coll[i][0]+1;
        }
    }
    var proc=0;
    for(var j in coll)
    {
        if((coll[j][0]>=args[0])&&(proc==0))
        {
            coll.splice(j,0,args)
            proc=1;
        }
    }
    outlet(0, "insert", args);
    notifyclients();
}

function nstore()
{
    var args=arrayfromargs(arguments);
    var new_args=[];
    for(var i in args)
    {
        if(i!=1)
        {
            new_args.push(args[i])
        }
    }
    store_to_coll(new_args);
    outlet(0, "nstore", args);
}

function merge()
{
    var args=arrayfromargs(arguments);
    for(var i in coll)
    {
        if(coll[i][0]==args[0])
        {
            for(var j in args)
            {
                coll[i].push(args[j]);
            }
        }
    }
    notifyclients();
    outlet(0, "merge", args);
}

function nsub()
{
    var args=arrayfromargs(arguments);
    for(var i in coll)
    {
        if(coll[i][0]==args[0])
        {
            coll[i][args[1]]=args[2];
        }
    }
    notifyclients();
    outlet(0, "nsub", args);
}

function seperate(args)
{
    for(var i in coll)
    {
        if((coll[i][0]>=args)&&(typeof coll[i][0]=="number"))
        {
            coll[i][0]++;
        }
    }
    notifyclients();
    outlet(0, "seperate", args);
}

function sort()
{
    args=arrayfromargs(arguments);
    outlet(0, "sort");
    outlet(0, "dump");
}

function store()
{
    var args = arrayfromargs(arguments);
    store_to_coll(args);
    notifyclients();
    outlet(0, "store", args);
}

function swap(a, b)
{
    var coll_a;
    var coll_b;
    for(var i in coll)
    {
        if(coll[i][0]==a)
        {
            coll_a=parseInt(i);
        }
        if(coll[i][0]==b)
        {
            coll_b=parseInt(i);
        }
    }
    if((coll_a!=undefined)&&(coll_b!=undefined))
    {
        coll[coll_a][0]=b;
        coll[coll_b][0]=a;
    }
    notifyclients();
    outlet(0, "swap", a, b);
}

function renumber()
{
    var new_num=0;
    for(var i in coll)
    {
        if(typeof coll[i][0]=="number")
        {
            coll[i][0]=new_num;
            new_num++;
        }
    }
    notifyclients();
    outlet(0, "renumber");
}

function renumber2()
{
    for(var i in coll)
    {
        if(typeof coll[i][0]=="number")
        {
            coll[i][0]=coll[i][0]+1;
        }
    }
    notifyclients();
    outlet(0, "renumber2");
}

function remove(arg)
{
    for(var i in coll)
    {
        if(coll[i][0]==arg)
        {
            coll.splice(i,1);
        }
    }
    notifyclients();
    outlet(0, "remove", arg);
}

function anything(num)
{
    var args = arrayfromargs(arguments);
    switch(inlet)
    {
        case 0:
            store_to_coll(args);
            outlet(0, args);
            break;
        case 2:
            reg=num;
            break;
        case 1:
            var args_out=[];
            args_out.push(reg);
            for(var i in args)
            {
                args_out.push(args[i]);
            }
            store_to_coll(args_out);
            break;
    }
}

function store_to_coll(args)
{
    var proc=0;
    for(var t in thru)
    {
        if(args[0]==thru[t])
        {
            proc=1;
        }
    }
    if(proc==0)
    {
        var add=1;
        if(coll.length>0)
        {
            for(var i in coll)
            {
                if(coll[i][0]==args[0])
                {
                    coll[i]=args;
                    add=0;
                }
            }
        }
        if(add>0)
        {
            coll.push(args);
        }
        notifyclients();
    }
}

function getvalueof()
{
    mux();
    return new_data;
}

function setvalueof()
{
    args=arrayfromargs(arguments);
    outlet(0, "clear");
    var temp=[];
    for(var i in args)
    {
        if(args[i]=="^")
        {
            if(i>0)
            {
                coll.push(temp);
                if(typeof temp[0]!="number")
                {
                    temp.unshift("store");
                }
                outlet(0, temp);
                temp=[];
            }
        }
        else
        {
            temp.push(args[i]);
        }
    }
}

function bang()
{
    switch(inlet)
    {
        case 0:
            outlet(0, "bang");
        case 3:
            mux();
            notifyclients();
            break;
        case 4:
            mux();
            notifyclients();
            break;
    }
}

function mux()
{
    new_data=[]
    for(var i in coll)
    {
        new_data.push("^");
        for(var j in coll[i])
        {
            new_data.push(coll[i][j]);
        }
    }
    new_data.push("^");
}

function sortNumber(a,b)
{
    return a - b;
}