public void TrySetProgress_ReturnsCorrentValue(AsyncOperationStatus status, bool expectedResult)
{
// Arrange
var op = new AsyncCompletionSource(status);
// Act
var result = op.TrySetProgress(1);
// Assert
Assert.Equal(expectedResult, result);
}
public void Progress_ReturnsCorrentValue(AsyncOperationStatus status, float expectedValue)
{
// Arrange
var progress = 0.3f;
var op = new AsyncCompletionSource(status);
// Act
op.TrySetProgress(progress);
// Assert
Assert.Equal(expectedValue, op.Progress);
}
public void TrySetCompleted_SetsStatusToRanToCompletion(AsyncOperationStatus status)
{
// Arrange
var op = new AsyncCompletionSource(status);
// Act
var result = op.TrySetCompleted();
// Assert
Assert.True(op.IsCompletedSuccessfully);
Assert.True(result);
}
/// <summary>
/// Callback for the authentication status of the Social API.
/// </summary>
/// <param name='success'>
/// Success.
/// </param>
void AuthenticateCallback(bool success)
{
// Change the state of this menu to track the Social API status.
if (success)
{
socialInitialization = AsyncOperationStatus.Success;
}
else
{
socialInitialization = AsyncOperationStatus.Failed;
}
}
public void TrySetCanceled_SetsStatusToCanceled(AsyncOperationStatus status)
{
// Arrange
var op = new AsyncCompletionSource(status);
// Act
var result = op.TrySetCanceled();
// Assert
Assert.True(op.IsCanceled);
Assert.True(result);
}
public void TrySetResult_SetsStatusToRanToCompletion(AsyncOperationStatus status)
{
// Arrange
var resultValue = new object();
var op = new AsyncCompletionSource <object>(status);
// Act
var result = op.TrySetResult(resultValue);
// Assert
Assert.True(op.IsCompletedSuccessfully);
Assert.Equal(resultValue, op.Result);
Assert.True(result);
}
public void TrySetException_SetsStatusToCanceled(AsyncOperationStatus status)
{
// Arrange
var e = new OperationCanceledException();
var op = new AsyncCompletionSource(status);
// Act
var result = op.TrySetException(e);
// Assert
Assert.True(op.IsCanceled);
Assert.True(result);
Assert.Equal(e, op.Exception);
}
private void LdrOnCompleted(IAddressableLoader loader, AsyncOperationStatus status)
{
loader.CompletedEvent -= LdrOnCompleted;
var atlases = loader.Assets.Where(o => o is SpriteAtlas).Cast <SpriteAtlas>().ToArray();
var sounds = loader.Assets.Where(o => o is AudioSettings).Cast <AudioSettings>().ToArray();
var locales = loader.Assets.Where(IsLocale).Cast <TextAsset>().ToArray();
var windows = loader.Assets.Where(o => (o as GameObject)?.GetComponent <Window>())
.Cast <GameObject>().Select(o => o.GetComponent <Window>()).ToArray();
if (atlases.Length > 0)
{
foreach (var pair in _delayedAtlasRequests.ToList())
{
if (atlases.Any(atlas =>
{
if (atlas.name != pair.Key)
{
return(false);
}
pair.Value?.Invoke(atlas);
_delayedAtlasRequests.Remove(pair.Key);
return(true);
}))
{
Debug.LogFormat("Request for atlas {0} was found and satisfied.", pair.Key);
break;
}
}
}
foreach (var audioSettings in sounds)
{
foreach (var pair in audioSettings.Clips)
{
AudioManager.RegisterClips(pair.Value, pair.Key);
}
}
foreach (var locale in locales)
{
LocaleService.AddLocaleCsv(locale.text);
}
foreach (var window in windows)
{
WindowManager.RegisterWindow(window, true);
}
}
public void Constructor_SetsCorrectStatusAndOptions(AsyncOperationStatus status, AsyncCreationOptions options)
{
// Arrange/Act
var op = new AsyncResult(status, options);
var op2 = new AsyncResult(status, options, null);
var op3 = new AsyncResult(status, options, null, null);
// Assert
Assert.Equal(status, op.Status);
Assert.Equal(options, op.CreationOptions);
Assert.Equal(status, op2.Status);
Assert.Equal(options, op2.CreationOptions);
Assert.Equal(status, op3.Status);
Assert.Equal(options, op3.CreationOptions);
}
public void Constructor_SetsCorrectCompletionStatus(AsyncOperationStatus status)
{
// Arrange/Act
var op = new AsyncResult(status);
var op2 = new AsyncResult(status, null);
var op3 = new AsyncResult(status, null, null);
// Assert
AssertCompleted(op, status);
Assert.True(op.CompletedSynchronously);
AssertCompleted(op2, status);
Assert.True(op2.CompletedSynchronously);
AssertCompleted(op3, status);
Assert.True(op3.CompletedSynchronously);
}
AsyncOperationStatus ProcessClose(AsyncProtocolRequest asyncRequest, AsyncOperationStatus status)
{
Debug("ProcessClose: {0}", status);
lock (ioLock) {
if (xobileTlsContext == null)
{
return(AsyncOperationStatus.Complete);
}
xobileTlsContext.Close();
xobileTlsContext = null;
return(AsyncOperationStatus.Continue);
}
}
private void NotifyCompleted(AsyncOperationStatus status)
{
try
{
OnProgressChanged();
OnStatusChanged(status);
OnCompleted();
InvokeCallbacks();
}
finally
{
_waitHandle?.Set();
}
}
private void AssertCompleted(IAsyncOperation op, AsyncOperationStatus status)
{
if (status == AsyncOperationStatus.RanToCompletion)
{
Assert.Null(op.Exception);
}
else
{
Assert.NotNull(op.Exception);
}
Assert.True(op.IsCompleted);
Assert.Equal(status == AsyncOperationStatus.RanToCompletion, op.IsCompletedSuccessfully);
Assert.Equal(status == AsyncOperationStatus.Faulted, op.IsFaulted);
Assert.Equal(status == AsyncOperationStatus.Canceled, op.IsCanceled);
Assert.Equal(status, op.Status);
}
internal static string ToSerializedValue(this AsyncOperationStatus value)
{
switch (value)
{
case AsyncOperationStatus.Started:
return("Started");
case AsyncOperationStatus.InProgress:
return("InProgress");
case AsyncOperationStatus.Succeeded:
return("Succeeded");
case AsyncOperationStatus.Failed:
return("Failed");
}
return(null);
}
internal void DecrementReferenceCount()
{
if (m_referenceCount <= 0)
{
throw new Exception(string.Format("Cannot decrement reference count for operation {0} because it is already 0", this));
}
m_referenceCount--;
if (m_RM != null && m_RM.postProfilerEvents)
{
m_RM.PostDiagnosticEvent(new ResourceManager.DiagnosticEventContext(new AsyncOperationHandle(this), ResourceManager.DiagnosticEventType.AsyncOperationReferenceCount, m_referenceCount));
}
if (m_referenceCount == 0)
{
if (m_RM != null && m_RM.postProfilerEvents)
{
m_RM.PostDiagnosticEvent(new ResourceManager.DiagnosticEventContext(new AsyncOperationHandle(this), ResourceManager.DiagnosticEventType.AsyncOperationDestroy));
}
if (m_DestroyedAction != null)
{
m_DestroyedAction.Invoke(new AsyncOperationHandle <TObject>(this));
m_DestroyedAction.Clear();
}
Destroy();
Result = default(TObject);
m_referenceCount = 1;
m_Status = AsyncOperationStatus.None;
m_taskCompletionSource = null;
m_taskCompletionSourceTypeless = null;
m_Error = null;
m_Version++;
m_RM = null;
if (m_OnDestroyAction != null)
{
m_OnDestroyAction(this);
m_OnDestroyAction = null;
}
}
}
/// <summary>
/// Call the event handlers for this operation.
/// </summary>
public void InvokeCompletionEvent()
{
Validate();
m_InsideCompletionEvent = true;
if (m_CompletedAction != null)
{
var tmpEvent = m_CompletedAction;
m_CompletedAction = null;
try
{
tmpEvent(this);
}
catch (Exception e)
{
m_Status = AsyncOperationStatus.Failed;
OperationException = e;
}
}
if (m_CompletedActionT != null)
{
for (int i = 0; i < m_CompletedActionT.Count; i++)
{
try
{
m_CompletedActionT[i](this);
}
catch (Exception e)
{
m_Status = AsyncOperationStatus.Failed;
OperationException = e;
}
}
m_CompletedActionT.Clear();
}
m_InsideCompletionEvent = false;
if (m_ReleaseToCacheOnCompletion)
{
AsyncOperationCache.Instance.Release(this);
}
}
public static string GetDetailPageId(object type, object status)
{
AsyncOperationType asyncOperationType = (AsyncOperationType)type;
AsyncOperationStatus asyncOperationStatus = (AsyncOperationStatus)status;
string result = null;
AsyncOperationType asyncOperationType2 = asyncOperationType;
if (asyncOperationType2 != AsyncOperationType.Migration)
{
if (asyncOperationType2 == AsyncOperationType.CertExpiry)
{
result = "Certificates";
}
}
else
{
result = "MigrationBatches";
}
return(result);
}
public static string GetStartedByText(object type, object status, object startedBy, object startTime)
{
AsyncOperationType asyncOperationType = (AsyncOperationType)type;
AsyncOperationStatus asyncOperationStatus = (AsyncOperationStatus)status;
string result = Strings.ProcessStartedBy((startedBy as string) ?? string.Empty, (string)startTime);
AsyncOperationType asyncOperationType2 = asyncOperationType;
if (asyncOperationType2 != AsyncOperationType.Migration)
{
if (asyncOperationType2 == AsyncOperationType.CertExpiry)
{
result = string.Empty;
}
}
else if (asyncOperationStatus == AsyncOperationStatus.Created || asyncOperationStatus == AsyncOperationStatus.Removing)
{
result = string.Empty;
}
return(result);
}
/// <summary>
/// Complete the operation and invoke events.
/// </summary>
/// <param name="result">The result object for the operation.</param>
/// <param name="success">True if successful.</param>
/// <param name="errorMsg">The error message if the operation has failed.</param>
public void Complete(TObject result, bool success, string errorMsg)
{
IUpdateReceiver upOp = this as IUpdateReceiver;
if (m_UpdateCallbacks != null && upOp != null)
{
m_UpdateCallbacks.Remove(m_UpdateCallback);
}
m_Result = result;
m_Status = success ? AsyncOperationStatus.Succeeded : AsyncOperationStatus.Failed;
m_RM.PostDiagnosticEvent(new ResourceManager.DiagnosticEventContext(new AsyncOperationHandle(this), ResourceManager.DiagnosticEventType.AsyncOperationPercentComplete, 1));
m_RM.PostDiagnosticEvent(new ResourceManager.DiagnosticEventContext(new AsyncOperationHandle(this), ResourceManager.DiagnosticEventType.AsyncOperationComplete));
if (m_Status == AsyncOperationStatus.Failed)
{
if (string.IsNullOrEmpty(errorMsg))
{
errorMsg = "Unknown error in AsyncOperation";
}
m_RM.PostDiagnosticEvent(new ResourceManager.DiagnosticEventContext(new AsyncOperationHandle(this), ResourceManager.DiagnosticEventType.AsyncOperationFail, 0, errorMsg));
OperationException = new Exception(errorMsg);
ICachable cachedOperation = this as ICachable;
if (cachedOperation != null)
{
m_RM.RemoveOperationFromCache(cachedOperation.Hash);
}
RegisterForDeferredCallbackEvent(false);
}
else
{
InvokeCompletionEvent();
DecrementReferenceCount();
}
}
AsyncOperationStatus ProcessHandshake(AsyncProtocolRequest asyncRequest, AsyncOperationStatus status)
{
Debug("ProcessHandshake: {0}", status);
/*
* The first time we're called (AsyncOperationStatus.Initialize), we need to setup the SslContext and
* start the handshake.
*/
if (status == AsyncOperationStatus.Initialize)
{
xobileTlsContext.StartHandshake();
return(AsyncOperationStatus.Continue);
}
else if (status == AsyncOperationStatus.ReadDone)
{
// remote prematurely closed connection.
throw new IOException("Remote prematurely closed connection.");
}
else if (status != AsyncOperationStatus.Continue)
{
throw new InvalidOperationException();
}
/*
* SSLHandshake() will return repeatedly with 'SslStatus.WouldBlock', we then need
* to take care of I/O and call it again.
*/
if (!xobileTlsContext.ProcessHandshake())
{
/*
* Flush the internal write buffer.
*/
InnerFlush();
return(AsyncOperationStatus.Continue);
}
xobileTlsContext.FinishHandshake();
return(AsyncOperationStatus.Complete);
}
AsyncOperationStatus ProcessWrite(AsyncProtocolRequest asyncRequest, AsyncOperationStatus status)
{
Debug("ProcessWrite - write user: {0} {1}", status, asyncRequest.UserBuffer);
if (asyncRequest.UserBuffer.Size == 0)
{
asyncRequest.UserResult = asyncRequest.CurrentSize;
return(AsyncOperationStatus.Complete);
}
int ret;
bool wantMore;
lock (ioLock) {
ret = Context.Write(asyncRequest.UserBuffer.Buffer, asyncRequest.UserBuffer.Offset, asyncRequest.UserBuffer.Size, out wantMore);
}
Debug("ProcessWrite - write user done: {0} - {1} {2}", asyncRequest.UserBuffer, ret, wantMore);
if (ret < 0)
{
asyncRequest.UserResult = -1;
return(AsyncOperationStatus.Complete);
}
asyncRequest.CurrentSize += ret;
asyncRequest.UserBuffer.Offset += ret;
asyncRequest.UserBuffer.Size -= ret;
if (wantMore || writeBuffer.Size > 0)
{
return(AsyncOperationStatus.WantWrite);
}
asyncRequest.ResetWrite();
asyncRequest.UserResult = asyncRequest.CurrentSize;
return(AsyncOperationStatus.Complete);
}
private static string GetItemTextForMigration(AsyncOperationType type, AsyncOperationStatus status, object displayName, object originalExtAttributes)
{
string empty = string.Empty;
string empty2 = string.Empty;
string empty3 = string.Empty;
if (originalExtAttributes != DBNull.Value)
{
KeyValuePair <string, LocalizedString>[] source = (KeyValuePair <string, LocalizedString>[])originalExtAttributes;
Dictionary <string, string> dictionary = source.ToDictionary((KeyValuePair <string, LocalizedString> item) => item.Key.ToString(), (KeyValuePair <string, LocalizedString> item) => item.Value.ToString());
dictionary.TryGetValue(AsyncNotificationAdapter.TotalSyncedCount, out empty);
dictionary.TryGetValue(AsyncNotificationAdapter.TotalItemCount, out empty2);
dictionary.TryGetValue(AsyncNotificationAdapter.TotalFailedCount, out empty3);
}
int totalSyncedCount;
int.TryParse(empty, out totalSyncedCount);
int totalItemCount;
int.TryParse(empty2, out totalItemCount);
int totalFailedCount;
int.TryParse(empty3, out totalFailedCount);
return(NotificationService.GetItemTextImp(type, status, displayName, DBNull.Value, new Func <string, string, LocalizedString>(Strings.AsyncProcessQueued), new Func <string, string, string, LocalizedString>(Strings.AsyncProcessInProgressWithPercentage), delegate(string operation, string name)
{
if (totalFailedCount > 0)
{
return Strings.MigrationInProgressWithFailedCount(operation, name, totalSyncedCount, totalItemCount, totalFailedCount);
}
if (totalItemCount > 0)
{
return Strings.MigrationInProgressWithSyncedCount(operation, name, totalSyncedCount, totalItemCount);
}
return Strings.AsyncProcessInProgress(operation, name);
}, new Func <string, string, LocalizedString>(Strings.AsyncProcessSuspended), new Func <string, string, LocalizedString>(Strings.AsyncProcessCompleted), new Func <string, string, LocalizedString>(Strings.AsyncProcessFailed), new Func <string, string, LocalizedString>(Strings.AsyncProcessWaitingFinalization), new Func <string, string, LocalizedString>(Strings.AsyncProcessCreated), new Func <string, string, LocalizedString>(Strings.AsyncProcessCompleting), new Func <string, string, LocalizedString>(Strings.AsyncProcessRemoving)));
}
protected override AsyncOperationStatus Run(AsyncOperationStatus status)
{
return(Parent.ProcessHandshake(status, true));
}
protected override AsyncOperationStatus Run(AsyncOperationStatus status)
{
return(Parent.ProcessShutdown(status));
}
/* * This will operate on the internal buffers and never block. */ protected abstract AsyncOperationStatus Run(AsyncOperationStatus status);
public static void CreateNotification(OrganizationId organizationId, string id, AsyncOperationType type, AsyncOperationStatus status, LocalizedString displayName, ADRecipientOrAddress owner, KeyValuePair <string, LocalizedString>[] extendedAttributes, bool throwOnError)
{
if (AsyncOperationNotificationDataProvider.IsAsyncNotificationDisabled())
{
ExTraceGlobals.StorageTracer.TraceWarning(0L, "DisableAsyncNotification is set in registry, no notification will be created.");
return;
}
if (string.IsNullOrEmpty(id))
{
throw new ArgumentNullException("id", "id is mandatory.");
}
try
{
AsyncOperationNotificationDataProvider asyncOperationNotificationDataProvider = new AsyncOperationNotificationDataProvider(organizationId);
if (asyncOperationNotificationDataProvider.FindItemByAlternativeId(id) != null)
{
throw new StoragePermanentException(ServerStrings.ErrorNotificationAlreadyExists);
}
asyncOperationNotificationDataProvider.Save(new AsyncOperationNotification
{
AlternativeId = id,
ExtendedAttributes = extendedAttributes,
StartedByValue = owner,
DisplayName = displayName,
Type = type,
Status = status
});
}
catch (Exception ex)
{
string printableId = AsyncOperationNotificationDataProvider.GetPrintableId(organizationId, id);
ExTraceGlobals.StorageTracer.TraceError <string, string>(0L, "AsyncOperationNotificationDataProvider::CreateNotification failed: {0}, message: {1}", printableId, ex.Message);
StorageGlobals.EventLogger.LogEvent(StorageEventLogConstants.Tuple_ErrorCreateNotification, printableId, new object[]
{
printableId,
ex
});
if (throwOnError)
{
throw;
}
}
}
public OperationResult(AsyncOperationStatus status, T value)
{
this.Succeeded = status == AsyncOperationStatus.Succeeded;
this.Value = value;
}
/// <summary>
/// Invoked when the operation completes.
/// </summary>
internal virtual void OnCompleted()
{
this.Status = AsyncOperationStatus.Completed;
}
AsyncOperationStatus ProcessHandshake (AsyncProtocolRequest asyncRequest, AsyncOperationStatus status)
{
Debug ("ProcessHandshake: {0}", status);
/*
* The first time we're called (AsyncOperationStatus.Initialize), we need to setup the SslContext and
* start the handshake.
*/
if (status == AsyncOperationStatus.Initialize) {
xobileTlsContext.StartHandshake ();
return AsyncOperationStatus.Continue;
} else if (status == AsyncOperationStatus.ReadDone) {
// remote prematurely closed connection.
throw new IOException ("Remote prematurely closed connection.");
} else if (status != AsyncOperationStatus.Continue) {
throw new InvalidOperationException ();
}
/*
* SSLHandshake() will return repeatedly with 'SslStatus.WouldBlock', we then need
* to take care of I/O and call it again.
*/
if (!xobileTlsContext.ProcessHandshake ()) {
/*
* Flush the internal write buffer.
*/
InnerFlush ();
return AsyncOperationStatus.Continue;
}
xobileTlsContext.FinishHandshake ();
return AsyncOperationStatus.Complete;
}
AsyncOperationStatus ProcessRead (AsyncProtocolRequest asyncRequest, AsyncOperationStatus status)
{
Debug ("ProcessRead - read user: {0} {1}", status, asyncRequest.UserBuffer);
int ret;
bool wantMore;
lock (ioLock) {
ret = Context.Read (asyncRequest.UserBuffer.Buffer, asyncRequest.UserBuffer.Offset, asyncRequest.UserBuffer.Size, out wantMore);
}
Debug ("ProcessRead - read user done: {0} - {1} {2}", asyncRequest.UserBuffer, ret, wantMore);
if (ret < 0) {
asyncRequest.UserResult = -1;
return AsyncOperationStatus.Complete;
}
asyncRequest.CurrentSize += ret;
asyncRequest.UserBuffer.Offset += ret;
asyncRequest.UserBuffer.Size -= ret;
Debug ("Process Read - read user done #1: {0} - {1} {2}", asyncRequest.UserBuffer, asyncRequest.CurrentSize, wantMore);
if (wantMore && asyncRequest.CurrentSize == 0)
return AsyncOperationStatus.WantRead;
asyncRequest.ResetRead ();
asyncRequest.UserResult = asyncRequest.CurrentSize;
return AsyncOperationStatus.Complete;
}
AsyncOperationStatus ProcessWrite (AsyncProtocolRequest asyncRequest, AsyncOperationStatus status)
{
Debug ("ProcessWrite - write user: {0} {1}", status, asyncRequest.UserBuffer);
if (asyncRequest.UserBuffer.Size == 0) {
asyncRequest.UserResult = asyncRequest.CurrentSize;
return AsyncOperationStatus.Complete;
}
int ret;
bool wantMore;
lock (ioLock) {
ret = Context.Write (asyncRequest.UserBuffer.Buffer, asyncRequest.UserBuffer.Offset, asyncRequest.UserBuffer.Size, out wantMore);
}
Debug ("ProcessWrite - write user done: {0} - {1} {2}", asyncRequest.UserBuffer, ret, wantMore);
if (ret < 0) {
asyncRequest.UserResult = -1;
return AsyncOperationStatus.Complete;
}
asyncRequest.CurrentSize += ret;
asyncRequest.UserBuffer.Offset += ret;
asyncRequest.UserBuffer.Size -= ret;
if (wantMore || writeBuffer.Size > 0)
return AsyncOperationStatus.WantWrite;
asyncRequest.ResetWrite ();
asyncRequest.UserResult = asyncRequest.CurrentSize;
return AsyncOperationStatus.Complete;
}
/// <summary>
/// Called when the operation state has changed. Default implementation does nothing.
/// </summary>
/// <param name="status">The new status value.</param>
/// <seealso cref="Status"/>
/// <seealso cref="TrySetScheduled"/>
/// <seealso cref="TrySetRunning"/>
/// <seealso cref="TrySetCanceled(bool)"/>
/// <seealso cref="TrySetCompleted(bool)"/>
/// <seealso cref="TrySetException(System.Exception, bool)"/>
/// <seealso cref="TrySetExceptions(IEnumerable{System.Exception}, bool)"/>
protected virtual void OnStatusChanged(AsyncOperationStatus status)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="AsyncResult"/> class with the specified <see cref="Status"/> and <see cref="CreationOptions"/>.
/// </summary>
/// <param name="status">Initial value of the <see cref="Status"/> property.</param>
/// <param name="asyncCallback">User-defined completion callback.</param>
/// <param name="asyncState">User-defined data returned by <see cref="AsyncState"/>.</param>
/// <param name="options">The <see cref="AsyncCreationOptions"/> used to customize the operation's behavior.</param>
public AsyncResult(AsyncOperationStatus status, AsyncCallback asyncCallback, object asyncState, AsyncCreationOptions options)
: this((int)status | ((int)options << _optionsOffset))
{
_asyncState = asyncState;
_callback = asyncCallback;
}
AsyncOperationStatus ProcessClose (AsyncProtocolRequest asyncRequest, AsyncOperationStatus status)
{
Debug ("ProcessClose: {0}", status);
lock (ioLock) {
if (xobileTlsContext == null)
return AsyncOperationStatus.Complete;
xobileTlsContext.Close ();
xobileTlsContext = null;
return AsyncOperationStatus.Continue;
}
}
AsyncOperationStatus ProcessFlush (AsyncProtocolRequest asyncRequest, AsyncOperationStatus status)
{
Debug ("ProcessFlush: {0}", status);
return AsyncOperationStatus.Complete;
}
AsyncOperationStatus ProcessOperation(AsyncOperationStatus status)
{
if (status == AsyncOperationStatus.WantRead) {
if (RequestedSize < 0)
throw new InvalidOperationException ();
else if (RequestedSize == 0)
return AsyncOperationStatus.Continue;
Parent.Debug ("ProcessOperation - read inner: {0}", RequestedSize);
var ret = Parent.InnerRead (RequestedSize);
Parent.Debug ("ProcessOperation - read inner done: {0} - {1}", RequestedSize, ret);
if (ret < 0)
return AsyncOperationStatus.ReadDone;
RequestedSize -= ret;
if (ret == 0 || RequestedSize == 0)
return AsyncOperationStatus.Continue;
else
return AsyncOperationStatus.WantRead;
} else if (status == AsyncOperationStatus.WantWrite) {
Parent.InnerWrite ();
return AsyncOperationStatus.Continue;
} else if (status == AsyncOperationStatus.Initialize || status == AsyncOperationStatus.Continue) {
Parent.Debug ("ProcessOperation - continue");
status = Operation (this, status);
Parent.Debug ("ProcessOperation - continue done: {0}", status);
return status;
} else if (status == AsyncOperationStatus.ReadDone) {
Parent.Debug ("ProcessOperation - read done");
status = Operation (this, status);
Parent.Debug ("ProcessOperation - read done: {0}", status);
return status;
}
throw new InvalidOperationException ();
}
