public static void report(StringWriter output, IList<Machine> machines, Robot robot) { output.Write("<h1>FACTORY REPORT</h1>\n"); IEnumerator<Machine> line = machines.GetEnumerator(); while (line.MoveNext()) { Machine machine = line.Current; output.Write("<h2>" + machine.Name() + "</h2>\n"); output.Write("<ul>\n"); output.Write("<li>location = " + machine.Location() + "</li>\n"); if (machine.Bin() != null) output.Write("<li>bin containing " + machine.Bin() + "</li>\n"); else output.Write("<li>no bin</li>\n"); output.Write("</ul>\n"); } output.Write("<h2>Robot</h2>\n<ul>\n"); if (robot.Location() != null) output.Write("<li>location = " + robot.Location().Name() + "</li>\n"); if (robot.Bin() != null) output.Write("<li>bin containing " + robot.Bin() + "</li>\n"); output.Write("</ul>\n"); }
/// <summary> /// Simplify a collection of <c>TaggedLineString</c>s. /// </summary> /// <param name="taggedLines">The collection of lines to simplify.</param> public virtual void Simplify(IList taggedLines) { for (IEnumerator i = taggedLines.GetEnumerator(); i.MoveNext(); ) _inputIndex.Add((TaggedLineString)i.Current); for (IEnumerator i = taggedLines.GetEnumerator(); i.MoveNext(); ) { TaggedLineStringSimplifier tlss = new TaggedLineStringSimplifier(_inputIndex, _outputIndex); tlss.DistanceTolerance = _distanceTolerance; tlss.Simplify((TaggedLineString)i.Current); } }
/// <summary> /// /// </summary> /// <param name="edges"></param> /// <param name="si"></param> /// <param name="testAllSegments"></param> public override void ComputeIntersections(IList edges, SegmentIntersector si, bool testAllSegments) { for (IEnumerator i0 = edges.GetEnumerator(); i0.MoveNext(); ) { Edge edge0 = (Edge)i0.Current; for (IEnumerator i1 = edges.GetEnumerator(); i1.MoveNext(); ) { Edge edge1 = (Edge)i1.Current; if (testAllSegments || edge0 != edge1) ComputeIntersects(edge0, edge1, si); } } }
protected override void PerformOperations(IList<IAccount> selectedAccs) { // Decides about to perform a write or read operation. int res = rnd.Next(100); if (res < UpdatesTax) { WriteOperations(selectedAccs.GetEnumerator()); nrOfWriteIterations++; } else { int totalBal = ReadOperations(selectedAccs.GetEnumerator()); int avgBal = totalBal / selectedAccs.Count; if (avgBal > maxAvgBalance) maxAvgBalance = avgBal; nrOfReadIterations++; } }
public static IList<CommandArgument> Load(IList<string> arguments) { var ret = new List<CommandArgument>(); var enumerator = arguments.GetEnumerator(); if (!enumerator.MoveNext()) return ret; while (true) { if (enumerator.Current.StartsWith("-")) { var argument = enumerator.Current.Substring(1); bool hasNext = enumerator.MoveNext(); string value = hasNext && !enumerator.Current.StartsWith("-") ? enumerator.Current : null; ret.Add(new CommandArgument { Argument = argument, Value = value }); if (hasNext && enumerator.Current.StartsWith("-")) //Skip movenext continue; } else { ret.Add(new CommandArgument { Value = enumerator.Current }); } if (!enumerator.MoveNext()) break; } return ret; }
/// <summary> /// /// </summary> /// <param name="dirEdgeList"></param> public void FindEdge(IList dirEdgeList) { /* * Check all forward DirectedEdges only. This is still general, * because each edge has a forward DirectedEdge. */ for (IEnumerator i = dirEdgeList.GetEnumerator(); i.MoveNext(); ) { DirectedEdge de = (DirectedEdge) i.Current; if (!de.IsForward) continue; CheckForRightmostCoordinate(de); } /* * If the rightmost point is a node, we need to identify which of * the incident edges is rightmost. */ Assert.IsTrue(minIndex != 0 || minCoord.Equals(minDe.Coordinate), "inconsistency in rightmost processing"); if (minIndex == 0) FindRightmostEdgeAtNode(); else FindRightmostEdgeAtVertex(); /* * now check that the extreme side is the R side. * If not, use the sym instead. */ orientedDe = minDe; Positions rightmostSide = GetRightmostSide(minDe, minIndex); if (rightmostSide == Positions.Left) orientedDe = minDe.Sym; }
/// <summary> /// Find the innermost enclosing shell EdgeRing containing the argument EdgeRing, if any. /// The innermost enclosing ring is the <i>smallest</i> enclosing ring. /// The algorithm used depends on the fact that: /// ring A contains ring B iff envelope(ring A) contains envelope(ring B). /// This routine is only safe to use if the chosen point of the hole /// is known to be properly contained in a shell /// (which is guaranteed to be the case if the hole does not touch its shell). /// </summary> /// <param name="shellList"></param> /// <param name="testEr"></param> /// <returns>Containing EdgeRing, if there is one, OR /// null if no containing EdgeRing is found.</returns> public static EdgeRing FindEdgeRingContaining(EdgeRing testEr, IList shellList) { ILinearRing teString = testEr.Ring; IEnvelope testEnv = teString.EnvelopeInternal; EdgeRing minShell = null; IEnvelope minEnv = null; for (IEnumerator it = shellList.GetEnumerator(); it.MoveNext(); ) { EdgeRing tryShell = (EdgeRing) it.Current; ILinearRing tryRing = tryShell.Ring; IEnvelope tryEnv = tryRing.EnvelopeInternal; if (minShell != null) minEnv = minShell.Ring.EnvelopeInternal; bool isContained = false; // the hole envelope cannot equal the shell envelope if (tryEnv.Equals(testEnv)) continue; // ICoordinate testPt = PointNotInList(teString.Coordinates, tryRing.Coordinates); ICoordinate testPt = CoordinateArrays.PointNotInList(teString.Coordinates, tryRing.Coordinates); if (tryEnv.Contains(testEnv) && CGAlgorithms.IsPointInRing(testPt, tryRing.Coordinates)) isContained = true; // check if this new containing ring is smaller than the current minimum ring if (isContained) { if (minShell == null || minEnv.Contains(tryEnv)) minShell = tryShell; } } return minShell; }
/// <summary> /// Returns a List containing the parent Edge (possibly null) for each of the given /// DirectedEdges. /// </summary> /// <param name="dirEdges"></param> /// <returns></returns> public static IList ToEdges(IList dirEdges) { IList edges = new ArrayList(); for (IEnumerator i = dirEdges.GetEnumerator(); i.MoveNext(); ) edges.Add(((DirectedEdge) i.Current).parentEdge); return edges; }
private void StoreAll(IList expected) { for (IEnumerator objIter = expected.GetEnumerator(); objIter.MoveNext(); ) { object obj = objIter.Current; } }
/// <summary> /// Initializes a new instance of the <see cref="SmallBlockTableWriter"/> class. /// </summary> /// <param name="documents">a IList of POIFSDocument instances</param> /// <param name="root">the Filesystem's root property</param> public SmallBlockTableWriter(POIFSBigBlockSize bigBlockSize, IList documents, RootProperty root) { _sbat = new BlockAllocationTableWriter(bigBlockSize); _small_blocks = new ArrayList(); _root = root; IEnumerator iter = documents.GetEnumerator(); while (iter.MoveNext()) { POIFSDocument doc = ( POIFSDocument ) iter.Current; BlockWritable[] blocks = doc.SmallBlocks; if (blocks.Length != 0) { doc.StartBlock=_sbat.AllocateSpace(blocks.Length); for (int j = 0; j < blocks.Length; j++) { _small_blocks.Add(blocks[ j ]); } } else { doc.StartBlock=POIFSConstants.END_OF_CHAIN; } } _sbat.SimpleCreateBlocks(); _root.Size=_small_blocks.Count; _big_block_count = SmallDocumentBlock.Fill(bigBlockSize, _small_blocks); }
public ListEnumerator(IList list, int offset) { this.original = list; this.enumerator = list.GetEnumerator(); this.offset = offset; this.AdjustOffset(); }
public NumericRange(IList<double> values) { double num3; double num4; double current; Func<double, double> selector = null; double num = 0.0; double num2 = 0.0; goto Label_016A; Label_00F1: using (IEnumerator<double> enumerator = values.GetEnumerator()) { goto Label_011B; Label_00FB: if ((((uint) current) - ((uint) num)) > uint.MaxValue) { goto Label_0142; } num4 += current * current; Label_011B: if (!enumerator.MoveNext()) { goto Label_0157; } current = enumerator.Current; num = Math.Max(num, current); num2 = Math.Min(num2, current); Label_0142: num3 += current; goto Label_00FB; } Label_0157: this._xdc8f3f8857bee4c6 = values.Count; this._x628ea9b89457a2a9 = num; this._xd12d1dba8a023d95 = num2; this._x0eb49ee242305597 = num3 / ((double) this._xdc8f3f8857bee4c6); this._xcce91100698a4514 = Math.Sqrt(num4 / ((double) this._xdc8f3f8857bee4c6)); if (((((uint) num2) & 0) != 0) || ((((uint) num2) + ((uint) current)) >= 0)) { if (selector == null) { selector = new Func<double, double>(this, (IntPtr) this.xf29670e286f5562f); } double num6 = values.Sum<double>(selector); this._x8db8a12c7e795fea = Math.Sqrt(num6 / ((double) this._xdc8f3f8857bee4c6)); if ((((uint) current) + ((uint) num4)) > uint.MaxValue) { goto Label_00F1; } if ((((uint) num6) - ((uint) current)) <= uint.MaxValue) { return; } } Label_016A: num3 = 0.0; num4 = 0.0; goto Label_00F1; }
/// <summary> /// /// </summary> /// <param name="lineList"></param> /// <param name="leftLoc"></param> /// <param name="rightLoc"></param> private void AddCurves(IList lineList, Locations leftLoc, Locations rightLoc) { for (IEnumerator i = lineList.GetEnumerator(); i.MoveNext(); ) { ICoordinate[] coords = (ICoordinate[]) i.Current; AddCurve(coords, leftLoc, rightLoc); } }
/// <summary> /// For nodes in the Collection, link the DirectedEdges at the node that are in the result. /// This allows clients to link only a subset of nodes in the graph, for /// efficiency (because they know that only a subset is of interest). /// </summary> /// <param name="nodes"></param> public static void LinkResultDirectedEdges(IList nodes) { for (IEnumerator nodeit = nodes.GetEnumerator(); nodeit.MoveNext(); ) { Node node = (Node) nodeit.Current; ((DirectedEdgeStar) node.Edges).LinkResultDirectedEdges(); } }
/// <summary> /// Add a collection of geometries to be polygonized. /// May be called multiple times. /// Any dimension of Geometry may be added; /// the constituent linework will be extracted and used. /// </summary> /// <param name="geomList">A list of <c>Geometry</c>s with linework to be polygonized.</param> public virtual void Add(IList geomList) { for (IEnumerator i = geomList.GetEnumerator(); i.MoveNext(); ) { Geometry geometry = (Geometry) i.Current; Add(geometry); } }
/// <summary> /// /// </summary> /// <param name="edges"></param> /// <param name="edgeSet"></param> private void Add(IList edges, object edgeSet) { for (IEnumerator i = edges.GetEnumerator(); i.MoveNext(); ) { Edge edge = (Edge) i.Current; Add(edge, edgeSet); } }
public PredictiveMaintenanceTelemetry(IConfigurationProvider config, ILogger logger, string deviceId, IList<ExpandoObject> dataset) { _config = config; _logger = logger; _deviceId = deviceId; _active = false; _data = dataset.GetEnumerator(); }
private void Apply(IList toFree) { for (var slotIter = toFree.GetEnumerator(); slotIter.MoveNext();) { var slot = ((Slot) slotIter.Current); _freespaceManager.Free(slot); } toFree.Clear(); }
private void WriteIds(ByteArrayBuffer buffer, IList ids) { buffer.WriteInt(ids.Count); for (IEnumerator idIter = ids.GetEnumerator(); idIter.MoveNext(); ) { int id = ((int)idIter.Current); buffer.WriteInt(id); } }
public async Task LoadAsync() { questions = await LanguageQuestion.LoadAsync(); JoinAllAnswers(); Debug.WriteLine(questions.Count); enumerator = questions.GetEnumerator(); enumerator.MoveNext(); // TODO: Assert. }
/// <summary> /// /// </summary> /// <param name="edges"></param> private void Add(IList edges) { for (IEnumerator i = edges.GetEnumerator(); i.MoveNext(); ) { Edge edge = (Edge) i.Current; // edge is its own group Add(edge, edge); } }
public TestRunner (IList tests, string working_dir, Driver driver) { this.driver = driver; this.tests = tests; this.working_dir = working_dir; tests_enumerator = tests.GetEnumerator (); tests_lock = new object (); }
/// <summary> /// Adds a collection of Geometries to be processed. May be called multiple times. /// Any dimension of Geometry may be added; the constituent linework will be /// extracted. /// </summary> /// <param name="geometries"></param> public void Add(IList geometries) { IEnumerator i = geometries.GetEnumerator(); while (i.MoveNext()) { IGeometry geometry = (IGeometry) i.Current; Add(geometry); } }
public static IList<int> AddList(IList<int> list1, IList<int> list2) { IList<int> temp = NewList(); IEnumerator<int> iter1 = list1.GetEnumerator(); IEnumerator<int> iter2 = list2.GetEnumerator(); while(iter1.MoveNext() != false){ iter2.MoveNext(); temp.Add(iter1.Current + iter2.Current); } return temp; }
/// <summary> /// /// </summary> /// <param name="edges"></param> /// <returns></returns> private static IList ToSegmentStrings(IList edges) { // convert Edges to SegmentStrings IList segStrings = new ArrayList(); for (IEnumerator i = edges.GetEnumerator(); i.MoveNext(); ) { Edge e = (Edge)i.Current; segStrings.Add(new SegmentString(e.Coordinates, e)); } return segStrings; }
/// <summary> /// /// </summary> /// <param name="seq"></param> /// <param name="lines"></param> /// <returns></returns> public bool HasIntersectionWithLineStrings(ICoordinateSequence seq, IList lines) { for (IEnumerator i = lines.GetEnumerator(); i.MoveNext(); ) { ILineString line = (ILineString) i.Current; HasIntersection(seq, line.CoordinateSequence); if (hasIntersection) break; } return hasIntersection; }
public FieldAndTermEnumAnonymousInnerClassHelper(List<Term> terms) { if (!terms.Any()) { throw new ArgumentException("no terms provided"); } this.terms = terms; terms.Sort(); iter = terms.GetEnumerator(); }
/// <summary> /// /// </summary> /// <param name="seq"></param> /// <param name="lines"></param> /// <returns></returns> public bool HasIntersectionWithLineStrings(IList<Coordinate> seq, IList lines) { for (IEnumerator i = lines.GetEnumerator(); i.MoveNext(); ) { LineString line = (LineString)i.Current; HasIntersection(seq, line.Coordinates); if (_hasIntersection) break; } return _hasIntersection; }
public AssemblyBundle(IList assemblyList) { this.assemblies = new ArrayList(); IEnumerator iAssemblies = assemblyList.GetEnumerator(); while (iAssemblies.MoveNext()) { AssemblyDefinition dfn = AssemblyFactory.GetAssembly((String)iAssemblies.Current); IAssembly assembly = new CompleteAssembly(dfn); //Console.WriteLine("ASSEMBLY: " + assembly.getAssemblyName() + " " + dfn.GetType()); this.assemblies.Add(assembly); } this.buildRelationships(); }
public static Task <AccountProperties> GetDatabaseAccountFromAnyLocationsAsync( Uri defaultEndpoint, IList <string>?locations, Func <Uri, Task <AccountProperties> > getDatabaseAccountFn) { GetAccountPropertiesHelper threadSafeGetAccountHelper = new GetAccountPropertiesHelper( defaultEndpoint, locations?.GetEnumerator(), getDatabaseAccountFn); return(threadSafeGetAccountHelper.GetAccountPropertiesAsync()); }
/// <summary> /// /// </summary> /// <param name="edges0"></param> /// <param name="edges1"></param> /// <param name="si"></param> public override void ComputeIntersections(IList edges0, IList edges1, SegmentIntersector si) { for (IEnumerator i0 = edges0.GetEnumerator(); i0.MoveNext(); ) { Edge edge0 = (Edge)i0.Current; for (IEnumerator i1 = edges1.GetEnumerator(); i1.MoveNext(); ) { Edge edge1 = (Edge)i1.Current; ComputeIntersects(edge0, edge1, si); } } }
public virtual IEnumerator GetEnumerator() { return(seq.GetEnumerator()); }
public IEnumerator <List <int> > GetEnumerator() { return(_data.GetEnumerator()); }
public IEnumerator <ReadOnlyMemory <byte> > GetEnumerator() { return(_segments?.GetEnumerator() ?? _lazySegments.GetEnumerator()); }
/// <inheritdoc/> public IEnumerator <T> GetEnumerator() { theLock.EnterWriteLock(); try { return(list.GetEnumerator()); } finally { theLock.ExitWriteLock(); } }
/// <devdoc> /// <para>Creates and retrieves a new enumerator for this collection.</para> /// </devdoc> public IEnumerator GetEnumerator() { return(designers.GetEnumerator()); }
public IEnumerator <TValue> GetEnumerator() => _list?.GetEnumerator() ?? EmptyValues.GetEnumerator();
public IEnumerator <TEntity> GetEnumerator() { return(_copyEntities.GetEnumerator()); }
public IEnumerator <SymbolicValue> GetEnumerator() { return(_slots.GetEnumerator()); }
IEnumerator <ExecutionTreeNode> IEnumerable <ExecutionTreeNode> .GetEnumerator() { return(children?.GetEnumerator()); }
/// <summary> /// Gets an <see cref="IEnumerator{T}"/> for the list. /// </summary> public IEnumerator <T> GetEnumerator() { return(new TypeSafeEnumeratorWrapper <T>(_inner.GetEnumerator())); }
/// <summary> /// Produces an enumerator for the segments of the message body. /// </summary> /// /// <returns>An enumerator that can be used to iterate through the segments of the message body.</returns> /// public override IEnumerator <ReadOnlyMemory <byte> > GetEnumerator() => _segments?.GetEnumerator() ?? _lazySegments.GetEnumerator();
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return(attributes.GetEnumerator()); }
public IEnumerator <KeyValuePair <string, string> > GetEnumerator() { return(_params.GetEnumerator()); }
public override IEnumerator <IModelItem> getChildrenIterator() { return(_content.GetEnumerator()); }
public IEnumerator <KeyValuePair <TKey, TValue> > GetEnumerator() { return(_keyValuePairs.GetEnumerator()); }
// IBindableIterable implementation: public IBindableIterator First() { IEnumerator enumerator = list.GetEnumerator(); return(new EnumeratorToIteratorAdapter <object>(new EnumerableToBindableIterableAdapter.NonGenericToGenericEnumerator(enumerator))); }
/// <summary> /// Returns an enumerator that iterates through the <see cref="termArrays"/> collection. /// </summary> /// <returns>An enumerator that can be used to iterate through the <see cref="termArrays"/> collection.</returns> // LUCENENET specific public IEnumerator <Term[]> GetEnumerator() { return(termArrays.GetEnumerator()); }
public IEnumerator <IArticleResultValues> GetEnumerator() { return(model.GetEnumerator()); }
public IEnumerator GetEnumerator() { return(_list?.GetEnumerator() ?? Array.Empty <object>().GetEnumerator()); }
public IEnumerator <T> GetEnumerator() { return(_configurations.GetEnumerator()); }
public IEnumerator <T> GetEnumerator() { return(_items.GetEnumerator()); }
public IEnumerator <IActionData> GetEnumerator() { return(data.GetEnumerator()); }
/// <summary/> public IEnumerator <TimedValue <TTime, TValue> > GetEnumerator() { return(mySet.GetEnumerator()); }
public IEnumerator GetEnumerator() => _list?.GetEnumerator() ?? Array.Empty <object>().GetEnumerator();
public IEnumerator GetEnumerator() { return(m_items.GetEnumerator()); }
public IEnumerator <T> GetEnumerator() { return(_list.GetEnumerator()); }
public IEnumerator <OpenerElement> GetEnumerator() { return(_targetBlankMimeTypeExtensions.GetEnumerator()); }
public IEnumerator <T> GetEnumerator() { return(list?.GetEnumerator() ?? EmptyEnumerator());
private void RunClause(Action <FunctionContext> clause, object dollarUnderbar, object inputToProcess) { ExecutionContext.CheckStackDepth(); _anyClauseExecuted = true; Pipe oldErrorOutputPipe = this.Context.ShellFunctionErrorOutputPipe; // If the script block has a different language mode than the current, // change the language mode. PSLanguageMode?oldLanguageMode = null; PSLanguageMode?newLanguageMode = null; if ((_scriptBlock.LanguageMode.HasValue) && (_scriptBlock.LanguageMode != Context.LanguageMode)) { oldLanguageMode = Context.LanguageMode; newLanguageMode = _scriptBlock.LanguageMode; } try { var oldScopeOrigin = this.Context.EngineSessionState.CurrentScope.ScopeOrigin; try { this.Context.EngineSessionState.CurrentScope.ScopeOrigin = this._dontUseScopeCommandOrigin ? CommandOrigin.Internal : this.Command.CommandOrigin; // Set the language mode. We do this before EnterScope(), so that the language // mode is appropriately applied for evaluation parameter defaults. if (newLanguageMode.HasValue) { Context.LanguageMode = newLanguageMode.Value; } bool?oldLangModeTransitionStatus = null; try { // If it's from ConstrainedLanguage to FullLanguage, indicate the transition before parameter binding takes place. if (oldLanguageMode == PSLanguageMode.ConstrainedLanguage && newLanguageMode == PSLanguageMode.FullLanguage) { oldLangModeTransitionStatus = Context.LanguageModeTransitionInParameterBinding; Context.LanguageModeTransitionInParameterBinding = true; } EnterScope(); } finally { if (oldLangModeTransitionStatus.HasValue) { // Revert the transition state to old value after doing the parameter binding Context.LanguageModeTransitionInParameterBinding = oldLangModeTransitionStatus.Value; } } if (commandRuntime.ErrorMergeTo == MshCommandRuntime.MergeDataStream.Output) { Context.RedirectErrorPipe(commandRuntime.OutputPipe); } else if (commandRuntime.ErrorOutputPipe.IsRedirected) { Context.RedirectErrorPipe(commandRuntime.ErrorOutputPipe); } if (dollarUnderbar != AutomationNull.Value) { _localsTuple.SetAutomaticVariable(AutomaticVariable.Underbar, dollarUnderbar, _context); } else if (_dollarUnderbar != AutomationNull.Value) { _localsTuple.SetAutomaticVariable(AutomaticVariable.Underbar, _dollarUnderbar, _context); } if (inputToProcess != AutomationNull.Value) { if (inputToProcess == null) { inputToProcess = MshCommandRuntime.StaticEmptyArray.GetEnumerator(); } else { IList list = inputToProcess as IList; inputToProcess = (list != null) ? list.GetEnumerator() : LanguagePrimitives.GetEnumerator(inputToProcess); } _localsTuple.SetAutomaticVariable(AutomaticVariable.Input, inputToProcess, _context); } clause(_functionContext); } catch (TargetInvocationException tie) { // DynamicInvoke wraps exceptions, unwrap them here. throw tie.InnerException; } finally { Context.ShellFunctionErrorOutputPipe = oldErrorOutputPipe; if (oldLanguageMode.HasValue) { Context.LanguageMode = oldLanguageMode.Value; } Context.EngineSessionState.CurrentScope.ScopeOrigin = oldScopeOrigin; } } catch (ExitException ee) { if (!this.FromScriptFile || _rethrowExitException) { throw; } this._exitWasCalled = true; int exitCode = (int)ee.Argument; this.Command.Context.SetVariable(SpecialVariables.LastExitCodeVarPath, exitCode); if (exitCode != 0) { this.commandRuntime.PipelineProcessor.ExecutionFailed = true; } } catch (FlowControlException) { throw; } catch (RuntimeException e) { // This method always throws. ManageScriptException(e); } catch (Exception e) { // This cmdlet threw an exception, so wrap it and bubble it up. throw ManageInvocationException(e); } }