/// <summary>
/// Takes a processing structure, finds all nodes that implement IErrorProcessor and sets the error serializer with a specific one.
/// </summary>
/// <typeparam name="TResult">Type of the result</typeparam>
/// <typeparam name="TSerializer">Type of the error serializer</typeparam>
/// <param name="processor">Processor to add serializer to</param>
/// <param name="serializer">Serializer to add to processors</param>
public static void SetErrorSerializerForStructure <TResult, TSerializer>(
IProcessorStructure <TResult, TSerializer> processor, TSerializer serializer)
where TSerializer : ISerializer
{
foreach (var node in processor)
{
if (node is IErrorProcessor <TSerializer> )
{
(node as IErrorProcessor <TSerializer>).ErrorSerializer = serializer;
}
ProcessNode <TResult, TSerializer>(node, "SetErrorSerializerForStructure", serializer);
}
}
public RestClientBuilder(TSerializer serializer, TSerializer errorSerializer, IRestClientExecuter restClientExecuter, string host, string path, OptionStrict <object> data, Method method, Func <Processors.ExceptionProcessor <TResult, RestBusinessError, RestException, TSerializer> > exProcesorCreator)
{
this.host = host;
this.path = path;
this.data = data;
this.method = method;
this.serializer = serializer;
this.errorSerializer = errorSerializer;
this.processor = new ProcessorStructure <TResult, TSerializer>();
this.certificateList = new List <X509Certificate>();
this.headers = new List <RestSharp.HttpHeader>();
this.restClientExecuter = restClientExecuter;
this.exProcesorCreator = exProcesorCreator;
this.proxy = OptionStrict <System.Net.IWebProxy> .Nothing;
}
/// <summary>
/// Takes a processing structure from a REST response, and it adds a default processor to the end of each leaf.
/// Because the default processor is the identity when composed on the right, it can be added without problems and it's only done so there exists at least one node to force the processing of a response.
///
/// Ej:
/// (P1 -> P2) goes to (P1 -> P2 -> DEF)
/// (R1 * P1) -> P2 goes to (R1 * (P1 -> DEF)) -> P2 -> DEF
/// </summary>
/// <typeparam name="TResult">Type of the result</typeparam>
/// <typeparam name="TSerializer">Type of the serializer</typeparam>
/// <param name="processor">Processor structure</param>
public static void AddNeutralProcessorAtEndsForStructure <TResult, TSerializer>(
IProcessorStructure <TResult, TSerializer> processor)
where TSerializer : ISerializer
{
//If it only has a single processor or it is one by default, then we don't do anything
if (processor.Count == 1 && processor[0] is SuccessProcessor <TResult, TSerializer> )
{
return;
}
//It adds the default processing node to all its nodes
foreach (var node in processor)
{
if (!InheritsFromExceptionProcessor(node.GetType()))
{
ProcessNode <TResult, TSerializer>(node, "AddNeutralProcessorAtEndsForStructure");
}
}
//Then it adds it to the end of the structure itself
processor.Add(new SuccessProcessor <TResult, TSerializer>().Default());
}
public EitherRestErrorProcessor(IProcessorStructure <TResult, TSerializer> processorStructure)
: base(processorStructure)
{
}
public IRestClientBuilder <TResult, TSerializer> AddProcessors(params IProcessorNode <TResult, TSerializer>[] processors)
{
processor = new ProcessorStructure <TResult, TSerializer>(processors);
return(this);
}
public EitherProcessor(IProcessorStructure <TRight, TSerializer> processorStructure)
: base(processorStructure)
{
leftProcessorStructure = new ProcessorStructure <TLeft, TSerializer>();
}
public EitherProcessor()
{
leftProcessorStructure = new ProcessorStructure <TLeft, TSerializer>();
}
/// <summary>
/// Creates a recursive processor with empty child processor nodes.
/// </summary>
protected RecursiveProcessorNode()
{
this.ProcessorStructure = new UruIT.RESTClient.ProcessorStructure <TRecursive, TSerializer>();
}
/// <summary>
/// Creates a recursive processor with an already existing set of child processors
/// </summary>
/// <param name="processorStructure"></param>
protected RecursiveProcessorNode(IProcessorStructure <TRecursive, TSerializer> processorStructure)
{
this.ProcessorStructure = processorStructure;
}
public OptionAsNotFoundProcessor(IProcessorStructure <TResult, TSerializer> processorStructure)
: base(processorStructure)
{
}
