/// <inheritdoc />
public void Reset()
{
_worksheetIterator?.Dispose();
_rowIterator?.Dispose();
_worksheetIterator = null;
_rowIterator = null;
ResetSheetData();
if (Workbook != null)
{
_worksheetIterator = Workbook.ReadWorksheets().GetEnumerator();
if (!_worksheetIterator.MoveNext())
{
_worksheetIterator.Dispose();
_worksheetIterator = null;
return;
}
_rowIterator = _worksheetIterator.Current.ReadRows().GetEnumerator();
}
}
public void Reset()
{
_generatorIterator?.Dispose();
for (int i = 0; i < _permutation.Length; i++)
{
_permutation[i] = i;
}
_generatorIterator = _generator.GetEnumerator();
_generatorIterator.MoveNext();
_hasMoreResults = true;
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
public void Dispose()
{
Current = default(T);
_disposeOnComplete?.Dispose();
_disposeOnComplete = null;
_enumerable = null;
_enumerator?.Dispose();
_enumerator = null;
if (_peek != null && _peek.Length > 0)
{
(_peek[0] as IDisposable)?.Dispose();
}
_peek = null;
}
protected virtual void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
_disposed = true;
if (disposing)
{
_source?.Dispose();
}
}
protected override void Dispose(bool disposing)
{
try
{
if (disposing)
{
enumerator?.Dispose();
}
}
finally
{
base.Dispose(disposing);
}
}
private bool disposedValue = false; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
_replayEventPosition?.Dispose();
}
_replayEvents = null;
disposedValue = true;
}
}
/// <summary>
/// Attempts to move to the next item in the current page of content. If there is no content in the current page, it retrieves the next page and returns the result of that content's move next
/// </summary>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <bool> MoveNext(CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (!_currentEnumerator.MoveNext())
{
if (string.IsNullOrWhiteSpace(_currentFeed.Cursor))
{
return(false);
}
RequestOptions newOptions = _options?.Clone() ?? RequestOptions.CreateFromDefaults(_client.ApiClient.Config);
newOptions.CancellationToken = cancellationToken;
_currentFeed = await _currentFeed.GetNextPageAsync(RequestCount, newOptions).ConfigureAwait(false);
_currentEnumerator?.Dispose();
_currentEnumerator = _currentFeed.Content.GetEnumerator();
return(_currentEnumerator.MoveNext());
}
return(true);
}
public override void Subscribe(IFlowableSubscriber <T> subscriber)
{
IEnumerator <T> enumerator = null;
bool b;
try
{
enumerator = enumerable.GetEnumerator();
b = enumerator.MoveNext();
}
catch (Exception ex)
{
try
{
enumerator?.Dispose();
}
catch (ObjectDisposedException)
{
// can't do much about this
}
subscriber.OnSubscribe(EmptySubscription <T> .Instance);
subscriber.OnError(ex);
return;
}
if (!b)
{
try
{
enumerator.Dispose();
}
catch (ObjectDisposedException)
{
// can't do much about this
}
subscriber.OnSubscribe(EmptySubscription <T> .Instance);
subscriber.OnComplete();
return;
}
if (subscriber is IConditionalSubscriber <T> s)
{
subscriber.OnSubscribe(new EnumerableConditionalSubscription(s, enumerator));
}
else
{
subscriber.OnSubscribe(new EnumerableSubscription(subscriber, enumerator));
}
}
/// <summary>Проверка с задаваемой точностью</summary>
/// <param name="Accuracy">Точность сравнения</param>
/// <param name="Message">Сообщение, выводимое в случае ошибки сравнения</param>
public EqualityCheckerWithAccuracy WithAccuracy(double Accuracy, string Message = null)
{
_IsChecked = true;
IEnumerator <double> expected_collection_enumerator = null;
IEnumerator <double> actual_collection_enumerator = null;
try
{
expected_collection_enumerator = _ExpectedValues.GetEnumerator();
actual_collection_enumerator = _ActualValues.GetEnumerator();
var index = 0;
Service.CheckSeparator(ref Message);
if (_Not)
{
while (actual_collection_enumerator.MoveNext() && expected_collection_enumerator.MoveNext())
{
var expected = expected_collection_enumerator.Current;
var actual = actual_collection_enumerator.Current;
var delta = Math.Abs(expected - actual);
Assert.AreNotEqual(
expected, actual, Accuracy,
"{0}error[{1}]: ожидалось({2}), получено({3}), accuracy:{4}, err:{5:e3}; rel.err:{6}",
Message, index++, expected, actual, Accuracy, delta, delta / expected);
}
}
else
{
while (actual_collection_enumerator.MoveNext() && expected_collection_enumerator.MoveNext())
{
var expected = expected_collection_enumerator.Current;
var actual = actual_collection_enumerator.Current;
var delta = Math.Abs(expected - actual);
Assert.AreEqual(
expected, actual, Accuracy,
"{0}error[{1}]: ожидалось({2}), получено({3}), accuracy:{4}, err:{5:e3}; rel.err:{6}",
Message, index++, expected, actual, Accuracy, delta, delta / expected);
}
}
}
finally
{
expected_collection_enumerator?.Dispose();
actual_collection_enumerator?.Dispose();
}
return(this);
}
public static async Task CreateEntriesFromDirectoryAsync(this TarWriter writer, string path, string entryBase)
{
await CreateEntryFromFileAsync(writer, path, entryBase);
// Keep a stack of directory enumerations in order to write the
// tar in depth-first order (which seems to be more common in tar
// implementations than the breadth-first order that SearchOption.AllDirectories
// implements).
var stack = new List <IEnumerator <string> >();
IEnumerator <string> enumerator = null;
try
{
enumerator = Directory.EnumerateFileSystemEntries(path).GetEnumerator();
while (enumerator != null)
{
while (enumerator.MoveNext())
{
var filePath = enumerator.Current;
var fileName = filePath.Substring(path.Length + 1);
var fi = new FileInfo(filePath);
await writer.CreateEntryFromFileInfoAsync(fi, Path.Combine(entryBase, fileName));
if (fi.Attributes.HasFlag(FileAttributes.Directory))
{
stack.Add(enumerator);
enumerator = Directory.EnumerateFileSystemEntries(filePath).GetEnumerator();
}
}
enumerator.Dispose();
enumerator = null;
if (stack.Count > 0)
{
enumerator = stack.Last();
stack.RemoveAt(stack.Count - 1);
}
}
}
finally
{
enumerator?.Dispose();
foreach (var e in stack)
{
e.Dispose();
}
}
}
/// <inheritdoc />
protected override void Dispose(bool disposing)
{
_enumerator?.Dispose();
#if NET20
if (disposing)
{
Reader.Close();
}
#else
if (disposing)
{
Reader.Dispose();
}
#endif
}
/// <summary>
/// Releases resources used by the <see cref="TokenStreamAnonymousInnerClassHelper{T}"/> and
/// if overridden in a derived class, optionally releases unmanaged resources.
/// </summary>
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources;
/// <c>false</c> to release only unmanaged resources.</param>
// LUCENENET specific
protected override void Dispose(bool disposing)
{
try
{
if (disposing)
{
iter?.Dispose(); // LUCENENET specific - dispose iter and set to null
iter = null;
}
}
finally
{
base.Dispose(disposing);
}
}
public void Reset()
{
_generatorIterator?.Dispose();
// restore lexographic ordering of the permutation indexes
for (var i = 0; i < _permutation.Length; i++)
{
_permutation[i] = i;
}
// start a newiteration over the nested loop generator
_generatorIterator = _generator.GetEnumerator();
// we must advance the nestedloop iterator to the initial element,
// this ensures that we only ever produce N!-1 calls to NextPermutation()
_generatorIterator.MoveNext();
_hasMoreResults = true; // there's always at least one permutation: the original set itself
}
public void Dispose()
{
_buffer.Clear();
_buffer = null !;
_current = null !;
_context._enumerator = null;
_context = null !;
_sources = null !;
_currentEnumerator?.Dispose();
_currentEnumerator = null !;
}
public IEnumerator <string> GetEnumerator()
{
do
{
IEnumerator <string> c = Sources[Sources.Count - 1];
if (c.MoveNext())
{
yield return(c.Current);
}
else
{
c?.Dispose();
Sources.RemoveAt(Sources.Count - 1);
}
} while (Sources.Count > 0);
}
public H264Bitstream(IEnumerable<byte> buffer)
{
_bytes = buffer.GetEnumerator();
if (!_bytes.MoveNext())
{
_bytes.Dispose();
_bytes = null;
return;
}
_nextByte = _bytes.Current;
_bitsLeft = 0;
}
public void ReceiveFromEndpoint()
{
try
{
if (_log.IsDebugEnabled)
_log.DebugFormat("Calling Receive on {0} from thread {1} ({2})", _bus.Endpoint.Address.Uri,
Thread.CurrentThread.ManagedThreadId, _receiveTimeout);
_startTime = SystemUtil.UtcNow;
_receiveTime.Start();
_bus.Endpoint.Receive(context =>
{
if (_log.IsDebugEnabled)
_log.DebugFormat("Enumerating pipeline on {0} from thread {1}", _bus.Endpoint.Address.Uri,
Thread.CurrentThread.ManagedThreadId);
context.SetBus(_bus);
IEnumerable<Action<IConsumeContext>> enumerable = _bus.InboundPipeline.Enumerate(context);
_consumers = enumerable.GetEnumerator();
if (!_consumers.MoveNext())
{
_consumers.Dispose();
return null;
}
return DeliverMessageToConsumers;
}, _receiveTimeout);
}
catch (ObjectDisposedException)
{
Thread.Sleep(1000);
}
catch (Exception ex)
{
_log.Error("Consumer Exception Exposed", ex);
}
finally
{
NotifyReceiveCompleted();
NotifyConsumeCompleted();
}
}
private void deleteExpiredSentItemsButton_Click(object sender, RibbonControlEventArgs e)
{
var expiredSentItems = new ExpiredSentItems();
// Setup the progress dialog.
m_progressDialog = new ProgressDialog { WindowTitle = DefaultWindowTitle, LabelContent = "Deleting..." };
m_progressDialog.Canceled += progressDialog_Canceled;
m_progressDialog.Maximum = expiredSentItems.Count;
// this sets up an enumeration to give us one Outlook item at a time in reverse order--suitable for deleting
m_expiredMailItems = expiredSentItems.GetEnumerator();
// Start the deleting and show the progress dialog
DeleteMailItem();
m_progressDialog.ShowDialog();
if (m_expiredMailItems != null) // not canceled
m_expiredMailItems.Dispose();
}
/// <inheritdoc />
public IAsyncEnumerable <StructResult <StrongFingerprint> > EnumerateStrongFingerprints(Context context)
{
context.Debug($"{nameof(SQLiteMemoizationStore)}.{nameof(EnumerateStrongFingerprints)}({context.Id})");
return(AsyncEnumerable.CreateEnumerable(
() =>
{
const long pageLimit = 100;
long offset = 0;
IEnumerator <StrongFingerprint> strongFingerprints = null;
StructResult <StrongFingerprint> error = null;
return AsyncEnumerable.CreateEnumerator(
async cancellationToken =>
{
try
{
if (error != null)
{
return false;
}
if (strongFingerprints == null || !strongFingerprints.MoveNext())
{
// ReSharper disable once GenericEnumeratorNotDisposed
strongFingerprints = (await EnumerateStrongFingerprintsAsync(pageLimit, offset)).GetEnumerator();
if (!strongFingerprints.MoveNext())
{
return false;
}
}
offset++;
return true;
}
catch (Exception e)
{
error = new StructResult <StrongFingerprint>(e);
return true;
}
},
() => error ?? new StructResult <StrongFingerprint>(strongFingerprints.Current),
() => { strongFingerprints?.Dispose(); });
}));
}
internal static IEnumerator <TSource> CompiledWhereIterator <TSource>(
IEnumerable <TSource> source, Func <TSource, bool> predicate)
{
IEnumerator <TSource> sourceIterator = null;
return(new Iterator <TSource>(
start: () => sourceIterator = source.GetEnumerator(),
moveNext: () =>
{
while (sourceIterator.MoveNext())
{
if (predicate(sourceIterator.Current))
{
return true;
}
}
return false;
},
getCurrent: () => sourceIterator.Current,
dispose: () => sourceIterator?.Dispose()).Start());
}
void Dispose(bool disposing)
{
if (disposed)
{
return;
}
disposed = true;
if (disposing)
{
iterator.Dispose();
iterator = null;
IsClosed = true;
}
else
{
iterator?.Dispose();
}
schema?.Dispose();
}
internal static IEnumerable <TResult> CompiledSelectGenerator <TSource, TResult>(
this IEnumerable <TSource> source, Func <TSource, TResult> selector)
{
IEnumerator <TSource> sourceIterator = null;
return(new Generator <TResult>(
start: () =>
{
"Select query starts.".WriteLine();
sourceIterator = source.GetEnumerator();
},
moveNext: () => sourceIterator.MoveNext(),
getCurrent: () =>
{
$"Select query calls selector with {sourceIterator.Current}.".WriteLine();
TResult result = selector(sourceIterator.Current);
$"Select query yields {result}.".WriteLine();
return result;
},
dispose: () => sourceIterator?.Dispose(),
end: () => "Select query ends.".WriteLine()));
}
public static T WithMin <T, U>(this IEnumerable <T> e, Func <T, U> selector) where U : IComparable <U>
{
Requires.NotNull(e);
Requires.NotNull(selector);
var comparer = Comparer <U> .Default;
T result;
IEnumerator <T> enumerator = null;
try {
enumerator = e.GetEnumerator();
if (!enumerator.MoveNext())
{
throw new InvalidOperationException();
}
result = enumerator.Current;
var minimum = selector(result);
while (enumerator.MoveNext())
{
var current = enumerator.Current;
var currentValue = selector(current);
if (comparer.Compare(minimum, currentValue) > 0)
{
minimum = currentValue;
result = current;
}
}
} finally {
enumerator?.Dispose();
}
return(result);
}
internal static IEnumerable <TResult> DesugaredSelectGenerator <TSource, TResult>(
this IEnumerable <TSource> source, Func <TSource, TResult> selector)
{
"Select query starts.".WriteLine();
IEnumerator <TSource> sourceIterator = null; // start.
try
{
sourceIterator = source.GetEnumerator(); // start.
while (sourceIterator.MoveNext()) // moveNext.
{
$"Select query calls selector with {sourceIterator.Current}.".WriteLine(); // getCurrent.
TResult result = selector(sourceIterator.Current); // getCurrent.
$"Select query yields {result}.".WriteLine(); // getCurrent.
yield return(result); // getCurrent.
}
}
finally
{
sourceIterator?.Dispose(); // dispose.
}
"Select query ends.".WriteLine(); // end.
}
public async ValueTask <bool> MoveNextAsync()
{
if (_asyncCursor == null)
{
_asyncCursor = await _asyncCursorSource
.ToCursorAsync(_cancellationToken)
.ConfigureAwait(false);
}
if (_batchEnumerator?.MoveNext() == true)
{
return(true);
}
if (await _asyncCursor?.MoveNextAsync(_cancellationToken))
{
_batchEnumerator?.Dispose();
_batchEnumerator = _asyncCursor.Current.GetEnumerator();
return(_batchEnumerator.MoveNext());
}
return(false);
}
internal static IEnumerable <TResult> CompiledSelectWithDeferredCheck <TSource, TResult>(
this IEnumerable <TSource> source, Func <TSource, TResult> selector)
{
IEnumerator <TSource> sourceIterator = null;
return(new Generator <TResult>(
start: () =>
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (selector == null)
{
throw new ArgumentNullException(nameof(selector));
}
sourceIterator = source.GetEnumerator();
},
moveNext: () => sourceIterator.MoveNext(),
getCurrent: () => selector(sourceIterator.Current),
dispose: () => sourceIterator?.Dispose()));
}
public IAsyncEnumerator <TResult> GetAsyncEnumerator(CancellationToken ct, AsyncIterationHint _)
{
IEnumerator <TSource>?inner = null;
try
{
inner = this.Source.GetEnumerator();
Contract.Assert(inner != null, "The underlying sequence returned an empty enumerator.");
var outer = this.Factory(inner, ct);
if (outer == null)
{
throw new InvalidOperationException("The async factory returned en empty enumerator.");
}
return(outer);
}
catch (Exception)
{
//make sure that the inner iterator gets disposed if something went wrong
inner?.Dispose();
throw;
}
}
/// <summary>
/// <para>Performs a receive from the endpoint that is specified on the bus given in the
/// constructor. First try to do the receive, then let the endpoint/transport
/// call <see cref="DeliverMessageToConsumers"/> (if there are consumers interested)</para>
/// <para>This method must not throw exceptions, because it might not be run on the main thread.</para>
/// </summary>
public void ReceiveFromEndpoint()
{
try
{
_startTime = SystemUtil.UtcNow;
_receiveTime.Start();
// Let the endpoint (and hence inbound transport) consume a message.
// This lambda passed is not called until the transport decides that it has
// gotten a message and want to pass it forward.
_bus.Endpoint.Receive(context =>
{
context.SetBus(_bus);
// look inside the inbound pipeline and find all message sinks that match the receive
// context (i.e. the message type we actually got from the transport)
// Have a look at everything implementing IPipelineSink<IConsumeContext> to
// dig deeper
IEnumerable<Action<IConsumeContext>> enumerable = _bus.InboundPipeline.Enumerate(context);
_consumers = enumerable.GetEnumerator();
if (!_consumers.MoveNext())
{
// meaning we don't have any sinks interested in this msg context
_consumers.Dispose();
return null;
}
// otherwise, we have some consumers
return DeliverMessageToConsumers;
}, _receiveTimeout);
}
catch (ObjectDisposedException ex)
{
_log.Warn("Endpoint threw ObjectDisposedException", ex);
Thread.Sleep(1000);
}
catch (Exception ex)
{
_log.Error("Consumer Exception Exposed", ex);
}
finally
{
NotifyReceiveCompleted();
NotifyConsumeCompleted();
}
}
internal void Reset()
{
_current = null;
_enumerator?.Dispose();
}
public void Dispose()
{
_source?.Dispose();
}
public void Dispose() => _groupingEnumerator?.Dispose();
public void Parse()
{
_sourceEnumerator = Source
.Where(t => TokenType.ToIgnore.NotContains(t.Type))
.GetEnumerator();
Match(TokenType.Undefined);
while (_inputToken.Type != TokenType.Eop)
{
if (_inputToken.Type == TokenType.String)
{
MethodBody
.Ldloc("sw")
.Ldstr(((Token<string>)_inputToken).Value)
.Callvirt<TextWriter>("Write", typeof(string));
Match(TokenType.String);
}
else if (_inputToken.Type == TokenType.GetShortHand)
{
MethodBody.Ldloc("sw");
RetrieveVariableValue(((GetShorhandToken) _inputToken).Identifier);
MethodBody.Callvirt<TextWriter>("Write", _resultType);
Match(TokenType.GetShortHand);
}
else
{
Match(TokenType.BeginExpressionMarker);
MethodBody.Ldloc("sw");
Expression();
if (_resultType == null)
{
MethodBody.Pop();
}
else
{
MethodBody.Callvirt<TextWriter>("Write", _resultType);
}
Match(TokenType.EndExpressionMarker);
}
}
Match(TokenType.Eop);
MethodBody
.Ldloc("sw")
.Callvirt<TextWriter>("Flush");
//Emitter.Eop();
_sourceEnumerator.Dispose();
}
void WriteDataAsync(ISocket socket, IEnumerator<byte[]> ds)
{
if (ds.MoveNext())
{
Debug.WriteLine("Client writing data async.");
if (!socket.Write(new ArraySegment<byte>(ds.Current), () => WriteDataAsync(socket, ds)))
WriteDataAsync(socket, ds);
}
else
{
Debug.WriteLine("Client ending connection.");
ds.Dispose();
socket.End();
}
}
public void Dispose()
{
_enumerator?.Dispose();
_enumerator = null;
}
void IAsyncStateMachine.MoveNext()
{
int result = default(int);
try
{
bool doFinallyBodies = true;
switch (state)
{
case -3:
goto Done;
case 0:
goto FirstAwaitContinuation;
case 1:
goto SecondAwaitContinuation;
}
// Default case - first call (state is -1)
total = 0;
iterator = text.GetEnumerator();
// We really want to jump straight to FirstAwaitRealContinuation, but we can't
// goto a label inside a try block...
FirstAwaitContinuation:
// foreach loop
try
{
// for/foreach loops typically have the condition at the end of the generated code.
// We want to go there *unless* we're trying to reach the first continuation.
if (state != 0)
{
goto LoopCondition;
}
goto FirstAwaitRealContinuation;
LoopBody:
ch = iterator.Current;
unicode = ch;
TaskAwaiter localTaskAwaiter = Task.Delay(unicode).GetAwaiter();
if (localTaskAwaiter.IsCompleted)
{
goto FirstAwaitCompletion;
}
state = 0;
taskAwaiter = localTaskAwaiter;
builder.AwaitUnsafeOnCompleted(ref localTaskAwaiter, ref this);
doFinallyBodies = false;
return;
FirstAwaitRealContinuation:
localTaskAwaiter = taskAwaiter;
taskAwaiter = default(TaskAwaiter);
state = -1;
FirstAwaitCompletion:
localTaskAwaiter.GetResult();
localTaskAwaiter = default(TaskAwaiter);
total += unicode;
LoopCondition:
if (iterator.MoveNext())
{
goto LoopBody;
}
}
finally
{
if (doFinallyBodies && iterator != null)
{
iterator.Dispose();
}
}
// After the loop
YieldAwaitable.YieldAwaiter localYieldAwaiter = Task.Yield().GetAwaiter();
if (localYieldAwaiter.IsCompleted)
{
goto SecondAwaitCompletion;
}
state = 1;
yieldAwaiter = localYieldAwaiter;
builder.AwaitUnsafeOnCompleted(ref localYieldAwaiter, ref this);
doFinallyBodies = false;
return;
SecondAwaitContinuation:
localYieldAwaiter = yieldAwaiter;
yieldAwaiter = default(YieldAwaitable.YieldAwaiter);
state = -1;
SecondAwaitCompletion:
localYieldAwaiter.GetResult();
localYieldAwaiter = default(YieldAwaitable.YieldAwaiter);
result = total;
}
catch (Exception ex)
{
state = -2;
builder.SetException(ex);
return;
}
Done:
state = -2;
builder.SetResult(result);
}
void IGenerationScheme.Generate(System3 system, DateTime simulationTime, long simulationStep)
{
var trailBundleSize = Math.Max (system.SimulationScheme is ParticlesWithTrails ? ((ParticlesWithTrails)system.SimulationScheme).TrailBundleSize : 1, 1);
var dt = (float)system.DT;
m_GIndices = m_GIndices ?? GenerationIndices(system).GetEnumerator();
var sw = new System.Diagnostics.Stopwatch();
sw.Start();
while(m_GIndices.MoveNext())
{
var pack = m_GIndices.Current;
var i = (int)(pack >> 32);
var j = (int)(pack);
var ii = i + j * trailBundleSize;
if (ii >= system.Position.Length) {
break;
}
var _i = i;
var metai = system.Meta.MapReadWrite(ref _i);
if(j == 0)
{
if (m_Length != system.Position.Length)
{
system.ParticleGenerator.NewBundle (system, i);
}
else if (metai[_i].LifeLen <= 0) {
system.ParticleGenerator.NewBundle (system, i);
}
else
{
metai[_i].LifeLen--;
metai[_i].Size = Math.Max (system.ParticleGenerator.UpdateSize (system, i, i), float.Epsilon);
}
}
else
{
var _ii = ii;
system.Meta.MapReadWrite(ref _ii)[_ii].Size = Math.Max (system.ParticleGenerator.UpdateSize (system, i, ii), float.Epsilon);
}
if(m_Length == system.Position.Length)
if(sw.Elapsed > TimeSpan.FromMilliseconds(50))
return;
}
m_GIndices.Dispose ();
m_GIndices = null;
m_Length = system.Position.Length;
}
/// <summary>
/// Moves to the next feature.
/// </summary>
/// <returns></returns>
public bool MoveNext()
{
if(_currentEnumerator != null &&
_currentEnumerator.MoveNext())
{ // there is still a current enumerator.
_current = _currentEnumerator.Current;
return true;
}
_currentEnumerator = null;
while(_source.MoveNext())
{
var features = _interpreter.Interpret(_source.Current());
if (features != null)
{ // an object was succesfully converted.
_currentEnumerator = features.GetEnumerator();
if(_currentEnumerator.MoveNext())
{ // move to first object in feature collection.
_current = _currentEnumerator.Current;
return true;
}
else
{ // an empty feature collection, try next one.
_currentEnumerator.Dispose();
_currentEnumerator = null;
}
}
}
return false;
}
public void Dispose()
{
_enumerator?.Dispose();
}
/// <summary>
/// Dispose of the Stream Reader and close out the source stream and file connections.
/// </summary>
public void Dispose()
{
_subscriptionFactoryEnumerator?.Dispose();
}
void RunAsyncProd(IDataConsumer consumer, IEnumerator<ArraySegment<byte>> data)
{
while (true)
{
if (!data.MoveNext())
{
consumer.OnEnd();
data.Dispose();
break;
}
if (consumer.OnData(data.Current, () => RunAsyncProd(consumer, data)))
break;
}
}
static void WriteNext(IEnumerator<string> data, IDataConsumer c, bool sync)
{
while (true)
{
if (!data.MoveNext())
{
c.OnEnd();
data.Dispose();
break;
}
var seg = new ArraySegment<byte>(Encoding.UTF8.GetBytes(data.Current));
if (sync)
{
if (c.OnData(seg, null))
throw new Exception("sync write should have returned false");
}
else
if (c.OnData(
seg,
() => WriteNext(data, c, sync)))
break;
}
}
