/// <summary>
/// see RepeatTemplate#WaitForResults
/// </summary>
/// <param name="state"></param>
/// <returns></returns>
protected override bool WaitForResults(IRepeatInternalState state)
{
IResultQueue <IResultHolder> queue = ((ResultQueueInternalState)state).ResultQueue;
bool result = true;
while (queue.IsExpecting())
{
// Careful that no runnables that are not going to finish ever get
// onto the queue, else this may block forever.
IResultHolder future;
try
{
future = queue.Take();
}
catch (ThreadInterruptedException)
{
Thread.CurrentThread.Interrupt();
throw new RepeatException("InterruptedException while waiting for result.");
}
if (future.Error != null)
{
state.GetExceptions().Add(future.Error);
result = false;
}
else
{
RepeatStatus status = future.Result;
result = result && CanContinue(status);
ExecuteAfterInterceptors(future.Context, status);
}
}
Assert.State(queue.IsEmpty(), "Future results queue should be empty at end of batch.");
return(result);
}
/// <summary>
/// @see ITasklet#Execute.
/// </summary>
/// <param name="contribution"></param>
/// <param name="chunkContext"></param>
/// <returns></returns>
public RepeatStatus Execute(StepContribution contribution, ChunkContext chunkContext)
{
Chunk <TI> inputs = (Chunk <TI>)chunkContext.GetAttribute(InputsKey);
if (inputs == null)
{
inputs = _chunkProvider.Provide(contribution);
if (_buffering)
{
chunkContext.SetAttribute(InputsKey, inputs);
}
}
_chunkProcessor.Process(contribution, inputs);
_chunkProvider.PostProcess(contribution, inputs);
// Allow a message coming back from the processor to say that we
// are not done yet
if (inputs.Busy)
{
if (_logger.IsDebugEnabled)
{
_logger.Debug("Inputs still busy");
}
return(RepeatStatus.Continuable);
}
chunkContext.RemoveAttribute(InputsKey);
chunkContext.SetComplete();
if (_logger.IsDebugEnabled)
{
_logger.Debug("Inputs not busy, ended: {0}", inputs.End);
}
return(RepeatStatus.ContinueIf(!inputs.End));
}
/// <summary>
/// If exit status is not continuable returns <c>true</c>, otherwise
/// delegates to #IsComplete(IRepeatContext).
/// </summary>
/// <param name="context"></param>
/// <param name="result"></param>
/// <returns></returns>
public virtual bool IsComplete(IRepeatContext context, RepeatStatus result)
{
if (result != null && !result.IsContinuable())
{
return(true);
}
return(IsComplete(context));
}
/// <summary>
/// If exit status is not continuable returns <code>true</code>, otherwise
/// delegates to #IsComplete(IRepeatContext).
/// </summary>
/// <param name="context"></param>
/// <param name="result"></param>
/// <returns></returns>
public virtual bool IsComplete(IRepeatContext context, RepeatStatus result)
{
if (result != null && !result.IsContinuable())
{
return true;
}
return IsComplete(context);
}
/// <summary>
/// Delegates to the Completion policy.
/// </summary>
/// <param name="context"></param>
/// <param name="result"></param>
/// <returns></returns>
protected bool IsComplete(IRepeatContext context, RepeatStatus result)
{
bool complete = _completionPolicy.IsComplete(context, result);
if (complete && Logger.IsDebugEnabled)
{
Logger.Debug("Repeat is complete according to policy and result value.");
}
return(complete);
}
private async void onRepeatStatus(object sender, RepeatStatus e)
{
switch (e)
{
case RepeatStatus.None: await mqtt?.Publish("onkyo/status/repeat", "no", retain : true); break;
case RepeatStatus.One: await mqtt?.Publish("onkyo/status/repeat", "single", retain : true); break;
case RepeatStatus.All: await mqtt?.Publish("onkyo/status/repeat", "repeat", retain : true); break;
}
}
public void Play(RepeatStatus repeat, ShuffleStatus shuffle, PlayStatus play)
{
if (play == PlayStatus.PLAY)
{
wmp.controls.play();
}
else if (play == PlayStatus.PAUSE)
{
wmp.controls.pause();
}
}
/// <summary>
/// Convenience method to execute after interceptors on a callback result.
/// </summary>
/// <param name="context"></param>
/// <param name="value"></param>
protected void ExecuteAfterInterceptors(IRepeatContext context, RepeatStatus value)
{
// Don't re-throw exceptions here: let the exception handler deal with
// that...
if (value != null && value.IsContinuable())
{
for (int i = _listeners.Length; i-- > 0;)
{
IRepeatListener interceptor = _listeners[i];
interceptor.After(context, value);
}
}
}
/// <summary>
/// NONE -> ALL -> ONE -> NONE ...
/// </summary>
public static void SetRepeatStatus(ref RepeatStatus currentStatus, BunifuImageButton button)
{
if (currentStatus == RepeatStatus.NONE)//next will be ALL
{
currentStatus = RepeatStatus.ALL;
button.Image = Image.FromFile(_Environment.g_SolutionDir + "/UIDesign/Asset/button_repeatall_background.png");
}
else if (currentStatus == RepeatStatus.ALL)//next will be ONE
{
currentStatus = RepeatStatus.ONE;
button.Image = Image.FromFile(_Environment.g_SolutionDir + "/UIDesign/Asset/button_repeatone_background.png");
}
else if (currentStatus == RepeatStatus.ONE)//next will be NONE
{
currentStatus = RepeatStatus.NONE;
button.Image = Image.FromFile(_Environment.g_SolutionDir + "/UIDesign/Asset/button_repeatnone_background.png");
}
}
/// <summary>
/// True if the result is null, or a RepeatStatus indicating completion.
/// </summary>
/// <param name="context"></param>
/// <param name="result"></param>
/// <returns></returns>
public override bool IsComplete(IRepeatContext context, RepeatStatus result)
{
return (result == null || !result.IsContinuable());
}
/// <summary>
/// Terminates if the chunk size has been reached, or the result is null.
/// </summary>
/// <param name="context"></param>
/// <param name="result"></param>
/// <returns></returns>
public override bool IsComplete(IRepeatContext context, RepeatStatus result)
{
return base.IsComplete(context, result) ||
((SimpleTerminationContext)context).IsComplete(this);
}
/// <summary>
/// Check return value from batch operation.
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
protected bool CanContinue(RepeatStatus value)
{
return value.IsContinuable();
}
private void formMainFrame_Load(object sender, EventArgs e)
{
m_buttonRepeat = RepeatStatus.NONE;
m_buttonPlay = PlayStatus.PAUSE;
}
/// <summary>
/// Convenience method to execute after interceptors on a callback result.
/// </summary>
/// <param name="context"></param>
/// <param name="value"></param>
protected void ExecuteAfterInterceptors(IRepeatContext context, RepeatStatus value)
{
// Don't re-throw exceptions here: let the exception handler deal with
// that...
if (value != null && value.IsContinuable())
{
for (int i = _listeners.Length; i-- > 0; )
{
IRepeatListener interceptor = _listeners[i];
interceptor.After(context, value);
}
}
}
/// <summary>
/// Delegates to the Completion policy.
/// </summary>
/// <param name="context"></param>
/// <param name="result"></param>
/// <returns></returns>
protected bool IsComplete(IRepeatContext context, RepeatStatus result)
{
bool complete = _completionPolicy.IsComplete(context, result);
if (complete && Logger.IsDebugEnabled)
{
Logger.Debug("Repeat is complete according to policy and result value.");
}
return complete;
}
/// <summary>
/// True if the result is null, or a RepeatStatus indicating completion.
/// </summary>
/// <param name="context"></param>
/// <param name="result"></param>
/// <returns></returns>
public override bool IsComplete(IRepeatContext context, RepeatStatus result)
{
return(result == null || !result.IsContinuable());
}
/// <summary>
///
/// </summary>
/// <param name="callback"></param>
/// <returns></returns>
private RepeatStatus ExecuteInternal(RepeatCallback callback)
{
// Reset the termination policy if there is one...
IRepeatContext context = Start();
// Make sure if we are already marked complete before we start then no
// processing takes place.
bool running = !IsMarkedComplete(context);
foreach (IRepeatListener interceptor in _listeners)
{
interceptor.Open(context);
running = running && !IsMarkedComplete(context);
if (!running)
{
break;
}
}
// Return value, default is to allow continued processing.
RepeatStatus result = RepeatStatus.Continuable;
IRepeatInternalState state = CreateInternalState(context);
// This is the list of exceptions thrown by all active callbacks
ICollection <System.Exception> exceptions = state.GetExceptions();
// Keep a separate list of exceptions we handled that need to be
// rethrown
ICollection <System.Exception> deferred = new List <System.Exception>();
try
{
while (running)
{
#region WhileRunning
/*
* Run the before interceptors here, not in the task executor so
* that they all happen in the same thread - it's easier for
* tracking batch status, amongst other things.
*/
foreach (IRepeatListener interceptor in _listeners)
{
interceptor.Before(context);
// Allow before interceptors to veto the batch by setting
// flag.
running = running && !IsMarkedComplete(context);
}
// Check that we are still running (should always be true) ...
if (running)
{
#region Running
try
{
result = GetNextResult(context, callback, state);
ExecuteAfterInterceptors(context, result);
}
catch (System.Exception exception)
{
DoHandle(exception, context, deferred);
}
// N.B. the order may be important here:
if (IsComplete(context, result) || IsMarkedComplete(context) || deferred.Any())
{
running = false;
}
#endregion
}
#endregion
}
result = result.And(WaitForResults(state));
foreach (System.Exception exception in exceptions)
{
DoHandle(exception, context, deferred);
}
// Explicitly drop any references to internal state...
// useless ?
state = null;
}
/*
* No need for explicit catch here - if the business processing threw an
* exception it was already handled by the helper methods. An exception
* here is necessarily fatal.
*/
finally
{
#region HandleFinally
HandleFinally(deferred, _listeners, context);
#endregion
}
return(result);
}
/// <summary>
/// Terminates if the chunk size has been reached, or the result is null.
/// </summary>
/// <param name="context"></param>
/// <param name="result"></param>
/// <returns></returns>
public override bool IsComplete(IRepeatContext context, RepeatStatus result)
{
return(base.IsComplete(context, result) ||
((SimpleTerminationContext)context).IsComplete(this));
}
/// <summary>
/// Check return value from batch operation.
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
protected bool CanContinue(RepeatStatus value)
{
return(value.IsContinuable());
}
