public TNodeMatrixAssign(TNode Parent, Heap<CellMatrix> Heap, int Ref, MNode Expression)
: base(Parent)
{
this._expression = Expression;
this._ref = Ref;
this._mat = Heap;
}
public TNode(TNode Parent, MemoryStruct Heap)
{
this._Parent = Parent;
this._Children = new List<TNode>();
this._Heap = Heap;
this._reg = null;
}
public TNodeExecute(TNode Parent, HScriptProcessor UseScripter, Dictionary<string, FNode> UseBindings, string UseScript)
: base(Parent)
{
this._nodes = UseBindings;
this._scripter = UseScripter;
this._script = UseScript;
}
public void Add(TNode Node)
{
this._tree.Add(Node);
if (Node is TNodeAppendTo)
{
this._ReturnRefs.Add(this._tree.Count - 1);
}
}
public TNodeFor(TNode Parent, int Begin, int End, MemoryStruct Heap, int CellPointer)
: base(Parent)
{
this._Begin = Begin;
this._End = End;
this._Heap = Heap;
this._ptrControll = CellPointer;
}
private int _AssignID; // 0 == assign, 1 == increment, 2 == decrement, 3 == auto increment, 4 == auto decrement
/// <summary>
/// Create an assignment action
/// </summary>
/// <param name="Parent">Parent node</param>
/// <param name="Heap">The memory heap to work off of</param>
/// <param name="Index">The direct location of the variable in the heap</param>
/// <param name="Map">The expression to assign to</param>
/// <param name="AssignID">0 == assign, 1 == increment, 2 == decrement, 3 == auto increment, 4 == auto decrement</param>
public TNodeAssignScalar(TNode Parent, MemoryStruct Heap, int Index, FNode Map, int AssignID)
: base(Parent)
{
this._Heap = Heap;
this._Mapping = Map;
this._Index = Index;
this._AssignID = AssignID;
}
private int _AssignID; // 0 == assign, 1 == increment, 2 == decrement, 3 == auto increment, 4 == auto decrement
public TNodeMatrixUnitAssign(TNode Parent, CellMatrix Data, FNode Node, FNode RowID, FNode ColumnID, int AssignID)
: base(Parent)
{
this._matrix = Data;
this._Node = Node;
this._AssignID = AssignID;
this._row_id = RowID;
this._col_id = ColumnID;
}
public TNodeFileReadString(TNode Parent, string Path, CellHeap Memory, int HeapRef)
: base(Parent)
{
this._path = Path;
this._stream = new StreamReader(Path);
this._heap = Memory;
this._ref = HeapRef;
this.SupportsMapReduce = false;
}
public TNodeFileReadBLOB(TNode Parent, string Path, CellHeap Memory, int HeapRef, int Len)
: base(Parent)
{
this._path = Path;
this._stream = File.Open(Path, FileMode.Open, FileAccess.Read);
this._heap = Memory;
this._ref = HeapRef;
this._len = Len;
this.SupportsMapReduce = false;
}
public TNodeAppendTo(TNode Parent, RecordWriter Writer, FNodeSet Output)
: base(Parent)
{
// Check that the column count is the same; we dont care about the schema //
if (Writer.SourceSchema.Count != Output.Count)
throw new Exception("Attempting to write a different number of recors to a stream");
this._writer = Writer;
this._output = Output;
}
public TNodeAppendToChunkAsync(TNode Parent, RecordSet UseParentData, FNodeSet UseFields)
: base(Parent)
{
if (UseParentData.Columns.GetHashCode() != UseFields.Columns.GetHashCode())
throw new Exception("Output table and fields passed are not compatible");
this._ParentData = UseParentData;
this._RecordCache = new RecordSet(UseParentData.Columns);
this._Fields = UseFields;
}
public TNodePrintMatrix(TNode Parent, MNode Expression)
: base(Parent)
{
this._expression = Expression;
}
public TNodeProcedure(TNode Parent, Procedure Proc, HParameterSet Parameters)
: base(Parent)
{
this._proc = Proc;
this._parameters = Parameters;
}
public TNodePrint(TNode Parent, Workspace Home, FNodeSet Expressions)
: base(Parent)
{
this._expressions = Expressions;
this._home = Home;
}
/// <summary>
/// Adds a child node
/// </summary>
/// <param name="Node">A single child node to add to the current node</param>
public void AddChild(TNode Node)
{
if (Node.MustBeLonely)
throw new Exception("This node cannot be an element of a tree");
Node._Parent = this;
this._Children.Add(Node);
}
public TNodeWhile(TNode Parent, FNode ControlFlow)
: base(Parent)
{
this._control = ControlFlow;
}
public TNodeEscapeLoop(TNode Parent)
: base(Parent)
{
}
public TNode(TNode Parent)
: this(Parent, new MemoryStruct(true))
{
}
public TNodeBeginEnd(TNode Parent)
: base(Parent)
{
}
public TNodeGeneric(TNode Parent, Action Delegate)
: base(Parent)
{
this._delegate = Delegate;
}
public TNodeEscapeRead(TNode Parent)
: base(Parent)
{
}
public TNodeNothing(TNode Parent)
: base(Parent)
{
}
public TNodeIf(TNode Parent, Predicate Condition)
: base(Parent)
{
this._Condition = Condition;
}