public static List<object> ConvertGenericDictionaryToArray(DataContractJsonSerializer serializer, IEnumerable value, CollectionDataContract dataContract, XmlObjectSerializerWriteContextComplexJson context, bool writeServerType) { List<object> keyValuePair = new List<object>(); Dictionary<string, object> currentEntry; Type[] declaredTypes = dataContract.ItemType.GetGenericArguments(); MethodInfo getEnumeratorMethod = dataContract.GetEnumeratorMethod; IDictionaryEnumerator enumerator = (IDictionaryEnumerator)((getEnumeratorMethod == null) ? value.GetEnumerator() : (IDictionaryEnumerator)getEnumeratorMethod.Invoke(value, Array.Empty<Type>())); while (enumerator.MoveNext()) { DictionaryEntry current = enumerator.Entry; DataContract currentDataContract = DataContract.GetDataContract(enumerator.Current.GetType()); currentEntry = new Dictionary<string, object>(); if (writeServerType) { AddTypeInformation(currentEntry, currentDataContract); } context.PushKnownTypes(dataContract); AddDictionaryEntryData(serializer, currentEntry, writeServerType ? JsonGlobals.KeyString.ToLowerInvariant() : JsonGlobals.KeyString, declaredTypes[0], current.Key, context); AddDictionaryEntryData(serializer, currentEntry, writeServerType ? JsonGlobals.ValueString.ToLowerInvariant() : JsonGlobals.ValueString, declaredTypes[1], current.Value, context); keyValuePair.Add(currentEntry); context.PopKnownTypes(dataContract); } return keyValuePair; }
public static void M(IEnumerable<int> list) { foreach (var i in list) { Console.WriteLine(i); } { // C# 3.0 以前 var e = list.GetEnumerator(); using (e as IDisposable) { int i; // ループの外 while (e.MoveNext()) { i = e.Current; Console.WriteLine(i); } } } { // C# 4.0 以降 var e = list.GetEnumerator(); using (e as IDisposable) { while (e.MoveNext()) { var i = e.Current; // ループの中 Console.WriteLine(i); } } } }
public static Mock<EnvDTE.Commands> CreateCommands(IEnumerable<EnvDTE.Command> commands) { var mock = new Mock<EnvDTE.Commands>(MockBehavior.Strict); var enumMock = mock.As<IEnumerable>(); mock.Setup(x => x.GetEnumerator()).Returns(commands.GetEnumerator()); enumMock.Setup(x => x.GetEnumerator()).Returns(commands.GetEnumerator()); return mock; }
private Grid(int size, int fileLength, IEnumerable<Tuple<char, Position>> data = null) { Size = size; using (var e = data == null ? null : data.GetEnumerator()) _grid = Ut.NewArray(2 * size - 1, j => Ut.NewArray(2 * size - 1 - Math.Abs(size - 1 - j), i => e != null && e.MoveNext() ? e.Current.Item1 : '.')); _endPos = new Position(fileLength, 0); using (var e = data == null ? null : data.GetEnumerator()) _gridPositions = Ut.NewArray(2 * size - 1, j => Ut.NewArray(2 * size - 1 - Math.Abs(size - 1 - j), i => e != null && e.MoveNext() ? e.Current.Item2 : _endPos)); }
public static Type GetElementType(IEnumerable enumerable) { Type elementType = null; var enumerableType = enumerable.GetType(); do { if (enumerableType.IsGenericType) { var genericArguments = enumerableType.GetGenericArguments(); if (genericArguments.Length > 0) { elementType = genericArguments[0]; } } enumerableType = enumerableType.BaseType; } while (elementType == null && enumerableType != null); if (elementType == null) { var enumItems = enumerable.GetEnumerator(); if (enumItems.MoveNext()) { if (enumItems.Current != null) { elementType = enumItems.Current.GetType(); } } } return elementType; }
/// <summary> /// Estimates the unbiased population covariance from the provided two sample enumerable sequences, in a single pass without memoization. /// On a dataset of size N will use an N-1 normalizer (Bessel's correction). /// Returns NaN if data has less than two entries or if any entry is NaN. /// </summary> /// <param name="samples1">First sample stream.</param> /// <param name="samples2">Second sample stream.</param> public static double Covariance(IEnumerable<double> samples1, IEnumerable<double> samples2) { // https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance var n = 0; var mean1 = 0.0; var mean2 = 0.0; var comoment = 0.0; using (var s1 = samples1.GetEnumerator()) using (var s2 = samples2.GetEnumerator()) { while (s1.MoveNext()) { if (!s2.MoveNext()) { throw new ArgumentException(Resources.ArgumentVectorsSameLength); } var mean2Prev = mean2; n++; mean1 += (s1.Current - mean1)/n; mean2 += (s2.Current - mean2)/n; comoment += (s1.Current - mean1)*(s2.Current - mean2Prev); } if (s2.MoveNext()) { throw new ArgumentException(Resources.ArgumentVectorsSameLength); } } return n > 1 ? comoment/(n - 1) : double.NaN; }
/// <summary> /// /// </summary> /// <param name="lineList"></param> /// <param name="leftLoc"></param> /// <param name="rightLoc"></param> private void AddCurves(IEnumerable lineList, Locations leftLoc, Locations rightLoc) { for (IEnumerator i = lineList.GetEnumerator(); i.MoveNext(); ) { AddCurve(i.Current as IList<Coordinate>, leftLoc, rightLoc); } }
public static VisualizationNode ToTree(IEnumerable<XamlNode> xamlNodes) { var enumerator = xamlNodes.GetEnumerator(); var stack = new Stack<VisualizationNode>(); stack.Push(new VisualizationNode("Root")); while (enumerator.MoveNext()) { var current = enumerator.Current; if (LowersLevel(current)) { stack.Pop(); } else { var item = new VisualizationNode(current); stack.Peek().Children.Add(item); if (RaisesLevel(current)) { stack.Push(item); } } } return stack.Peek(); }
public static void AreInstanceOf(Type expectedType, IEnumerable values) { for (var i = values.GetEnumerator(); i.MoveNext();) { Assert.IsInstanceOf(expectedType, i.Current); } }
/// <summary/> public static void ArgumentNotNullOrEmpty(string argName, IEnumerable argValue) { ArgumentNotNull(argName, argValue); if (!argValue.GetEnumerator().MoveNext()) throw new ArgumentException("Argument was empty", argName); }
protected static Type GetType(IEnumerable records) { var enumerator = records.GetEnumerator(); if (!enumerator.MoveNext() || enumerator.Current == null) return typeof(object); return enumerator.Current.GetType(); }
internal MonetDbDataReader(IEnumerable<MonetDBQueryResponseInfo> ri, MonetDbConnection con) { _con = con; this.eri = ri; this.enum_ri = ri.GetEnumerator(); this.NextResult(); }
public static IEnumerable <T> Take <T>(this IEnumerable <T> source, int start, int length) { // C# dispose it, but ReSharper don't think so // ReSharper disable once GenericEnumeratorNotDisposed using var en = source?.GetEnumerator() ?? throw new ArgumentNullException(nameof(source)); for (int i = 0; i < start; ++i) { if (!en.MoveNext()) { yield break; } } for (int i = 0; i < length; ++i) { if (en.MoveNext()) { yield return(en.Current); } else { yield break; } } }
private static IEnumerable <Tuple <T1, T2> > ZipLongest <T1, T2>(IEnumerable <T1> src1, IEnumerable <T2> src2, T1 default1 = default(T1), T2 default2 = default(T2)) { using (var e1 = src1?.GetEnumerator()) using (var e2 = src2?.GetEnumerator()) { bool b1 = e1?.MoveNext() ?? false, b2 = e2?.MoveNext() ?? false; while (b1 && b2) { yield return(Tuple.Create(e1.Current, e2.Current)); b1 = e1.MoveNext(); b2 = e2.MoveNext(); } while (b1) { yield return(Tuple.Create(e1.Current, default2)); b1 = e1.MoveNext(); } while (b2) { yield return(Tuple.Create(default1, e2.Current)); b2 = e2.MoveNext(); } } }
protected static bool Any(IEnumerable enumerable) { var en = enumerable.GetEnumerator(); try { en.Reset(); } catch (NotImplementedException) { return en.Current != null; } return en.MoveNext(); }
/// <summary> /// Create scanner /// </summary> /// <param name="logger"></param> /// <param name="source"></param> /// <param name="target"></param> /// <param name="portProbe"></param> /// <param name="maxProbeCount"></param> /// <param name="minProbePercent"></param> /// <param name="timeout"></param> /// <param name="ct"></param> public PortScanner(ILogger logger, IEnumerable <IPEndPoint> source, Action <IPEndPoint> target, IPortProbe portProbe, int?maxProbeCount, int?minProbePercent, TimeSpan?timeout, CancellationToken ct) { _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _source = source?.GetEnumerator() ?? throw new ArgumentNullException(nameof(source)); _target = target ?? throw new ArgumentNullException(nameof(target)); _maxProbeCount = maxProbeCount ?? kDefaultMaxProbeCount; _minProbeCount = (int)(_maxProbeCount * ((minProbePercent ?? kDefaultMinProbePercent) / 100.0)); _timeout = timeout ?? kDefaultProbeTimeout; _portProbe = portProbe ?? new NullPortProbe(); _requeued = new ConcurrentQueue <IPEndPoint>(); _rand = new Random(); _probePool = LinqEx .Repeat(i => new ConnectProbe(this, i), _maxProbeCount) .ToList(); _cts = new CancellationTokenSource(); ct.Register(_cts.Cancel); _completion = new TaskCompletionSource <bool>(); _active = _maxProbeCount; foreach (var probe in _probePool) { probe.Start(); } }
private static IEnumerable<string> ZipFill(this IEnumerable<string> source1, IEnumerable<string> source2, Func<string, string, string> selector) { using (var enumerator1 = source1.GetEnumerator()) { using (var enumerator2 = source2.GetEnumerator()) { var has1 = enumerator1.MoveNext(); var has2 = enumerator2.MoveNext(); while (has1 || has2) { var value1 = has1 ? enumerator1.Current : null; var value2 = has2 ? enumerator2.Current : null; var value = selector(value1, value2); if (value != null) { yield return value; } if (has1) { has1 = enumerator1.MoveNext(); } if (has2) { has2 = enumerator2.MoveNext(); } } } } }
public static T FirstOr <T>(this IEnumerable <T> enumerable, T def) { var enumerator = enumerable?.GetEnumerator(); var exist = enumerator?.MoveNext() ?? false; return(exist ? enumerator.Current : def); }
public static IEnumerable ConvertGenericListToArray(DataContractJsonSerializer serializer, IEnumerable value, CollectionDataContract dataContract, XmlObjectSerializerWriteContextComplexJson context, bool writeServerType) { Type listArgumentType = dataContract.ItemType; if (listArgumentType.GetTypeInfo().IsGenericType) { listArgumentType = listArgumentType.GetGenericArguments()[0]; } List<object> serializedList = new List<object>(); MethodInfo getEnumeratorMethod = dataContract.GetEnumeratorMethod; IEnumerator enumerator = (getEnumeratorMethod == null) ? value.GetEnumerator() : (IEnumerator)getEnumeratorMethod.Invoke(value, Array.Empty<Type>()); while (enumerator.MoveNext()) { if (enumerator.Current == null || enumerator.Current.GetType().GetTypeInfo().IsPrimitive) { serializedList.Add(enumerator.Current); } else { Type currentItemType = enumerator.Current.GetType(); DataContract currentItemDataContract = DataContract.GetDataContract(currentItemType); bool emitTypeInformation = EmitTypeInformation(dataContract.ItemContract, currentItemType); if (writeServerType || emitTypeInformation) { context.CheckIfTypeNeedsVerifcation(dataContract.ItemContract, currentItemDataContract); } context.PushKnownTypes(dataContract); serializedList.Add(serializer.ConvertDataContractToObject(enumerator.Current, currentItemDataContract, context, (writeServerType || emitTypeInformation), dataContract.ItemType.TypeHandle)); context.PopKnownTypes(dataContract); } } return serializedList; }
public void Add(double startValue, IEnumerable<double> actualContinuation, IEnumerable<double> referenceContinuation, IEnumerable<double> predictedContinuation) { if (double.IsNaN(startValue) || (errorState & OnlineCalculatorError.InvalidValueAdded) > 0) { errorState = errorState | OnlineCalculatorError.InvalidValueAdded; } else { var actualEnumerator = actualContinuation.GetEnumerator(); var predictedEnumerator = predictedContinuation.GetEnumerator(); var referenceEnumerator = referenceContinuation.GetEnumerator(); while (actualEnumerator.MoveNext() & predictedEnumerator.MoveNext() & referenceEnumerator.MoveNext() & ErrorState != OnlineCalculatorError.InvalidValueAdded) { double actual = actualEnumerator.Current; double predicted = predictedEnumerator.Current; double reference = referenceEnumerator.Current; if (double.IsNaN(actual) || double.IsNaN(predicted) || double.IsNaN(reference)) { errorState = errorState | OnlineCalculatorError.InvalidValueAdded; } else { // error of predicted change double errorPredictedChange = (predicted - startValue) - (actual - startValue); squaredErrorMeanCalculator.Add(errorPredictedChange * errorPredictedChange); double errorReference = (reference - startValue) - (actual - startValue); unbiasedEstimatorMeanCalculator.Add(errorReference * errorReference); } } // check if both enumerators are at the end to make sure both enumerations have the same length if (actualEnumerator.MoveNext() || predictedEnumerator.MoveNext() || referenceEnumerator.MoveNext()) { errorState = errorState | OnlineCalculatorError.InvalidValueAdded; } else { errorState = errorState & (~OnlineCalculatorError.InsufficientElementsAdded); // n >= 1 } } }
/// <summary> /// Compares the order of using directives in two lists. Returns null if they are /// the same, and otherwise returns a description of the first element to move /// to bring the current order closer into line with the required order. /// </summary> /// <param name="requiredOrder">The order in which the directives should appear.</param> /// <param name="currentOrder">The order in which the directives currently appear.</param> /// <returns>Null if the orders match. Otherwise, a <see cref="Relocation"/> describing /// the first element to move to bring the order closer to the required one.</returns> /// <remarks> /// Code that simply needs to know whether the order is correct (e.g., when we want to /// highlight bad ordering) will just use this to get a yes/no answer. Code that wants /// to fix the order will call this repeatedly to generate a sequence of moves. /// </remarks> public static Relocation GetNextUsingToMove( IEnumerable<UsingDirective> requiredOrder, IEnumerable<UsingDirective> currentOrder) { int expectedIndex = 0; using (var reqIt = requiredOrder.GetEnumerator()) using (var currentIt = currentOrder.GetEnumerator()) { while (reqIt.MoveNext() && currentIt.MoveNext()) { UsingDirective expected = reqIt.Current; if (!ReferenceEquals(expected, currentIt.Current)) { int currentIndex = expectedIndex; while (currentIt.MoveNext()) { currentIndex += 1; if (ReferenceEquals(expected, currentIt.Current)) { return new Relocation(currentIndex, expectedIndex); } } throw new ArgumentException( "Lists should contain same items, but currentOrder was missing " + expected, "currentOrder"); } expectedIndex += 1; } } return null; }
public TaskRoutine CreateTask(IEnumerable task) { if (task == null) return null; return CreateTask(task.GetEnumerator()); }
public DataReader(string[] columnNames, IEnumerable <object[]> values, IEnumerable <Tuple <string[], IEnumerable <object[]> > > resultSets = null) { _columnNames = columnNames; _values = values; _current = _values.GetEnumerator(); _resultSets = resultSets?.GetEnumerator(); }
public void RunManaged(IEnumerable task) { if (task == null) return; RunManaged(task.GetEnumerator()); }
public void Add(double startValue, IEnumerable<double> actualContinuation, IEnumerable<double> predictedContinuation) { if (double.IsNaN(startValue) || (errorState & OnlineCalculatorError.InvalidValueAdded) > 0) { errorState = errorState | OnlineCalculatorError.InvalidValueAdded; } else { var actualEnumerator = actualContinuation.GetEnumerator(); var predictedEnumerator = predictedContinuation.GetEnumerator(); while (actualEnumerator.MoveNext() & predictedEnumerator.MoveNext() & errorState != OnlineCalculatorError.InvalidValueAdded) { double actual = actualEnumerator.Current; double predicted = predictedEnumerator.Current; if (double.IsNaN(actual) || double.IsNaN(predicted)) { errorState = errorState | OnlineCalculatorError.InvalidValueAdded; } else { double err = Math.Abs(actual - predicted); // count as correct only if the trend (positive/negative/no change) is predicted correctly if ((actual - startValue) * (predicted - startValue) > 0.0 || (actual - startValue).IsAlmost(predicted - startValue)) { correctSum += err; } else { incorrectSum += err; } n++; } } // check if both enumerators are at the end to make sure both enumerations have the same length if (actualEnumerator.MoveNext() || predictedEnumerator.MoveNext()) { errorState = errorState | OnlineCalculatorError.InvalidValueAdded; } else { errorState = errorState & (~OnlineCalculatorError.InsufficientElementsAdded); // n >= 1 } } }
public ImportExcelFileDialog(IEnumerable<string> names) { bool flag; this.InitializeComponent(); using (IEnumerator<string> enumerator = names.GetEnumerator()) { string str; goto Label_0055; Label_0037: str = enumerator.Current; this.cbDataSets.Items.Add(str); if (0 != 0) { goto Label_0037; } Label_0055: if (enumerator.MoveNext()) { goto Label_0037; } goto Label_0086; } if (((uint) flag) <= uint.MaxValue) { goto Label_0086; } Label_000A: this.cbDataSets.SelectedIndex = 0; return; Label_0086: if (names.Count<string>() > 0) { goto Label_000A; } }
static IEnumerable <TResult> EquiZipImpl <T1, T2, T3, T4, TResult>( IEnumerable <T1> first, IEnumerable <T2> second, IEnumerable <T3> third, IEnumerable <T4> fourth, Func <T1, T2, T3, T4, TResult> resultSelector) { using (var e1 = first.GetEnumerator()) using (var e2 = second.GetEnumerator()) using (var e3 = third?.GetEnumerator()) using (var e4 = fourth?.GetEnumerator()) { while (e1.MoveNext()) { bool m2, m3 = false; if ((m2 = e2.MoveNext()) && (m3 = (e3 == null || e3.MoveNext())) && ((e4 == null || e4.MoveNext()))) { yield return(resultSelector(e1.Current, e2.Current, e3 != null ? e3.Current : default(T3), e4 != null ? e4.Current : default(T4))); } else { var message = string.Format("{0} sequence too short.", !m2 ? "Second" : !m3 ? "Third" : "Fourth"); throw new InvalidOperationException(message); } } if (e2.MoveNext() || (e3 != null && e3.MoveNext()) || (e4 != null && e4.MoveNext())) { throw new InvalidOperationException("First sequence too short."); } } }
public IEnumerable<IEnumerable<double>> GetPrognosedValues(IDataset dataset, IEnumerable<int> rows, IEnumerable<int> horizons) { var rowsEnumerator = rows.GetEnumerator(); var horizonsEnumerator = horizons.GetEnumerator(); var targetValues = dataset.GetReadOnlyDoubleValues(TargetVariable); // produce a n-step forecast for all rows while (rowsEnumerator.MoveNext() & horizonsEnumerator.MoveNext()) { int row = rowsEnumerator.Current; int horizon = horizonsEnumerator.Current; if (row - TimeOffset < 0) { yield return Enumerable.Repeat(double.NaN, horizon); continue; } double[] prognosis = new double[horizon]; for (int h = 0; h < horizon; h++) { double estimatedValue = 0.0; for (int i = 1; i <= TimeOffset; i++) { int offset = h - i; if (offset >= 0) estimatedValue += prognosis[offset] * Phi[i - 1]; else estimatedValue += targetValues[row + offset] * Phi[i - 1]; } estimatedValue += Constant; prognosis[h] = estimatedValue; } yield return prognosis; } if (rowsEnumerator.MoveNext() || horizonsEnumerator.MoveNext()) throw new ArgumentException("Number of elements in rows and horizon enumerations doesn't match."); }
public override IEnumerable<object> ConvertTokens(IEnumerable<object> sequence) { var enumerator = sequence.GetEnumerator(); while(enumerator.MoveNext()) { var item = enumerator.Current; if(item is HelperExpression) { var helper = item as HelperExpression; item = GetNext(enumerator); List<Expression> helperArguments = new List<Expression>(); while((item is EndExpressionToken) == false) { if((item is Expression) == false) { throw new HandlebarsCompilerException( string.Format("Token '{0}' could not be converted to an expression", item)); } helperArguments.Add((Expression)item); item = GetNext(enumerator); } yield return HandlebarsExpression.Helper( helper.HelperName, helperArguments); yield return item; } else { yield return item; } } }
List<CssToken> Transform(IEnumerable<CssToken> values) { var enumerator = values.GetEnumerator(); while (enumerator.MoveNext() && enumerator.Current.Type == CssTokenType.Whitespace) { //Empty on purpose. } if (enumerator.Current.Type == _type && enumerator.Current.Data.Isi(_data)) { var list = new List<CssToken>(); while (enumerator.MoveNext()) { if (enumerator.Current.Type != CssTokenType.Whitespace || list.Count != 0) { list.Add(enumerator.Current); } } return list; } return null; }
private void CheckForMismatch([NotNull] IEnumerable <IDie> dice) { if (dice is null) { throw new ArgumentNullException(nameof(dice)); } using (IEnumerator <IDie> enumerator = dice?.GetEnumerator()) { if (enumerator.MoveNext()) { if (enumerator.Current != null) { Sides = enumerator.Current.Sides; while (enumerator.MoveNext()) { if (enumerator.Current != null && Sides != enumerator.Current.Sides) { throw new DiceMismatchException("A dice set cannot contain dice with differing numbers of sides"); } } } } } }
protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization) { JsonProperty property = base.CreateProperty(member, memberSerialization); if (typeof(IEnumerable).IsAssignableFrom(property.PropertyType)) { property.ShouldSerialize = obj => { IEnumerable enumerable = null; switch (member) { case PropertyInfo propertyInfo: enumerable = (IEnumerable)propertyInfo.GetValue(obj); break; case FieldInfo fieldInfo: enumerable = (IEnumerable)fieldInfo.GetValue(obj); break; } bool anyElements = enumerable?.GetEnumerator().MoveNext() ?? false; return(anyElements); }; } return(property); }
private IEnumerable<KeyValuePair<byte[], ulong>>MakeInternalNodes(ulong txnId, IEnumerable<KeyValuePair<byte[], ulong >> children, BrightstarProfiler profiler) { var enumerator = children.GetEnumerator(); var childList = enumerator.Next(_internalBranchFactor).ToList(); if (childList.Count == 1) { yield return childList[0]; yield break; } byte[] prevNodeKey = childList[0].Key; IInternalNode prevNode = MakeInternalNode(txnId, childList); childList = enumerator.Next(_internalBranchFactor).ToList(); while(childList.Count > 0) { IInternalNode nextNode = MakeInternalNode(txnId, childList); var nextNodeKey = childList[0].Key; if (nextNode.NeedJoin) { nextNodeKey = new byte[_config.KeySize]; nextNode.RedistributeFromLeft(txnId, prevNode, childList[0].Key, nextNodeKey); } yield return WriteNode(txnId, prevNode, prevNodeKey, profiler); prevNode = nextNode; prevNodeKey = nextNodeKey; childList = enumerator.Next(_internalBranchFactor).ToList(); } yield return WriteNode(txnId, prevNode, prevNodeKey, profiler); }
public void Flush(IEnumerable<ISqlStatement> statements) { var writer = new SqlStatementBatchWriter(); using (var connection = new SqlConnection(_builder.ConnectionString)) { connection.Open(); using (var transaction = connection.BeginTransaction(IsolationLevel.ReadCommitted)) { using (var command = new SqlCommand()) { command.Connection = connection; command.Transaction = transaction; using (var enumerator = statements.GetEnumerator()) { var moved = enumerator.MoveNext(); while (moved) { while (moved && writer.TryWrite(enumerator.Current)) { moved = enumerator.MoveNext(); } writer.BuildCommand(command); command.ExecuteNonQuery(); writer.Reset(); } } } transaction.Commit(); } connection.Close(); } }
internal string ExpandString(IEnumerable<object> expandedValues) { expandedValues = expandedValues.Reverse(); var exValEnumerator = expandedValues.GetEnumerator(); var resultStr = new StringBuilder(); string rest = Value; // we expand this string in reversed order so we don't need to adjust start indexes foreach (var item in NestedExpressions.Reverse()) { if (!exValEnumerator.MoveNext()) { break; } // first find the relative position of the expandable part inside our string string value = LanguagePrimitives.ConvertTo<string>(exValEnumerator.Current); var relStart = item.Extent.StartOffset - Extent.StartOffset - 1; var relEnd = item.Extent.EndOffset - Extent.StartOffset - 1; // the end are constant words between this expression and the last resolved expression // we need to resolve escape constants before adding it var resolvedEnd = StringExpressionHelper.ResolveEscapeCharacters(rest.Substring(relEnd), StringConstantType); // as we do it in reverse order: insert at the beginning, in reverse order resultStr.Insert(0, resolvedEnd).Insert(0, value); // finally strip the rest which needs to be expanded rest = rest.Substring(0, relStart); } // now insert the rest at the beginning (other constant string) resultStr.Insert(0, StringExpressionHelper.ResolveEscapeCharacters(rest, StringConstantType)); return resultStr.ToString(); }
private static bool ZipCompare(this IEnumerable<string> source1, IEnumerable<string> source2, Func<string, string, bool> comparison) { using (var enumerator1 = source1.GetEnumerator()) { using (var enumerator2 = source2.GetEnumerator()) { var has1 = enumerator1.MoveNext(); var has2 = enumerator2.MoveNext(); while (has1 || has2) { var current1 = has1 ? enumerator1.Current : ""; var current2 = has2 ? enumerator2.Current : ""; if (!comparison(current1, current2)) { return false; } if (has1) { has1 = enumerator1.MoveNext(); } if (has2) { has2 = enumerator2.MoveNext(); } } } } return true; }
public void SayManyPhrasesInManyLanguages( IEnumerable<UniLangPhrase> fragments, Action<UniLangPhrase> funcNextFragment) { CurMultiPhrasing = new MultiPhrasing(this, fragments.GetEnumerator(), funcNextFragment); CurMultiPhrasing.Start(); }
private string SqlInInternal <T>(string field, string param, string alias, NpgsqlDbType dbType, IEnumerable <T> values, bool notIn) { var enumerator = values?.GetEnumerator(); if (enumerator == null || !enumerator.MoveNext()) { return("0=1"); } param = "@" + param; var i = 0; var count = 0; do { Set(param + i, dbType, enumerator.Current); i++; count++; } while (enumerator.MoveNext()); var sb = new StringBuilder(); if (!String.IsNullOrEmpty(alias)) { sb.Append(alias).Append("."); } sb.AppendFormat("`{0}` {1}IN ({2}0", field, notIn ? "NOT " : String.Empty, param); for (i = 1; i < count; i++) { sb.AppendFormat(", {0}{1}", param, i); } sb.Append(")"); return(sb.ToString()); }
public static void Invoke(IEnumerable<object> e) { // https://sites.google.com/a/jsc-solutions.net/backlog/knowledge-base/2015/201501/20150102/foreach //02000002 Test453ForEach.Class1 //script: error JSC1000: unknown while condition at Void Invoke(System.Collections.Generic.IEnumerable`1[System.Object]).Maybe you did not turn off c# compiler 'optimize code' feature? // 2015 comples it the way jsc likes it. yet for foreach it optimizes. // lets turn on optimization then? var x = e.GetEnumerator(); while (x.MoveNext()) { loopStart(); loopEnd(); } join(); //var a = [this], c, d; //c = b.IQIABnMeWzaNooAKOmFm5g(); //while (c.BgIABu7N0xGI6ACQJ1TEOg()) //{ //} }
private Mock <IVBComponent> CreateComponentMock(string name, ComponentType type, string content, Selection selection, IEnumerable <IProperty> properties, out Mock <ICodeModule> moduleMock) { var result = new Mock <IVBComponent>(); result.Setup(m => m.Dispose()); result.SetupReferenceEqualityIncludingHashCode(); result.Setup(m => m.Equals(It.IsAny <IVBComponent>())) .Returns((IVBComponent other) => ReferenceEquals(result.Object, other)); result.SetupGet(m => m.VBE).Returns(_getVbe); result.SetupGet(m => m.Collection).Returns(() => _vbComponents.Object); result.SetupGet(m => m.Type).Returns(() => type); result.SetupGet(m => m.HasCodeModule).Returns(true); result.SetupProperty(m => m.Name, name); result.SetupGet(m => m.QualifiedModuleName).Returns(() => new QualifiedModuleName(result.Object)); result.SetupGet(m => m.QualifiedModuleName).Returns(() => new QualifiedModuleName(result.Object)); var propertiesMock = new Mock <IProperties>(); propertiesMock.Setup(m => m.GetEnumerator()).Returns(() => properties?.GetEnumerator()); result.SetupGet(m => m.Properties).Returns(propertiesMock.Object); var module = CreateCodeModuleMock(name, content, selection, result); result.SetupGet(m => m.CodeModule).Returns(() => module.Object); // Note that this setup does not account for hashing behavior of designers. See https://github.com/rubberduck-vba/Rubberduck/issues/3387 result.Setup(m => m.ContentHash()).Returns(() => result.Object.CodeModule.ContentHash()); result.Setup(m => m.Activate()); moduleMock = module; return(result); }
public Parser(IEnumerable <Token> tokens) { scope = -1; typeExpression = 0; errors = new List <string>(); symbols = new List <Symbols>(); this.tokens = tokens?.GetEnumerator() ?? Enumerable.Empty <Token>().GetEnumerator(); }
/// <summary> /// Create an IDataReader over an instance of IEnumerable. /// Use other constructor for IEnumerable<> /// </summary> /// <param name="collection">The collection</param> public MockedDataReader(IEnumerable collection, Type type) : base(type) { _type = type; _enumerator = collection?.GetEnumerator(); _results = new Queue <Result>(); }
public static bool Any(this IEnumerable source) { var result = default(bool?); var enumerator = source?.GetEnumerator(); result = enumerator?.MoveNext(); return(result.GetValueOrDefault()); }
/// <summary> /// Create an IDataReader over an instance of IEnumerable. /// Use other constructor for IEnumerable<> /// </summary> /// <param name="collection">The collection</param> public MockedDataReader(IEnumerable <T> collection) : base(typeof(T)) { _type = typeof(T); _enumerator = collection?.GetEnumerator(); _results = new Queue <Result>(); }
public static void IsNullOrEmpty <T>( IEnumerable <T> actual, string message = null, params object[] parameters) { using (IEnumerator <T> iterator = actual?.GetEnumerator()) { Assert.IsFalse(iterator?.MoveNext() ?? false, message, parameters); } }
IEnumerator IEnumerable.GetEnumerator() { IEnumerable <T> source = this; return(source?.GetEnumerator() ?? EnumerableHelpers .Empty <T>() .GetEnumerator());; }
public DoubleIterator(IEnumerable <TFirst> first, IEnumerable <TSecond> second) { if (first == null) { throw new ArgumentNullException(nameof(first)); } _first = first.GetEnumerator(); _second = second?.GetEnumerator(); }
/// <summary> /// Executes a given constructor (identified by <paramref name="constructorSelector"/>) by reading values out of the picker /// (or prompting the user if <paramref name="pickerArgsIfAny"/> is null) /// </summary> /// <param name="toConstruct">The Type you want to construct</param> /// <param name="constructorSelector">Selects which constructor on <paramref name="toConstruct"/> you want to invoke</param> /// <param name="pickerArgsIfAny"></param> /// <returns></returns> protected object Construct(Type toConstruct, Func <ObjectConstructor, ConstructorInfo> constructorSelector, IEnumerable <CommandLineObjectPickerArgumentValue> pickerArgsIfAny = null) { var objectConstructor = new ObjectConstructor(); var invoker = new CommandInvoker(BasicActivator); var constructor = constructorSelector(objectConstructor); List <object> constructorValues = new List <object>(); var pickerEnumerator = pickerArgsIfAny?.GetEnumerator(); foreach (var parameterInfo in constructor.GetParameters()) { var required = new RequiredArgument(parameterInfo); var parameterDelegate = invoker.GetDelegate(required); if (parameterDelegate.IsAuto) { constructorValues.Add(parameterDelegate.Run(required)); } else { //it's not auto if (pickerEnumerator != null) { pickerEnumerator.MoveNext(); if (pickerEnumerator.Current == null) { throw new ArgumentException($"Value needed for parameter '{required.Name}' (of type '{required.Type}')"); } //construct with the picker arguments if (!pickerEnumerator.Current.HasValueOfType(required.Type)) { throw new NotSupportedException($"Argument '{pickerEnumerator.Current.RawValue}' could not be converted to required Type '{required.Type}' for argument {required.Name}"); } //it is a valid object yay! constructorValues.Add(pickerEnumerator.Current.GetValueForParameterOfType(required.Type)); } else { //construct by prompting user for the values constructorValues.Add(invoker.GetValueForParameterOfType(parameterInfo)); } } } pickerEnumerator?.Dispose(); return(constructor.Invoke(constructorValues.ToArray())); }
public Exercise(Guid exerciseId, Guid userId, IEnumerable <ExercisedWord> exercisedWords) { ExerciseId = exerciseId; UserId = userId; _wordsDone = 0; _wordsLeft = exercisedWords.Count(); _wordsEnumerator = exercisedWords?.GetEnumerator() ?? throw new ArgumentNullException(nameof(exercisedWords)); _isFinished = !_wordsEnumerator.MoveNext(); _currentExercisedWord = _wordsEnumerator.Current; }
public static object GetFirstOrDefault(this IEnumerable source, object defaultValue = null) { var enumerator = source?.GetEnumerator(); var result = enumerator?.MoveNext(); if (result == true) { return(enumerator.Current); } return(defaultValue); }
static IEnumerable <TResult> ZipImpl <T1, T2, T3, T4, TResult>( IEnumerable <T1> s1, IEnumerable <T2> s2, IEnumerable <T3> s3, IEnumerable <T4> s4, Func <T1, T2, T3, T4, TResult> resultSelector, int limit, Folder <IEnumerator, Exception> errorSelector = null) { IEnumerator <T1> e1 = null; IEnumerator <T2> e2 = null; IEnumerator <T3> e3 = null; IEnumerator <T4> e4 = null; var terminations = 0; try { e1 = s1.GetEnumerator(); e2 = s2.GetEnumerator(); e3 = s3?.GetEnumerator(); e4 = s4?.GetEnumerator(); while (true) { var n = 0; var v1 = Read(ref e1, ++n); var v2 = Read(ref e2, ++n); var v3 = Read(ref e3, ++n); var v4 = Read(ref e4, ++n); if (terminations <= limit) { yield return(resultSelector(v1, v2, v3, v4)); } else { yield break; } } } finally { e1?.Dispose(); e2?.Dispose(); e3?.Dispose(); e4?.Dispose(); } T Read <T>(ref IEnumerator <T> e, int n) { if (e == null || terminations > limit) { return(default);
public static T MoveOne <T>(this IEnumerable <T> enumerable) { var enumerator = enumerable?.GetEnumerator(); if (enumerator?.MoveNext() ?? false) { enumerator.Dispose(); return(enumerator.Current); } enumerator?.Dispose(); return(default);
public void WriteFormat(string format, IEnumerable <object?> args, IEnumerable <ConCol?> conCols, int argCount) { var argRanges = ParseInterpArgs(format, argCount); var colors = conCols?.GetEnumerator(); var allArgs = args.ToArray(); Index regStart = 0; for (var i = 0; i < argCount; i++) { // Write non-colorized lead-in _writer.Write(format[regStart..argRanges[i].Start]);
public static bool Any(this IEnumerable <bool> source) { using var en = source?.GetEnumerator() ?? throw new ArgumentNullException(nameof(source)); while (en.MoveNext()) { if (en.Current) { return(true); } } return(false); }
private static State CalcOutput(IEnumerable <long> inputSequence) { var state = new State() { Name = "noop", Panels = new Dictionary <Point, Panel>(), Direction = "up", Register = (long[])register.Clone(), Running = true, InputSequence = inputSequence?.GetEnumerator() }; return(RunOpcodeProgram(state)); }
public static IEnumerable <KeyRange> Create(IEnumerable <string> keys, IEnumerable <double> values, IEnumerable <double> mins, IEnumerable <double> maxs) { using (var b = keys.GetEnumerator()) using (var c = values.GetEnumerator()) using (var d = mins?.GetEnumerator()) using (var e = maxs?.GetEnumerator()) { while (b.MoveNext() && c.MoveNext() && (bool)(d?.MoveNext() ?? true) && (bool)(e?.MoveNext() ?? true)) { var ff = new KeyRange(b.Current, c.Current, d?.Current, e?.Current); yield return(ff); } } }
public static async Task <List <long> > RunProgramAsync( long[] program, IEnumerable <long> input, CancellationToken cancellationToken = default) { using var stream = input?.GetEnumerator() ?? throw new ArgumentNullException(nameof(input)); var output = new List <long>(); await RunProgramAsync( program, () => stream.MoveNext()?stream.Current : throw new InvalidOperationException(), output.Add, cancellationToken ); return(output); }
public override bool TryCreateWuEndpoint(Binding binding, EndpointAddress remoteAddress, out IWuEndpoint endpoint, out Exception exception) { lock (_lock) { if (_enumerator == null) { _enumerator = _endpoint?.GetEnumerator(); } _enumerator?.MoveNext(); endpoint = _enumerator?.Current ?? null; exception = _exception; return(_result); } }
public static void AddStructuredInParameter(this SqlCommand command, string name, SqlDbType type, IEnumerable value, string tableType) { object tvp = null; var hasRecords = value?.GetEnumerator()?.MoveNext(); if (value != null && hasRecords.GetValueOrDefault()) { tvp = new TableValueCollection(value as IEnumerable <object>); } var parameter = command.Parameters.AddWithValue(name, tvp); parameter.SqlDbType = type; parameter.TypeName = tableType; }
private static void ItemsSourceChanged(object sender, EventArgs e) { ListView lv = (ListView)sender; IEnumerable its = lv.ItemsSource; IEnumerator itsEnumerator = its?.GetEnumerator(); if (itsEnumerator != null) { bool hasItems = itsEnumerator.MoveNext(); if (hasItems) { SetUpTheColumns(lv, itsEnumerator.Current); } } }