public int IndexOf(T item)
{
Contract.Ensures(Contract.Result <int>() >= -1);
Contract.Ensures(Contract.Result <int>() < Count);
return(this.IndexOf <T>(item));
}
public static int GetDegree(this IBinaryTreeNode node)
{
Contract.Requires <ArgumentNullException>(node != null);
Contract.Ensures(Contract.Result <int>() >= 0 && Contract.Result <int>() <= 2);
if (SentinelEx.NotEqualNull(node.LeftChild))
{
if (SentinelEx.NotEqualNull(node.RightChild))
{
return(2);
}
else
{
return(1);
}
}
else if (SentinelEx.NotEqualNull(node.RightChild))
{
return(1);
}
else
{
return(0);
}
}
public virtual int LastIndexOf(TData item)
{
Contract.Ensures(Contract.Result <int>() >= -1);
Contract.Ensures(Contract.Result <int>() < Count);
return(EnumerateIndexOf(item, true));
}
public static IEnumerable <IBinaryTreeNode> TraverseSubtree(this IBinaryTreeNode partialroot, TraverseOrder order = TraverseOrder.InOrder)
{
Contract.Requires <ArgumentNullException>(partialroot != null);
Contract.Ensures(Contract.Result <IEnumerable <IBinaryTreeNode> >() != null);
return(partialroot.TraverseSubtree <object>(null, null, null, order).Select(res => res.Item1));
}
/// <summary>
/// Scans current domain included previously unloaded assemblies for IRegister implementations.
/// Assemblies in common will be called first, followed by any others.
/// Calling assembly will be last
/// </summary>
/// <param name="callingAssembly">
/// Used to determine which IRegister implementors should be run last.
/// Useful when you need to override some previous registrations
/// </param>
/// <returns>An autofac IContainer</returns>
public static IContainer GetContainerInstance(Assembly callingAssembly)
{
DiagnosticsContract.Ensures(DiagnosticsContract.Result <IContainer>() != null);
var containerBuilder = new ContainerBuilder();
var assemblies = AssemblyHelper.AssembliesOrdered("Disty.Common", callingAssembly.FullName);
var types = TypeHelper.FindTypesThatExtend <IRegister>(assemblies);
foreach (var type in types)
{
Trace.WriteLine("Executing IRegister.Register method within type " + type);
try
{
((IRegister)Activator.CreateInstance(type)).Register(containerBuilder);
}
catch (Exception exception)
{
Trace.WriteLine(string.Format("Failed to register {0}: {1}", type, exception.Message));
}
}
var container = containerBuilder.Build();
return(container);
}
public static IEnumerable <IMultiwayTreeNode> TraverseSubtree(this IMultiwayTreeNode partialroot, TraverseOrder order = TraverseOrder.LevelOrder)
{
Contract.Requires <ArgumentNullException>(partialroot != null);
Contract.Requires <NotSupportedException>(order != TraverseOrder.InOrder, "多叉树不支持中序遍历");
Contract.Ensures(Contract.Result <IEnumerable <IMultiwayTreeNode> >() != null);
return(partialroot.TraverseSubtree <object>(null, null, order).Select(res => res.Item1));
}
protected virtual IEnumerable <ClassificationSpan> GetClassificationSpansForToken(IToken token, ITextSnapshot snapshot)
{
Contract.Requires <ArgumentNullException>(token != null, "token");
Contract.Requires <ArgumentNullException>(snapshot != null, "snapshot");
Contract.Ensures(Contract.Result <IEnumerable <ClassificationSpan> >() != null);
var classification = ClassifyToken(token);
if (classification != null)
{
SnapshotSpan span = new SnapshotSpan(snapshot, token.StartIndex, token.StopIndex - token.StartIndex + 1);
return(new ClassificationSpan[] { new ClassificationSpan(span, classification) });
}
return(Enumerable.Empty <ClassificationSpan>());
}
private static XElement GetLinks(IList <string> tokenNames, HashSet <State> reachableStates, Dictionary <int, RuleBinding> stateRules, List <XElement> extraLinks)
{
Contract.Requires(reachableStates != null);
Contract.Requires(stateRules != null);
Contract.Requires(extraLinks != null);
Contract.Ensures(Contract.Result <XElement>() != null);
List <XElement> links = new List <XElement>();
foreach (var state in reachableStates)
{
foreach (var transition in state.OutgoingTransitions)
{
string transitionCategory;
if (transition.IsEpsilon)
{
transitionCategory = Categories.EpsilonEdge;
}
else if (transition.IsMatch)
{
transitionCategory = Categories.AtomEdge;
}
else if (transition is PushContextTransition)
{
transitionCategory = Categories.PushContextEdge;
}
else if (transition is PopContextTransition)
{
transitionCategory = Categories.PopContextEdge;
}
else
{
transitionCategory = Categories.Edge;
}
XElement link = new XElement(Elements.Link,
new XAttribute(Attributes.Source, "state_" + state.Id),
new XAttribute(Attributes.Target, "state_" + transition.TargetState.Id),
new XAttribute(Attributes.Category, transitionCategory),
new XAttribute(Attributes.Label, GetTransitionLabel(transition, tokenNames)));
links.Add(link);
}
}
return(new XElement(Elements.Links, links.Concat(extraLinks)));
}
public IList <T> GetRange(int index, int count)
{
Contract.Requires <ArgumentOutOfRangeException>(index >= 0);
Contract.Requires <ArgumentOutOfRangeException>(count >= 0);
Contract.Requires <ArgumentOutOfRangeException>(index + count <= Count);
Contract.Ensures(Contract.Result <IList <T> >() != null);
Contract.EndContractBlock();
if (count > 0)
{
return(tree.Report(index, index + count - 1));
}
else
{
return(new List <T>());
}
}
private static XElement GetNodes(List <RuleBinding> rules, HashSet <State> reachableStates, Dictionary <int, RuleBinding> stateRules, List <XElement> extraLinks)
{
Contract.Requires(rules != null);
Contract.Requires(reachableStates != null);
Contract.Requires(stateRules != null);
Contract.Requires(extraLinks != null);
Contract.Ensures(Contract.Result <XElement>() != null);
Dictionary <State, XElement> nodes = new Dictionary <State, XElement>();
List <XElement> extraNodes = new List <XElement>();
foreach (var rule in rules)
{
extraNodes.Add(new XElement(Elements.Node,
new XAttribute(Attributes.Id, "rule_" + rule.Name),
new XAttribute(Attributes.Label, rule.Name),
new XAttribute(Attributes.Group, "Collapsed")));
}
foreach (var state in reachableStates)
{
string nodeCategory;
if (state.OutgoingTransitions.Count == 0)
{
nodeCategory = Categories.StopState;
}
else
{
nodeCategory = Categories.State;
}
XElement node = new XElement(Elements.Node,
new XAttribute(Attributes.Id, "state_" + state.Id),
new XAttribute(Attributes.Label, GetStateLabel(state)),
new XAttribute(Attributes.Category, nodeCategory));
nodes.Add(state, node);
extraLinks.Add(CreateContainmentLink("rule_" + stateRules[state.Id].Name, "state_" + state.Id));
}
return(new XElement(Elements.Nodes, nodes.Values.Concat(extraNodes)));
}
/// <summary>
/// enumerate the subtree with the root <paramref name="partialroot"/>, provided with certain information (of type <typeparamref name="TLevel"/>) of the node
/// 遍历以<paramref name="partialroot"/>为根的子树，并且在过程中提供结点有关信息(<typeparamref name="TLevel"/>类型的)
/// </summary>
/// <typeparam name="TLevel">提供的每层结点额外信息的类型</typeparam>
/// <param name="partialroot">需要遍历的子树的根</param>
/// <param name="seed">附加参数的初始值</param>
/// <param name="leftlevelfunc">遍历到某一层结点时将附加参数传给下一层左孩子时需要进行的操作</param>
/// <param name="rightlevelfunc">遍历到某一层结点时将附加参数传给下一层右孩子时需要进行的操作</param>
/// <param name="order">二叉树遍历方式</param>
/// <return>遍历得到的结点与附加参数的集合</return>
public static IEnumerable <Tuple <IBinaryTreeNode, TLevel> > TraverseSubtree <TLevel>(
this IBinaryTreeNode partialroot,
TLevel seed,
Func <TLevel, IBinaryTreeNode, TLevel> leftlevelfunc,
Func <TLevel, IBinaryTreeNode, TLevel> rightlevelfunc,
TraverseOrder order = TraverseOrder.InOrder)
{
Contract.Requires <ArgumentNullException>(partialroot != null);
Contract.Ensures(Contract.Result <IEnumerable <Tuple <IBinaryTreeNode, TLevel> > >() != null);
var current = new Tuple <IBinaryTreeNode, TLevel>[] { new Tuple <IBinaryTreeNode, TLevel>(partialroot, seed) };
var leftlevel = leftlevelfunc == null ? seed : leftlevelfunc(seed, partialroot);
var rightlevel = rightlevelfunc == null ? seed : rightlevelfunc(seed, partialroot);
switch (order)
{
case TraverseOrder.InOrder:
return(partialroot.LeftChild.TraverseSubtree(leftlevel, leftlevelfunc, rightlevelfunc, order)
.Concat(current)
.Concat(partialroot.RightChild.TraverseSubtree(rightlevel, leftlevelfunc, rightlevelfunc, order)));
case TraverseOrder.PreOrder:
return(current
.Concat(partialroot.LeftChild.TraverseSubtree(leftlevel, leftlevelfunc, rightlevelfunc, order))
.Concat(partialroot.RightChild.TraverseSubtree(rightlevel, leftlevelfunc, rightlevelfunc, order)));
case TraverseOrder.PostOrder:
return(partialroot.LeftChild.TraverseSubtree(leftlevel, leftlevelfunc, rightlevelfunc, order)
.Concat(partialroot.RightChild.TraverseSubtree(rightlevel, leftlevelfunc, rightlevelfunc, order))
.Concat(current));
case TraverseOrder.LevelOrder:
return(LevelOrderTraverse(partialroot, seed, leftlevelfunc, rightlevelfunc));
default:
return(null);
}
}
public IList <TData> GetRange(int index, int count)
{
Contract.Requires <ArgumentOutOfRangeException>(index >= 0);
Contract.Requires <ArgumentOutOfRangeException>(count >= 0);
Contract.Requires <ArgumentOutOfRangeException>(index + count <= Count);
Contract.Ensures(Contract.Result <IList <TData> >() != null);
Contract.EndContractBlock();
var start = index;
var startnode = Find(ref start);
var end = index + count;
var endnode = Find(ref end);
if (ReferenceEquals(startnode, endnode))
{
var res = new TData[count];
Array.Copy(startnode._items, start, res, 0, count);
return(res.ToList());
}
List <TData> result = new List <TData>(count);
for (int i = start; i < startnode.Count; i++)
{
result.Add(startnode._items[i]);
}
startnode = startnode.Next;
while (!ReferenceEquals(startnode, endnode))
{
result.AddRange(startnode._items.Take(startnode.Count));
startnode = startnode.Next;
}
result.AddRange(endnode._items.Take(end));
return(result);
}
/// <summary>
/// Get the enumerator of subtree, root of which is <paramref name="partialroot"/>
/// 获取以<paramref name="partialroot"/>为根的子树的遍历器
/// </summary>
/// <param name="order">二叉树遍历方式</param>
/// <param name="partialroot">需要遍历的子树的根</param>
public static IEnumerator <TNode> GetSubtreeEnumerator <TNode>(this TNode partialroot, TraverseOrder order = TraverseOrder.InOrder)
where TNode : class, IBinaryTreeNode, IPersistent
{
Contract.Requires <ArgumentNullException>(partialroot != null);
Contract.Ensures(Contract.Result <IEnumerator <TNode> >() != null);
switch (order)
{
case TraverseOrder.InOrder:
return(new BinaryTreeEnumerator <TNode> .InOrderEnumerator(partialroot));
case TraverseOrder.PreOrder:
return(new BinaryTreeEnumerator <TNode> .PreOrderEnumerator(partialroot));
case TraverseOrder.PostOrder:
return(new BinaryTreeEnumerator <TNode> .PostOrderEnumerator(partialroot));
case TraverseOrder.LevelOrder:
return(new BinaryTreeEnumerator <TNode> .LevelOrderEnumerator(partialroot));
default:
return(null);
}
}
/// <summary>
/// enumerate the subtree with the root <paramref name="partialroot"/>, provided with certain information (of type <typeparamref name="TLevel"/>) of the node
/// 遍历以<paramref name="partialroot"/>为根的子树，并且在过程中提供结点有关信息(<typeparamref name="TLevel"/>类型的)
/// </summary>
/// <typeparam name="TLevel">提供的每层结点额外信息的类型</typeparam>
/// <param name="partialroot">需要遍历的子树的根</param>
/// <param name="seed">附加参数的初始值</param>
/// <param name="levelfunc">遍历到某一层结点时将附加参数传给下一层孩子时需要进行的操作。第一个参数是该层的附加参数，
/// 第二个参数是遍历到的结点，第三个是遍历到的结点在上层结点孩子结点中的编号</param>
/// <param name="order">多叉树遍历方式</param>
/// <returns>遍历得到的结点与附加参数的集合</returns>
public static IEnumerable <Tuple <IMultiwayTreeNode, TLevel> > TraverseSubtree <TLevel>(
this IMultiwayTreeNode partialroot,
TLevel seed,
Func <TLevel, IMultiwayTreeNode, int, TLevel> levelfunc,
TraverseOrder order = TraverseOrder.LevelOrder)
{
Contract.Requires <ArgumentNullException>(partialroot != null);
Contract.Requires <NotSupportedException>(order != TraverseOrder.InOrder, "多叉树不支持中序遍历");
Contract.Ensures(Contract.Result <IEnumerable <Tuple <IMultiwayTreeNode, TLevel> > >() != null);
var current = new Tuple <IMultiwayTreeNode, TLevel>[] { new Tuple <IMultiwayTreeNode, TLevel>(partialroot, seed) };
switch (order)
{
case TraverseOrder.PreOrder:
return(current.Concat(partialroot.Children?
.SelectMany((node, index) => node?.TraverseSubtree(
levelfunc == null ? seed : levelfunc(seed, partialroot, index), levelfunc, order)
?? Enumerable.Empty <Tuple <IMultiwayTreeNode, TLevel> >())
?? Enumerable.Empty <Tuple <IMultiwayTreeNode, TLevel> >()));
case TraverseOrder.PostOrder:
return((partialroot.Children?
.SelectMany((node, index) => node?.TraverseSubtree(
levelfunc == null ? seed : levelfunc(seed, partialroot, index), levelfunc, order)
?? Enumerable.Empty <Tuple <IMultiwayTreeNode, TLevel> >())
?? Enumerable.Empty <Tuple <IMultiwayTreeNode, TLevel> >())
.Reverse().Concat(current));
case TraverseOrder.LevelOrder:
return(LevelOrderTraverse(partialroot, seed, levelfunc));
default:
return(null);
}
}
public static int GetDegree(this IMultiwayTreeNode node)
{
Contract.Requires <ArgumentNullException>(node == null);
Contract.Ensures(Contract.Result <int>() >= 0);
return(node.Children?.Count(cnode => SentinelEx.NotEqualNull(cnode)) ?? 0);
}
public virtual IList <ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
{
Contract.Ensures(Contract.Result <IList <ClassificationSpan> >() != null);
Span requestedSpan = span;
AdjustParseSpan(ref span);
ICharStream input = CreateInputStream(span);
ITokenSource lexer = CreateLexer(input);
List <ClassificationSpan> classificationSpans = new List <ClassificationSpan>();
IToken previousToken = null;
bool previousTokenEndsLine = false;
/* this is held outside the loop because only tokens which end at the end of a line
* impact its value.
*/
bool lineStateChanged = false;
int extendMultilineSpanToLine = 0;
SnapshotSpan extendedSpan = span;
bool spanExtended = false;
while (true)
{
IToken token = lexer.NextToken();
bool inBounds = token.StartIndex < span.End.Position;
int startLineCurrent;
if (token.Type == CharStreamConstants.EndOfFile)
{
startLineCurrent = span.Snapshot.LineCount;
}
else
{
startLineCurrent = token.Line;
}
if (previousToken == null || previousToken.Line < startLineCurrent - 1)
{
// endLinePrevious is the line number the previous token ended on
int endLinePrevious;
if (previousToken != null)
{
endLinePrevious = span.Snapshot.GetLineNumberFromPosition(previousToken.StopIndex + 1);
}
else
{
endLinePrevious = span.Snapshot.GetLineNumberFromPosition(span.Start) - 1;
}
if (startLineCurrent > endLinePrevious + 1)
{
int firstMultilineLine = endLinePrevious;
if (previousToken == null || previousTokenEndsLine)
{
firstMultilineLine++;
}
for (int i = firstMultilineLine; i < startLineCurrent; i++)
{
if (!_lineStates[i].MultilineToken || lineStateChanged)
{
extendMultilineSpanToLine = i + 1;
}
if (inBounds)
{
SetLineState(i, LineStateInfo.Multiline);
}
}
}
}
if (token.Type == CharStreamConstants.EndOfFile)
{
break;
}
previousToken = token;
previousTokenEndsLine = TokenEndsAtEndOfLine(span.Snapshot, lexer, token);
if (IsMultilineToken(span.Snapshot, lexer, token))
{
int startLine = span.Snapshot.GetLineNumberFromPosition(token.StartIndex);
int stopLine = span.Snapshot.GetLineNumberFromPosition(token.StopIndex + 1);
for (int i = startLine; i < stopLine; i++)
{
if (!_lineStates[i].MultilineToken)
{
extendMultilineSpanToLine = i + 1;
}
if (inBounds)
{
SetLineState(i, LineStateInfo.Multiline);
}
}
}
bool tokenEndsLine = previousTokenEndsLine;
if (tokenEndsLine)
{
int line = span.Snapshot.GetLineNumberFromPosition(token.StopIndex + 1);
lineStateChanged = _lineStates[line].MultilineToken;
// even if the state didn't change, we call SetLineState to make sure the _first/_lastChangedLine values get updated.
if (inBounds)
{
SetLineState(line, new LineStateInfo());
}
if (lineStateChanged)
{
if (line < span.Snapshot.LineCount - 1)
{
/* update the span's end position or the line state change won't be reflected
* in the editor
*/
int endPosition = span.Snapshot.GetLineFromLineNumber(line + 1).EndIncludingLineBreak;
if (endPosition > extendedSpan.End)
{
spanExtended = true;
extendedSpan = new SnapshotSpan(extendedSpan.Snapshot, Span.FromBounds(extendedSpan.Start, endPosition));
}
}
}
}
if (token.StartIndex >= span.End.Position)
{
break;
}
if (token.StopIndex < requestedSpan.Start)
{
continue;
}
var tokenClassificationSpans = GetClassificationSpansForToken(token, span.Snapshot);
if (tokenClassificationSpans != null)
{
classificationSpans.AddRange(tokenClassificationSpans);
}
if (!inBounds)
{
break;
}
}
if (extendMultilineSpanToLine > 0)
{
int endPosition = extendMultilineSpanToLine < span.Snapshot.LineCount ? span.Snapshot.GetLineFromLineNumber(extendMultilineSpanToLine).EndIncludingLineBreak : span.Snapshot.Length;
if (endPosition > extendedSpan.End)
{
spanExtended = true;
extendedSpan = new SnapshotSpan(extendedSpan.Snapshot, Span.FromBounds(extendedSpan.Start, endPosition));
}
}
if (spanExtended)
{
/* Subtract 1 from each of these because the spans include the line break on their last
* line, forcing it to appear as the first position on the following line.
*/
int firstLine = extendedSpan.Snapshot.GetLineNumberFromPosition(span.End);
int lastLine = extendedSpan.Snapshot.GetLineNumberFromPosition(extendedSpan.End) - 1;
ForceReclassifyLines(firstLine, lastLine);
}
return(classificationSpans);
}
