C# Tree.ValueAt方法代码示例

 static void Execute(CellProcessor processor, object facility, Tree<Cell> currentRow) {
     var selector = new DoRowSelector();
     var result = processor.ExecuteWithThrow(facility, selector.SelectMethodCells(currentRow),
                                             selector.SelectParameterCells(currentRow),
                                             currentRow.ValueAt(0));
     if (result.IsVoid) return;
     currentRow.ValueAt(0).SetAttribute(CellAttribute.Folded, result.ValueString);
 }

 protected override Tree<string> ExecuteOperation(Tree<string> parameters) {
     var singleSymbol = Processor.LoadSymbol(parameters.ValueAt(3));
     var newInstance = singleSymbol.IsObject
         ? singleSymbol
         : CreateInstance(parameters);
     var name = parameters.ValueAt(2); 
     Processor.Get<SavedInstances>().Save(name, newInstance.Value);
     if (name.StartsWith("library")) {
         Processor.PushLibraryInstance(newInstance);
     }
     return DefaultResult(parameters);
 }

 void InterpretTable(Tree<Cell> table) {
     var heading = table.ValueAt(0, 0);
     if (heading == null || processor.TestStatus.IsAbandoned) return;
     new InterpretFlow(processor, flowFixture)
         .OnNewFixture(IsNewFlowFixture)
         .DoTableFlow(table, 0);
 }

 static void ValidateTree(Tree<string> result, IList<object> results) {
     Assert.AreEqual(results.Count, result.Branches.Count);
     for (var i = 0; i < results.Count; i++) {
         var itemList = results[i] as IList<object>;
         if (itemList == null) Assert.AreEqual(results[i], result.ValueAt(i));
         else ValidateTree(result.Branches[i], itemList);
     }
 }

        public void Interpret(CellProcessor processor, Tree<Cell> table)
        {
            processor.TestStatus.TableCount--;

            var facility = processorIdentifier.Matches(table.ValueAt(0, 1).Text)
                ? processor
                : processor.Memory.GetItem(table.ValueAt(0, 1).Text);

            if (table.Branches[0].Branches.Count > 2) {
                var currentRow = table.Branches[0].Skip(2);
                Execute(processor, facility, currentRow);
            }

            new Traverse<Cell>()
                .Rows.All(row => Execute(processor, facility, row))
                .VisitTable(table);
        }

 public void Interpret(CellProcessor processor, Tree<Cell> table) {
     var action = new IncludeAction(processor);
     var currentRow = table.Branches[0].Skip(1);
     var selector = new SequenceRowSelector();
     processor.ExecuteWithThrow(action, selector.SelectMethodCells(currentRow),
                                                             selector.SelectParameterCells(currentRow),
                                                             currentRow.ValueAt(0));
     table.ValueAt(0, 0).SetAttribute(CellAttribute.Folded, action.Result);
 }

 public static object ExecuteFlowRowMethod(this FlowInterpreter interpreter, CellProcessor processor, Tree<Cell> row) {
     try {
         var cells = row.Skip(1);
         return
             processor.ExecuteWithThrow(interpreter,
                     interpreter.MethodRowSelector.SelectMethodCells(cells),
                     interpreter.MethodRowSelector.SelectParameterCells(cells),
                     row.ValueAt(1)).
                 Value;
     }
     catch (ParseException<Cell> e) {
         processor.TestStatus.MarkException(e.Subject, e.InnerException);
         throw new IgnoredException();
     }
 }

        public bool MarkCell(IEnumerable<object> actualValues, Tree<Cell> table, int rowsToSkip) {
            var actuals = new Actuals(actualValues);
            if (table.Branches.Count == rowsToSkip + 1 && actuals.UnmatchedCount == 0) {
                processor.TestStatus.MarkRight(table.ValueAt(rowsToSkip));
            }

            if (!FindMatches(table.Branches.Skip(rowsToSkip + 1), actuals)) return false;

            var rowCountBeforeSurplus = table.Branches.Count - rowsToSkip - 1;
            var result = true;

            if (actuals.UnmatchedCount > 0 && !strategy.SurplusAllowed) {
                actuals.ForSurplusValues(surplus => AddSurplusRow(surplus, table));
                result = false;
            }

            if (!MarkRows(table.Branches.Skip(rowsToSkip + 1).Take(rowCountBeforeSurplus), actuals)) result = false;

            return strategy.FinalCheck(processor.TestStatus) && result;
        }

 public InstructionException(Tree<string> instruction)
     : base(string.Format("Unrecognized operation '{0}'", instruction.ValueAt(1))) {
     Instruction = instruction;
 }

 public MethodPhrase(Tree<Cell> theCells) {
     cells = theCells;
     keyword = cells.ValueAt(0).Text;
 }

 protected override Tree<string> ExecuteOperation(Tree<string> parameters) {
     TypedValue result = InvokeMember(parameters, 3);
     Processor.Get<Symbols>().Save(parameters.ValueAt(2), result.Value);
     return Result(parameters, Processor.Compose(result));
 }

 protected override Tree<string> ExecuteOperation(Tree<string> parameters)
 {
     Processor.Get<Symbols>().Save(parameters.ValueAt(2), parameters.ValueAt(3));
     return DefaultResult(parameters);
 }

 void ProcessRestOfTable(Interpreter childInterpreter, Tree<Cell> theRestOfTheRows, bool isFlow)
 {
     processor.CallStack.Push();
     processor.CallStack.DomainAdapter = new TypedValue(interpreter);
     try {
         DoTable(theRestOfTheRows, childInterpreter, isFlow);
     }
     catch (System.Exception e) {
         processor.TestStatus.MarkException(theRestOfTheRows.ValueAt(0, 0), e);
     }
     processor.CallStack.PopReturn();
     hasFinishedTable = true;
 }

 static void Execute(CellProcessor processor, object facility, Tree<Cell> currentRow)
 {
     var result = currentRow.ExecuteMethod(processor, new DoRowSelector(), facility).ThrowExceptionIfNotValid();
     if (result.IsVoid) return;
     currentRow.ValueAt(0).SetAttribute(CellAttribute.Folded, result.ValueString);
 }

 protected override Tree<string> ExecuteOperation(Tree<string> parameters) {
     Processor.AddNamespace(parameters.ValueAt(2));
     return DefaultResult(parameters);
 }