pivot-editor/N.js

var N =
{
    ID:{
        Walk:0,
        Instance:0
    },

    Create(inMeta)
    {
        return {
            ID:{
                Walk:0,
                Instance:N.ID.Instance++
            },
            Meta:inMeta||{},
            Link:{}
        };
    },
    Connect(inNodeMajor, inNodeMinor, inKey, inUnique)
    {
        if(inUnique) // bail if the nodes are already connected
        {
            let check = N.Step(inNodeMajor, inKey, true);
            if(check)
            {
                if(check.indexOf(inNodeMinor) !== -1)
                {
                    return;
                }
            }
        }
        N.Step(inNodeMajor, inKey, true, true).push(inNodeMinor);
        N.Step(inNodeMinor, inKey, false, true).push(inNodeMajor);
    },
    Disconnect(inNodeMajor, inNodeMinor, inKey)
    {
        let remove = (inArray, inMatch) => inArray.findIndex( (inMember, inIndex, inArray) => (inMember === inMatch) ? inArray.splice(inIndex, 1) : false );

        // if no specific child was passed
        if(inNodeMinor === null)
        {
            // get all the children
            let check = N.Step(inNodeMajor, inKey);
            if(!check){ return; }

            // go down to each child ...
            check.forEach( inNodeMinor => 
            {
                let connections = inNodeMinor.Link[inKey];
                remove( connections.Get, inNodeMajor); // ... and remove any reference to the parent

                // if after the remove operation, this child has no connections on inKey, scrub the key
                if(!connections.Set.length && !connections.Get.length)
                {
                    delete inNodeMinor.Link[inKey];
                }
            });

            // we just wiped out all outgoing connections to the parent, if incoming connections are empty too we can purge the key there as well
            if(inNodeMajor.Link[inKey].Get.length == 0)
            {
                delete inNodeMajor.Link[inKey];
            }
            return;
        }

        // if no specific parent was passed
        if(inNodeMajor === null)
        {
            // get all the parents
            let check = N.Step(inNodeMinor, inKey, false);
            if(!check){ return; }
            
            // go up to each parent ...
            check.forEach( inNodeMajor => 
            {
                let connections = inNodeMajor.Link[inKey];
                remove( connections.Set, inNodeMinor); // ... and remove any reference to the child
                
                // if after the remove operation, this parent has no connections on inKey, scrub the key
                if( !connections.Set.length && !connections.Get.length )
                {
                    delete inNodeMajor.Link[inKey];
                }
            });

            // we just wiped out all incoming connections to the child, if outgoing connections are empty too we can purge the key there as well
            if(inNodeMinor.Link[inKey].Set.length == 0)
            {
                delete inNodeMinor.Link[inKey];
            }
            return;
        }

        // if a specific parent and child were passed
        if(inNodeMajor.Link[inKey].Set.length == 1)
        {
            delete inNodeMajor.Link[inKey];
        }
        else
        {
            remove(inNodeMajor.Link[inKey].Set, inNodeMinor);
        }
        if(inNodeMinor.Link[inKey].Get.length == 1)
        {
            delete inNodeMinor.Link[inKey];
        }
        else
        {
            remove(inNodeMinor.Link[inKey].Get, inNodeMajor);
        }

    },
    Step(inNode, inKey, inForward, inForceCreate)
    {
        let connectionGroup = inNode.Link[inKey];
        if(!connectionGroup)
        {
            if(inForceCreate === true)
            {
                inNode.Link[inKey] = connectionGroup = {Get:[], Set:[]};
            }
            else
            {
                return false;
            }
        }
        return (inForward === undefined || inForward === true) ? connectionGroup.Set : connectionGroup.Get;
        
    },
    Walk(inIterator, inNode, inKey, inForward, inTerminal)
    {
        let array = N.Step(inNode, inKey, inForward);

        if(!array.length && inTerminal)
        {
            return inTerminal(inNode);
        }

        for(let i=0; i<array.length; i++)
        {
            let next = array[i];
            if(next.ID.Walk !== N.ID.Walk)
            {
                next.ID.Walk = N.ID.Walk;
                //console.log("processing", next.Meta)
                let results = inIterator(next);
                if(results !== false)
                {
                    N.Walk(inIterator, next, inKey, inForward, inTerminal);
                }
                else
                {
                    //console.log("routine exited");
                }
            }
            else
            {
                //console.log("id collision");
            }
        }
    },
    Path(inArray, inNode, inKey, inForward)
    {
        var current = inNode;
        var direction = inForward||true;
        for(let i=0; i<inArray.length; i++)
        {
            current = N.Step(current, inKey, direction)[inArray[i]];
        }
        return current;
    }
};