public RuntimePipeline(IPipelineHandler handler, ILogger logger)
{
if (handler == null)
{
throw new ArgumentNullException("handler");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
_handler = handler;
_handler.Logger = logger;
_logger = logger;
}
/// <summary>
/// Inserts the given handler after current handler in the pipeline.
/// </summary>
/// <param name="handler">Handler to be inserted in the pipeline.</param>
/// <param name="current">Handler after which the given handler is inserted.</param>
private static void InsertHandler(IPipelineHandler handler, IPipelineHandler current)
{
var next = current.InnerHandler;
current.InnerHandler = handler;
handler.OuterHandler = current;
if (next != null)
{
var innerMostHandler = GetInnermostHandler(handler);
innerMostHandler.InnerHandler = next;
next.OuterHandler = innerMostHandler;
}
}
/// <summary>
/// Replaces the first occurance of a handler of type T with the given handler.
/// </summary>
/// <typeparam name="T">Type of the handler which will be replaced.</typeparam>
/// <param name="handler">The handler to be added to the pipeline.</param>
public void ReplaceHandler <T>(IPipelineHandler handler)
where T : IPipelineHandler
{
if (handler == null)
{
throw new ArgumentNullException("handler");
}
var type = typeof(T);
IPipelineHandler previous = null;
var current = _handler;
while (current != null)
{
if (current.GetType() == type)
{
// Replace current with handler.
handler.InnerHandler = current.InnerHandler;
handler.OuterHandler = current.OuterHandler;
if (previous != null)
{
// Wireup previous handler
previous.InnerHandler = handler;
}
else
{
// Current is the top, replace it.
_handler = handler;
}
if (current.InnerHandler != null)
{
// Wireup next handler
current.InnerHandler.OuterHandler = handler;
}
// Cleanup current
current.InnerHandler = null;
current.OuterHandler = null;
SetHandlerProperties(handler);
return;
}
previous = current;
current = current.InnerHandler;
}
throw new InvalidOperationException(
string.Format(CultureInfo.InvariantCulture, "Cannot find a handler of type {0}", type.Name));
}
/// <summary>
/// Constructor for RuntimePipeline.
/// </summary>
/// <param name="handler">The handler with which the pipeline is initalized.</param>
public RuntimePipeline(IPipelineHandler handler)
{
if (handler == null)
{
throw new ArgumentNullException("handler");
}
var logger =
Amazon.Runtime.Internal.Util.Logger.GetLogger(typeof(RuntimePipeline));
_handler = handler;
_handler.Logger = logger;
_logger = logger;
}
public IPipelineBuilder <T> Use(IPipelineHandler <T> handler)
{
_ = handler ?? throw new ArgumentNullException(nameof(handler));
if (_first is null)
{
_first = handler;
_last = _first;
}
else
{
_last.SetNext(handler);
_last = handler;
}
return(this);
}
public void AddHandler(IPipelineHandler handler)
{
if (handler == null)
{
throw new ArgumentNullException("handler");
}
ThrowIfDisposed();
IPipelineHandler innermostHandler = GetInnermostHandler(handler);
if (_handler != null)
{
innermostHandler.InnerHandler = _handler;
_handler.OuterHandler = innermostHandler;
}
_handler = handler;
SetHandlerProperties(handler);
}
public XPipelineContext <THandler> AddLast(IPipelineHandler <THandler> handler)
{
var context = new XPipelineContext <THandler>(handler);
var origin_prev = _last;
_last = context;
if (origin_prev != null)
{
origin_prev.Next = context;
context.Prev = origin_prev;
}
if (_head == null)
{
_head = origin_prev != null ? origin_prev : _last;
}
return(context);
}
public void AddHandlerAfter <T>(IPipelineHandler handler) where T : IPipelineHandler
{
if (handler == null)
{
throw new ArgumentNullException("handler");
}
ThrowIfDisposed();
Type typeFromHandle = typeof(T);
for (IPipelineHandler pipelineHandler = _handler; pipelineHandler != null; pipelineHandler = pipelineHandler.InnerHandler)
{
if (pipelineHandler.GetType() == typeFromHandle)
{
InsertHandler(handler, pipelineHandler);
SetHandlerProperties(handler);
return;
}
}
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Cannot find a handler of type {0}", typeFromHandle.Name));
}
public void ReplaceHandler <T>(IPipelineHandler handler) where T : IPipelineHandler
{
if (handler == null)
{
throw new ArgumentNullException("handler");
}
ThrowIfDisposed();
Type typeFromHandle = typeof(T);
IPipelineHandler pipelineHandler = null;
for (IPipelineHandler pipelineHandler2 = _handler; pipelineHandler2 != null; pipelineHandler2 = pipelineHandler2.InnerHandler)
{
if (pipelineHandler2.GetType() == typeFromHandle)
{
handler.InnerHandler = pipelineHandler2.InnerHandler;
handler.OuterHandler = pipelineHandler2.OuterHandler;
if (pipelineHandler != null)
{
pipelineHandler.InnerHandler = handler;
}
else
{
_handler = handler;
}
if (pipelineHandler2.InnerHandler != null)
{
pipelineHandler2.InnerHandler.OuterHandler = handler;
}
pipelineHandler2.InnerHandler = null;
pipelineHandler2.OuterHandler = null;
SetHandlerProperties(handler);
return;
}
pipelineHandler = pipelineHandler2;
}
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Cannot find a handler of type {0}", typeFromHandle.Name));
}
/// <summary>
/// Adds a handler before the first instance of handler of type T.
/// </summary>
/// <typeparam name="T">Type of the handler before which the given handler instance is added.</typeparam>
/// <param name="handler">The handler to be added to the pipeline.</param>
public void AddHandlerBefore <T>(IPipelineHandler handler)
where T : IPipelineHandler
{
if (handler == null)
{
throw new ArgumentNullException("handler");
}
ThrowIfDisposed();
var type = typeof(T);
if (_handler.GetType() == type)
{
// Add the handler to the top of the pipeline
AddHandler(handler);
SetHandlerProperties(handler);
return;
}
var current = _handler;
while (current != null)
{
if (current.InnerHandler != null &&
current.InnerHandler.GetType() == type)
{
InsertHandler(handler, current);
SetHandlerProperties(handler);
return;
}
current = current.InnerHandler;
}
throw new InvalidOperationException(
string.Format(CultureInfo.InvariantCulture, "Cannot find a handler of type {0}", type.Name));
}
public XPipelineContext <THandler> AddFirst(IPipelineHandler <THandler> handler)
{
var context = new XPipelineContext <THandler>(handler);
var _origin_first = _head;
context.Next = _origin_first;
_head = context;
if (_origin_first != null)
{
_origin_first.Prev = _head;
if (_last == null)
{
_last = _origin_first;
}
}
else
{
if (_last == null)
{
_last = context;
}
}
return(context);
}
public XPipelineContext(IPipelineHandler <THandler> handler)
{
_handler = handler;
Next = null;
Prev = null;
}
public Pipeline AddHandler(IPipelineHandler handler)
{
_pipelineHandlers.Add(new PipelineOption(null, handler));
return(this);
}
private void SetHandlerProperties(IPipelineHandler handler)
{
handler.Logger = _logger;
}
public PipelineHandlerCollection Add(IPipelineHandler handler) => AddRange(handler);
public IPipelineHandler <T> SetNext(IPipelineHandler <T> handler)
{
_next = handler;
return(handler);
}
public PipelineHandlerToDelegatingHandlerConverter(T handler)
{
this.handler = handler;
}
private void SetHandlerProperties(IPipelineHandler handler)
{
ThrowIfDisposed();
handler.Logger = _logger;
}
public PipelineOption(Func <IPipelineHandler> factory, IPipelineHandler handler)
{
_factory = factory;
_handler = handler;
}
public Notification(IPipelineHandler handler, string errorMessage)
{
Handler = handler;
ErrorMessage = errorMessage;
}
private void SetHandlerProperties(IPipelineHandler handler)
{
ThrowIfDisposed();
}
public PipelineDependencyException(IPipelineHandler handler, params string[] dependencies)
: base(handler, FormatErrorMessage(handler, dependencies))
{
}
public PipelineException(IPipelineHandler pipelineHandler, string message, Exception innerException = null)
: base(message, innerException)
{
PipelineHandler = pipelineHandler;
}
public static PipelineContext AddNotification(this PipelineContext context, IPipelineHandler handler, string errorMessage) => context.Add(new Notification(handler, errorMessage));
public void AddLast(IPipelineHandler handler)
{
}
