/// <summary>
/// Sets callback which executed when this future will completed.
/// </summary>
/// <param name="execute">A place which used to service specified callback.</param>
/// <param name="callback">A callback.</param>
public void OnComplete(Execute execute, FutureCallback <T> callback)
{
Ensure.NotNull(execute, nameof(execute));
Ensure.NotNull(callback, nameof(callback));
while (true)
{
var oldState = _state;
if (oldState.Callback != null)
{
throw new FutureException("Can't set Future callback because it already in set.");
}
var newState = new State(
oldState.Status,
oldState.Result,
oldState.Error,
execute,
callback);
var prevState = Interlocked.CompareExchange(ref _state, newState, oldState);
if (prevState == oldState)
{
PerformCallback(newState);
return;
}
}
}
/// <summary>
/// Adds a new callback to invoke if the future value is retrieved successfully or has an error.
/// </summary>
/// <param name="callback">The callback to invoke.</param>
/// <returns>The future so additional calls can be chained together.</returns>
public IFuture <T> OnComplete(FutureCallback <T> callback)
{
if (_state == FutureState.Success || _state == FutureState.Error)
{
if (Dispatcher.isMainThread)
{
callback(this);
}
else
{
Dispatcher.InvokeAsync(() => callback(this));
}
}
else
{
if (!_successCallbacks.Contains(callback))
{
_successCallbacks.Add(callback);
}
if (!_errorCallbacks.Contains(callback))
{
_errorCallbacks.Add(callback);
}
}
return(this);
}
public _PoolEntryFuture_170(AbstractConnPool <T, C, E> _enclosing, T route, object
state, Lock baseArg1, FutureCallback <E> baseArg2) : base(baseArg1, baseArg2)
{
this._enclosing = _enclosing;
this.route = route;
this.state = state;
}
public Task <R> Send <C, R>(C command)
{
var futureCallback = new FutureCallback <R>();
Send(command, futureCallback);
return(futureCallback.Task);
}
internal HttpRequestTaskCallable(HttpClient httpClient, IHttpUriRequest request,
HttpContext context, ResponseHandler <V> responseHandler, FutureCallback <V> callback
, FutureRequestExecutionMetrics metrics)
{
this.httpclient = httpClient;
this.responseHandler = responseHandler;
this.request = request;
this.context = context;
this.callback = callback;
this.metrics = metrics;
}
public State(
Status status,
T result,
Exception error,
Execute execute,
FutureCallback <T> callback)
{
Status = status;
Result = result;
Execute = execute;
Callback = callback;
Error = error;
}
public void Listen(FutureCallback <T> callback)
{
lock (mutex)
{
if (set)
{
callback(value);
}
else
{
listeners.Add(callback);
}
}
}
/// <summary>
/// Adds a new callback to invoke if the future value is retrieved successfully or has an error.
/// </summary>
/// <param name="callback">The callback to invoke.</param>
/// <returns>The future so additional calls can be chained together.</returns>
public IFuture <T> OnComplete(FutureCallback <T> callback)
{
if (_state == FutureState.Success || _state == FutureState.Error)
{
callback(this);
}
else
{
if (!_complationCallbacks.Contains(callback))
{
_complationCallbacks.Add(callback);
}
}
return(this);
}
public Task <object> Invoke(object proxy, MethodInfo invokedMethod, object[] args)
{
var command = args[0];
if (_metaDataExtractors.Length != 0)
{
var metaDataValues = new Dictionary <string, object>();
foreach (var extractor in _metaDataExtractors)
{
extractor.AddMetaData(args, metaDataValues);
}
if (!metaDataValues.IsEmpty())
{
command = GenericCommandMessage.AsCommandMessage(command).WithMetaData(metaDataValues);
}
}
if (_forceCallbacks || !_commandCallbacks.IsEmpty())
{
var callbacks = new List <ICommandCallback>();
var future = new FutureCallback <object>();
callbacks.Add(future);
foreach (var arg in args)
{
if (arg is ICommandCallback)
{
var callback = (ICommandCallback)arg;
callbacks.Add(callback);
}
}
callbacks.AddRange(_commandCallbacks);
Send(command, new CompositeCallback(callbacks));
return(future.Task);
}
else
{
SendAndForget(command);
return(null);
}
}
/// <summary>
/// Adds a new callback to invoke if the future has an error.
/// </summary>
/// <param name="callback">The callback to invoke.</param>
/// <returns>The future so additional calls can be chained together.</returns>
public IFuture <T> OnError(FutureCallback <T> callback)
{
if (_state == FutureState.Error)
{
if (Dispatcher.isMainThread)
{
callback(this);
}
else
{
Dispatcher.InvokeAsync(() => callback(this));
}
}
else if (_state != FutureState.Success && !_errorCallbacks.Contains(callback))
{
_errorCallbacks.Add(callback);
}
return(this);
}
/// <summary>Schedule a request for execution.</summary>
/// <remarks>Schedule a request for execution.</remarks>
/// <?></?>
/// <param name="request">request to execute</param>
/// <param name="context">optional context; use null if not needed.</param>
/// <param name="responseHandler">handler that will process the response.</param>
/// <param name="callback">
/// callback handler that will be called when the request is scheduled,
/// started, completed, failed, or cancelled.
/// </param>
/// <returns>HttpAsyncClientFutureTask for the scheduled request.</returns>
/// <exception cref="System.Exception">System.Exception</exception>
public virtual HttpRequestFutureTask <T> Execute <T>(IHttpUriRequest request, HttpContext
context, ResponseHandler <T> responseHandler, FutureCallback <T> callback)
{
if (closed.Get())
{
throw new InvalidOperationException("Close has been called on this httpclient instance."
);
}
metrics.GetScheduledConnections().IncrementAndGet();
HttpRequestTaskCallable <T> callable = new HttpRequestTaskCallable <T>(httpclient,
request, context, responseHandler, callback, metrics);
HttpRequestFutureTask <T> httpRequestFutureTask = new HttpRequestFutureTask <T>(request
, callable);
executorService.Execute(httpRequestFutureTask);
return(httpRequestFutureTask);
}
public IFuture <TResult> OnComplete(FutureCallback <TResult> callback)
{
return(this.future.OnComplete(callback));
}
internal PoolEntryFuture(Semaphore semaphore, FutureCallback <T> callback) : base()
{
this.condition = semaphore;
this.callback = callback;
}
/// <summary>
/// <inheritDoc></inheritDoc>
/// <p/>
/// Please note that this class does not maintain its own pool of execution
/// <see cref="Sharpen.Thread">Sharpen.Thread</see>
/// s. Therefore, one <b>must</b> call
/// <see cref="Sharpen.Future{V}.Get()">Sharpen.Future<V>.Get()</see>
/// or
/// <see cref="Sharpen.Future{V}.Get(long, Sharpen.TimeUnit)">Sharpen.Future<V>.Get(long, Sharpen.TimeUnit)
/// </see>
/// method on the
/// <see cref="Sharpen.Future{V}">Sharpen.Future<V></see>
/// returned by this method in order for the lease operation to complete.
/// </summary>
public virtual Future <E> Lease(T route, object state, FutureCallback <E> callback)
{
Args.NotNull(route, "Route");
Asserts.Check(!this.isShutDown, "Connection pool shut down");
return(new _PoolEntryFuture_170(this, route, state, this.Lock, callback));
}
internal static extern void AddCallback(FutureSafeHandle future, FutureCallback cb, IntPtr userdata);
public BasicFuture(FutureCallback <T> callback) : base()
{
this.callback = callback;
}
