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);
}
}
}
