public Fix44MessageHandler(
IEventTranslatorTwoArg <NewOrderEvent, Order, SessionID> translator,
IRingBufferCaller <NewOrderEvent> newOrderEventRingBufferCaller)
{
this.translator = translator;
this.newOrderEventRingBufferCaller = newOrderEventRingBufferCaller;
}
public void PublishEvents <A, B>(IEventTranslatorTwoArg <T, A, B> translator, int batchStartsAt, int batchSize, A[] arg0, B[] arg1)
{
CheckBounds(arg0, arg1, batchStartsAt, batchSize);
long finalSequence = _fields.Sequencer.Next(batchSize);
TranslateAndPublishBatch(translator, arg0, arg1, batchStartsAt, batchSize, finalSequence);
}
public void PublishEvents <TArg0, TArg1>(IEventTranslatorTwoArg <TEvent, TArg0, TArg1> translators, int batchStartsAt, int batchSize, TArg0[] arg0, TArg1[] arg1)
{
CheckBounds(arg0, arg1, batchStartsAt, batchSize);
var finalSequence = Sequencer.Next(batchSize);
TranslateAndPublishBatch(translators, arg0, arg1, batchStartsAt, batchSize, finalSequence);
}
/// <summary>
/// <see cref="IEventSink{T}.TryPublishEvent{A,B}(IEventTranslatorTwoArg{T,A,B},A,B)"/>
/// </summary>
public bool TryPublishEvent <A, B>(IEventTranslatorTwoArg <T, A, B> translator, A arg0, B arg1)
{
if (_fields.Sequencer.TryNext(out var sequence))
{
TranslateAndPublish(translator, sequence, arg0, arg1);
return(true);
}
return(false);
}
private void TranslateAndPublish <A, B>(IEventTranslatorTwoArg <T, A, B> translator, long sequence, A arg0, B arg1)
{
try
{
translator.TranslateTo(this[sequence], sequence, arg0, arg1);
}
finally
{
_fields.Sequencer.Publish(sequence);
}
}
/// <summary>
/// <see cref="IEventSink{T}.TryPublishEvents{A,B}(IEventTranslatorTwoArg{T,A,B},int,int,A[],B[])"/>
/// </summary>
public bool TryPublishEvents <A, B>(IEventTranslatorTwoArg <T, A, B> translator, int batchStartsAt, int batchSize, A[] arg0, B[] arg1)
{
CheckBounds(arg0, arg1, batchStartsAt, batchSize);
if (_fields.Sequencer.TryNext(batchSize, out var finalSequence))
{
TranslateAndPublishBatch(translator, arg0, arg1, batchStartsAt, batchSize, finalSequence);
return(true);
}
return(false);
}
public bool TryPublishEvent <TArg0, TArg1>(IEventTranslatorTwoArg <TEvent, TArg0, TArg1> translator, TArg0 arg0, TArg1 arg1)
{
try
{
Sequencer.TryNext(out long sequence);
TranslateAndPublish(translator, sequence, arg0, arg1);
return(true);
}
catch (InsufficientCapacityException e)
{
return(false);
}
}
public bool TryPublishEvent <A, B>(IEventTranslatorTwoArg <T, A, B> translator, A arg0, B arg1)
{
try
{
long sequence = _fields.Sequencer.TryNext();
TranslateAndPublish(translator, sequence, arg0, arg1);
return(true);
}
catch (InsufficientCapacityException)
{
return(false);
}
}
public bool TryPublishEvents <A, B>(IEventTranslatorTwoArg <T, A, B> translator, int batchStartsAt, int batchSize, A[] arg0, B[] arg1)
{
CheckBounds(arg0, arg1, batchStartsAt, batchSize);
try
{
long finalSequence = _fields.Sequencer.TryNext(batchSize);
TranslateAndPublishBatch(translator, arg0, arg1, batchStartsAt, batchSize, finalSequence);
return(true);
}
catch (InsufficientCapacityException)
{
return(false);
}
}
private void TranslateAndPublish <TArg0, TArg1>(
IEventTranslatorTwoArg <TEvent, TArg0, TArg1> translator,
long sequence, TArg0 arg0,
TArg1 arg1)
{
try
{
translator.TranslateTo(Get(sequence), sequence, arg0, arg1);
}
finally
{
Sequencer.Publish(sequence);
}
}
private void TranslateAndPublishBatch <A, B>(IEventTranslatorTwoArg <T, A, B> translator, A[] arg0,
B[] arg1, int batchStartsAt, int batchSize,
long finalSequence)
{
long initialSequence = finalSequence - (batchSize - 1);
try
{
long sequence = initialSequence;
int batchEndsAt = batchStartsAt + batchSize;
for (int i = batchStartsAt; i < batchEndsAt; i++)
{
translator.TranslateTo(this[sequence], sequence++, arg0[i], arg1[i]);
}
}
finally
{
_fields.Sequencer.Publish(initialSequence, finalSequence);
}
}
private void TranslateAndPublishBatch <TArg0, TArg1>(
IEventTranslatorTwoArg <TEvent, TArg0, TArg1> translator,
TArg0[] arg0, TArg1[] arg1,
int batchStartsAt, int batchSize,
long finalSequence)
{
var initialSequence = finalSequence - (batchSize - 1);
try
{
var sequence = initialSequence;
var batchEndsAt = batchStartsAt + batchSize;
for (int i = batchStartsAt; i < batchEndsAt; i++)
{
translator.TranslateTo(Get(sequence), sequence++, arg0[i], arg1[i]);
}
}
finally
{
Sequencer.Publish(initialSequence, finalSequence);
}
}
public bool TryPublishEvents <A, B>(IEventTranslatorTwoArg <T, A, B> translator, A[] arg0, B[] arg1)
{
return(TryPublishEvents(translator, 0, arg0.Length, arg0, arg1));
}
public bool TryPublishEvents <A, B>(IEventTranslatorTwoArg <TEvent, A, B> translator, int batchStartsAt, int batchSize, A[] arg0, B[] arg1)
{
throw new NotImplementedException();
}
public void PublishEvents <A, B>(IEventTranslatorTwoArg <T, A, B> translator, A[] arg0, B[] arg1)
{
PublishEvents(translator, 0, arg0.Length, arg0, arg1);
}
public void PublishEvent <A, B>(IEventTranslatorTwoArg <T, A, B> translator, A arg0, B arg1)
{
long sequence = _fields.Sequencer.Next();
TranslateAndPublish(translator, sequence, arg0, arg1);
}
public void PublishEvents <A, B>(IEventTranslatorTwoArg <TEvent, A, B> translator, A[] arg0, B[] arg1)
{
throw new NotImplementedException();
}
public void PublishEvents <TArg0, TArg1>(IEventTranslatorTwoArg <TEvent, TArg0, TArg1> translators, TArg0[] arg0, TArg1[] arg1)
{
PublishEvents(translators, 0, arg0.Length, arg0, arg1);
}
public void PublishEvent <TArg0, TArg1>(IEventTranslatorTwoArg <TEvent, TArg0, TArg1> translator, TArg0 arg0, TArg1 arg1)
{
var sequence = Sequencer.Next();
TranslateAndPublish(translator, sequence, arg0, arg1);
}
public void PublishEvent <TArg0, TArg1>(IEventTranslatorTwoArg <TEvent, TArg0, TArg1> translator, TArg0 arg0, TArg1 arg1)
{
throw new NotImplementedException();
}
/// <summary> /// Publish an event to the ring buffer. /// </summary> /// <typeparam name="A">Class of the user supplied argument.</typeparam> /// <typeparam name="B">Class of the user supplied argument.</typeparam> /// <param name="eventTranslator">the translator that will load data into the event.</param> /// <param name="arg0">The first argument to load into the event</param> /// <param name="arg1">The second argument to load into the event</param> public void PublishEvent <A, B>(IEventTranslatorTwoArg <T, A, B> eventTranslator, A arg0, B arg1) => _ringBuffer.PublishEvent(eventTranslator, arg0, arg1);
/// <summary>
/// Publish an event to the ring buffer.
/// </summary>
/// <typeparam name="TArg0">Class of the user supplied argument.</typeparam>
/// <typeparam name="TArg1">Class of the user supplied argument.</typeparam>
/// <param name="eventTranslator">the translator that will load data into the event.</param>
/// <param name="arg0">The first argument to load into the event</param>
/// <param name="arg1">The second argument to load into the event</param>
public void PublishEvent <TArg0, TArg1>(IEventTranslatorTwoArg <T, TArg0, TArg1> eventTranslator, TArg0 arg0,
TArg1 arg1)
{
_ringBuffer.PublishEvent(eventTranslator, arg0, arg1);
}
public LimitOrderMatchingService(
IOrderBookRepository orderBookRepository,
IEventTranslatorTwoArg <CancelOrderEvent, OrderMatchReport, SessionID> translator)
: base(orderBookRepository)
{
}
