protected GreenCrawlSyntaxNode[] ChildCopy()
{
GreenCrawlSyntaxNode[] newArray = new GreenCrawlSyntaxNode[ChildCount];
Array.Copy(_children, newArray, ChildCount);
return(newArray);
}
public CrawlSyntaxNode Translplant(CrawlSyntaxNode replacement)
{
Stack <int> parrentIndex = new Stack <int>();
int count = 0;
GreenCrawlSyntaxNode toInsert = replacement.Green;
CrawlSyntaxNode self = this;
while (self.Parent != null)
{
parrentIndex.Push(self.IndexInParent);
toInsert = self.Parent.Green.WithReplacedChild(toInsert, self.IndexInParent);
self = self.Parent;
count++;
}
CrawlSyntaxNode newRoot = toInsert.CreateRed(null, 0);
while (parrentIndex.Count != 0)
{
newRoot = newRoot.GetChildAt(parrentIndex.Pop());
if (newRoot == null)
{
throw new Exception();
}
}
return(newRoot);
}
internal override GreenCrawlSyntaxNode WithReplacedChild(GreenCrawlSyntaxNode newChild, int index)
{
GreenCrawlSyntaxNode[] newArray = ChildCopy();
newArray[index] = newChild;
return(new GreenListNode <T>(Interval, newArray));
}
/// <param name="parent">The parent of this node.</param>
/// <param name="self">The red counterpart of this node.</param>
/// <param name="indexInParent">The index this node has in its parent.</param>
protected internal CrawlSyntaxNode(CrawlSyntaxNode parent, GreenCrawlSyntaxNode self, int indexInParent)
{
Parent = parent;
Green = self;
//GreenNodes sometimes uses upper bits to encode extra information. Not allowed here
// ReSharper disable once BitwiseOperatorOnEnumWithoutFlags
Type = self.Type;
IndexInParent = indexInParent;
}
internal override GreenCrawlSyntaxNode WithReplacedChild(GreenCrawlSyntaxNode newChild, int index)
{
if (0 > index || index >= ChildCount)
{
throw new ArgumentOutOfRangeException();
}
var newchildren = ChildCopy();
newchildren[index] = newChild;
return(new GreenBlockNode(Type, Interval, newchildren, Scope));
}
/// <summary>
/// This is one of the big pieces of the puzzle of how the Red side of the tree.
/// It tries to take the <paramref name="slot"/> child and either return the
/// coresponding child or create it. This value is cached in <paramref name="field"/>.
/// This would be rather simple to do, except that this needs to be done
/// <b>thread safe</b>.
/// </summary>
/// <typeparam name="T">The type of child</typeparam>
/// <param name="field">A field to cache the value in.</param>
/// <param name="slot">The index of the child</param>
/// <returns>A child node, either a new or from cache.</returns>
protected T GetRed <T>(ref T field, int slot) where T : CrawlSyntaxNode
{
T result = field;
if (result == null)
{
GreenCrawlSyntaxNode green = this.Green.GetChildAt(slot);
if (green != null)
{
Interlocked.CompareExchange(ref field, (T)green.CreateRed(this, slot), null);
result = field;
}
}
return(result);
}
internal abstract GreenCrawlSyntaxNode WithReplacedChild(GreenCrawlSyntaxNode newChild, int index);
public ListNode(CrawlSyntaxNode parent, GreenCrawlSyntaxNode self, int indexInParent) : base(parent, self, indexInParent)
{
_childNodes = new T[self.ChildCount];
}
public BlockNode(CrawlSyntaxNode parent, GreenCrawlSyntaxNode self, int indexInParent)
: base(parent, self, indexInParent)
{
Scope = ((GreenBlockNode)self).Scope;
}