dag-editor/table.ts

export class Sum
{
    ColumnIndex: number;

    Original: number;
    Adjustment: number;
    FromParents: number;
    FromChildren: number;
    FromOutside: number;

    constructor(inIndex: number)
    {
        this.ColumnIndex = inIndex;
    }
}

export class Table
{
    Name: string;
    Rows: Array<Array<string>>;
    Columns: Array<Sum>;
    Parent?: Table; 
    Children: Array<Table>;

    constructor(inName: string, inRows: Array<Array<string>>, inColumns: Array<number>)
    {
        this.Name = inName;
        this.Rows = inRows;
        this.Parent = null;
        this.Children = [];
        this.Columns = inColumns.map( (inIndex: number) => new Sum(inIndex) );
    }

    Pivot(inColumnPivot: number)
    {
        var cell: string;
        var child: Table;

        this.Rows.forEach((inRow: Array<string>)=>
        {
            cell = inRow[inColumnPivot];
            child = this.Children.find( (inChild: Table) => inChild.Name == cell );
            if(!child)
            {
                child = new Table(cell, [], this.Columns.map( (inColumn: Sum) => inColumn.ColumnIndex ));
                child.Parent = this;
                this.Children.push(child);
            }
            child.Rows.push(inRow);
        });
        this.Rows = [];
    }
    PivotTree(inColumnsPivot: Array<number>)
    {
        var pivotsRemaining: Array<number>;

        if(inColumnsPivot.length == 0)
        {
            return;
        }
        pivotsRemaining = [...inColumnsPivot];
        this.Pivot(pivotsRemaining.shift());
        this.Children.forEach( (inChild: Table) => inChild.PivotTree(pivotsRemaining) );
    }

    ItrParents(inFunction: Function)
    {
        if(this.Parent)
        {
            inFunction(this.Parent);
            this.Parent.ItrParents(inFunction);
        }
    }
    ItrChildren(inFunction: Function)
    {
        this.Children.forEach( (inChild: Table) =>
        {
            inFunction(inChild);
            inChild.ItrChildren(inFunction);
        });
    }
    ItrLeaves(inFunction:Function)
    {
        if(this.Children.length == 0)
        {
            inFunction(this);
        }
        else
        {
            this.Children.forEach( (inChild: Table) => inChild.ItrLeaves(inFunction) );
        }
    }
}

export const Iterators = {
    SumRows: (inTable: Table) =>
    {
        
    }
};