public StEdge GetChildEdge(char c)
{
StEdge childEdge = null;
childEdges.TryGetValue(c, out childEdge);
return(childEdge);
}
public string EdgeSubstring(StEdge e)
{
int index1 = e.BeginIndex;
int index2 = e.EndIndex;
return(RangeString(index1, index2));
}
// Rule 1: Try to find matching edge for the parent node.
private ExtensionResult extendSuffixByRuleOne(
ref StSuffix active, ref StNode parentNode, int endIndex)
{
if (active.IsExplicit)
{
StEdge edge = active.OriginNode.GetChildEdge(text[endIndex]);
if (edge != null && edge.IsSet())
{
return(ExtensionResult.Done);
}
}
else // active suffix is implicit
{
StEdge edge = active.OriginNode.GetChildEdge(text[active.BeginIndex]);
int span = active.EndIndex - active.BeginIndex;
if (text[edge.BeginIndex + span + 1] == text[endIndex])
{
return(ExtensionResult.Done);
}
StUtil.WriteLine(StVerbosityLevel.Verbose, String.Format(
" Rule #1: About to split edge E{0:d} (\"{1:s}\") at suffix {2:s}",
edge.Id, edge.GetText(), active.ToString()));
parentNode = edge.Split(active);
}
return(ExtensionResult.NotDone);
}
// Rule 2: Create a new edge and add it to the tree at the parent's position.
// Part of this is inserting the new edge into the hash table,
// and creating a suffix link to the new node from the last one visited.
private void extendSuffixByRuleTwo(
ref StSuffix active, StNode parentNode, ref StNode prevParentNode, int endIndex)
{
StEdge newEdge = new StEdge(this, parentNode, endIndex, this.text.Length - 1);
newEdge.Add();
StUtil.WriteLine(StVerbosityLevel.Verbose, String.Format(
" Rule #2: New edge E{0:d} (\"{1:s}\") connects N{2:d} (old parent) to N{3:d} (new child)",
newEdge.Id,
newEdge.GetText(),
newEdge.ParentNode.Id,
newEdge.ChildNode.Id
));
setSuffixLink(prevParentNode, parentNode);
prevParentNode = parentNode;
}
public StNode Split(StSuffix s)
{
Remove();
StEdge newEdge = new StEdge(tree, s.OriginNode, BeginIndex, BeginIndex + s.Span);
newEdge.Add();
newEdge.ChildNode.SuffixNode = s.OriginNode;
BeginIndex += s.Span + 1;
ParentNode = newEdge.ChildNode;
Add();
StUtil.WriteLine(StVerbosityLevel.Normal, String.Format(
" Split E{0:d} into E{1:d} + E{0:d} = \"{2:s}\" + \"{3:s}\"",
Id, newEdge.Id,
newEdge.GetText(),
this.GetText()
));
return(newEdge.ChildNode);
}
public IEnumerable <StEdge> Edges()
{
Stack <StEdge> edges = new Stack <StEdge>();
foreach (StEdge edge in root.ChildEdges())
{
edges.Push(edge);
}
while (edges.Count > 0)
{
StEdge edge = edges.Pop();
foreach (StEdge childEdge in edge.ChildNode.ChildEdges())
{
edges.Push(childEdge);
}
yield return(edge);
}
yield break;
}
public void Canonicalize()
{
if (IsImplicit)
{
bool haveValuesChanged = false;
StringBuilder sb = new StringBuilder();
sb.AppendLine(" Canonicalize: Entering");
// sb.AppendLine(tree.ToString());
int origNodeId, begin, end;
origNodeId = this.OriginNode.Id;
begin = this.beginIndex;
end = this.endIndex;
StEdge edge = OriginNode.GetChildEdge(tree.Text[BeginIndex]);
while (edge.Span <= Span)
{
sb.Append(String.Format(
" Canonicalize: Active suffix changed from {0:s}",
ToSuffixString(origNodeId, begin, end)));
this.beginIndex += edge.Span + 1;
this.OriginNode = edge.ChildNode;
haveValuesChanged = true;
sb.AppendLine(String.Format(" to {0:s}",
ToSuffixString(OriginNode.Id, beginIndex, endIndex)));
if (Span >= 0)
{
edge = edge.ChildNode.GetChildEdge(tree.Text[BeginIndex]);
}
}
sb.AppendLine(" Canonicalize: Exiting");
if (haveValuesChanged)
{
StUtil.Write(StVerbosityLevel.Verbose, sb.ToString());
}
}
}
private string getToStringEdgeTable(bool doAddIds, bool doAddTree)
{
StringBuilder sb = new StringBuilder();
string edgesBanner = getToStringEdgeBanner();
string addIdsSpacer = " Id ";
if (doAddIds)
{
sb.Append(addIdsSpacer);
}
sb.AppendLine(edgesBanner);
foreach (DepthTaggedEdge dtEdge in DepthTaggedEdges())
{
StEdge edge = dtEdge.Edge;
string formatStr = " {0,-11:d}{1,-11:d}{2,-11:s}{3,-11:d}{4,-9:d}{5,-"
+ text.Length.ToString()
+ ":s}";
if (doAddIds)
{
sb.Append(String.Format(" {0,-4:d}", edge.Id));
}
sb.Append( // edge.ToString(text)
String.Format(formatStr,
edge.ParentNode.Id, edge.ChildNode.Id,
(edge.ChildNode.SuffixNode == null ? "null" : edge.ChildNode.SuffixNode.Id.ToString()),
edge.BeginIndex, edge.EndIndex,
(new String(' ', edge.BeginIndex)) +
RangeString(edge.BeginIndex, edge.EndIndex)));
if (doAddTree)
{
string depthStr = new String(' ', 2 * dtEdge.Depth) + "*";
sb.AppendLine(depthStr);
}
}
return(sb.ToString());
}
public void AddChildEdge(char c, StEdge edge)
{
childEdges.Add(c, edge);
}
public DepthTaggedEdge(StEdge e, int d)
{
Edge = e;
Depth = d;
}
public void AddChildEdge(char c, StEdge edge)
{
childEdges.Add(c, edge);
}
public DepthTaggedEdge(StEdge e, int d)
{
Edge = e;
Depth = d;
}
public StNode Split(StSuffix s)
{
Remove();
StEdge newEdge = new StEdge(tree, s.OriginNode, BeginIndex, BeginIndex + s.Span);
newEdge.Add();
newEdge.ChildNode.SuffixNode = s.OriginNode;
BeginIndex += s.Span + 1;
ParentNode = newEdge.ChildNode;
Add();
StUtil.WriteLine(StVerbosityLevel.Normal, String.Format(
" Split E{0:d} into E{1:d} + E{0:d} = \"{2:s}\" + \"{3:s}\"",
Id, newEdge.Id,
newEdge.GetText(),
this.GetText()
));
return newEdge.ChildNode;
}
public string EdgeSubstring(StEdge e)
{
int index1 = e.BeginIndex;
int index2 = e.EndIndex;
return RangeString(index1, index2);
}
// Rule 2: Create a new edge and add it to the tree at the parent's position.
// Part of this is inserting the new edge into the hash table,
// and creating a suffix link to the new node from the last one visited.
private void extendSuffixByRuleTwo(
ref StSuffix active, StNode parentNode, ref StNode prevParentNode, int endIndex)
{
StEdge newEdge = new StEdge(this, parentNode, endIndex, this.text.Length - 1);
newEdge.Add();
StUtil.WriteLine(StVerbosityLevel.Verbose, String.Format(
" Rule #2: New edge E{0:d} (\"{1:s}\") connects N{2:d} (old parent) to N{3:d} (new child)",
newEdge.Id,
newEdge.GetText(),
newEdge.ParentNode.Id,
newEdge.ChildNode.Id
));
setSuffixLink(prevParentNode, parentNode);
prevParentNode = parentNode;
}
