/** * @see com.lmax.disruptor.EventSink#publishEvents(com.lmax.disruptor.EventTranslatorThreeArg, Object[], Object[], Object[]) * com.lmax.disruptor.EventSink#publishEvents(com.lmax.disruptor.EventTranslatorThreeArg, A[], B[], C[]) */ @Override public <A, B, C> void publishEvents(EventTranslatorThreeArg<E, A, B, C> translator, A[] arg0, B[] arg1, C[] arg2) { publishEvents(translator, 0, arg0.length, arg0, arg1, arg2); }
/** * @see com.lmax.disruptor.EventSink#publishEvents(com.lmax.disruptor.EventTranslatorTwoArg, Object[], Object[]) * com.lmax.disruptor.EventSink#publishEvents(com.lmax.disruptor.EventTranslatorTwoArg, A[], B[]) */ @Override public <A, B> void publishEvents(EventTranslatorTwoArg<E, A, B> translator, A[] arg0, B[] arg1) { publishEvents(translator, 0, arg0.length, arg0, arg1); }
/** * Publish a batch of events to the ring buffer. * * @param <A> Class of the user supplied argument. * @param eventTranslator the translator that will load data into the event. * @param arg An array single arguments to load into the events. One Per event. */ public <A> void publishEvents(final EventTranslatorOneArg<T, A> eventTranslator, final A[] arg) { ringBuffer.publishEvents(eventTranslator, arg); }
/** * @see com.lmax.disruptor.EventSink#publishEvents(com.lmax.disruptor.EventTranslator[]) */ @Override public void publishEvents(EventTranslator<E>[] translators) { publishEvents(translators, 0, translators.length); }
/** * @see com.lmax.disruptor.EventSink#publishEvents(com.lmax.disruptor.EventTranslatorVararg, java.lang.Object[][]) */ @Override public void publishEvents(EventTranslatorVararg<E> translator, Object[]... args) { publishEvents(translator, 0, args.length, args); }
/** * @see com.lmax.disruptor.EventSink#publishEvents(com.lmax.disruptor.EventTranslatorOneArg, Object[]) * com.lmax.disruptor.EventSink#publishEvents(com.lmax.disruptor.EventTranslatorOneArg, A[]) */ @Override public <A> void publishEvents(EventTranslatorOneArg<E, A> translator, A[] arg0) { publishEvents(translator, 0, arg0.length, arg0); }
@Test public void shouldPublishEventsTwoArgWithBatchSizeOfOne() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorTwoArg<Object[], String, String> translator = new TwoArgEventTranslator(); ringBuffer.publishEvents(translator, 0, 1, new String[]{"Foo0", "Foo1"}, new String[]{"Bar0", "Bar1"}); ringBuffer.tryPublishEvents(translator, 0, 1, new String[]{"Foo2", "Foo3"}, new String[]{"Bar2", "Bar3"}); assertThat( ringBuffer, ringBufferWithEvents( is((Object) "Foo0Bar0-0"), is((Object) "Foo2Bar2-1"), is( nullValue()), is(nullValue()))); }
@Test public void shouldPublishEventsOneArgBatchSizeOfOne() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorOneArg<Object[], String> translator = new OneArgEventTranslator(); ringBuffer.publishEvents(translator, 0, 1, new String[]{"Foo", "Foo"}); assertTrue(ringBuffer.tryPublishEvents(translator, 0, 1, new String[]{"Foo", "Foo"})); assertThat( ringBuffer, ringBufferWithEvents( is((Object) "Foo-0"), is((Object) "Foo-1"), is(nullValue()), is( nullValue()))); }
@Test(expected = IllegalArgumentException.class) public void shouldNotPublishEventsOneArgWhenBatchExtendsPastEndOfArray() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorOneArg<Object[], String> translator = new OneArgEventTranslator(); try { ringBuffer.publishEvents(translator, 1, 3, new String[]{"Foo", "Foo"}); } finally { assertEmptyRingBuffer(ringBuffer); } }
@SuppressWarnings("unchecked") @Test(expected = IllegalArgumentException.class) public void shouldNotPublishEventsWhenBatchSizeIsNegative() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslator<Object[]> translator = new NoArgEventTranslator(); try { ringBuffer.publishEvents(new EventTranslator[]{translator, translator, translator, translator}, 1, -1); } finally { assertEmptyRingBuffer(ringBuffer); } }
@SuppressWarnings("unchecked") @Test(expected = IllegalArgumentException.class) public void shouldNotPublishEventsWhenBatchStartsAtIsNegative() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslator<Object[]> translator = new NoArgEventTranslator(); try { ringBuffer.publishEvents(new EventTranslator[]{translator, translator, translator, translator}, -1, 2); } finally { assertEmptyRingBuffer(ringBuffer); } }
@Test(expected = IllegalArgumentException.class) public void shouldNotPublishEventsOneArgWhenBatchSizeIs0() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorOneArg<Object[], String> translator = new OneArgEventTranslator(); try { ringBuffer.publishEvents(translator, 1, 0, new String[]{"Foo", "Foo"}); } finally { assertEmptyRingBuffer(ringBuffer); } }
@Test(expected = IllegalArgumentException.class) public void shouldNotPublishEventsOneArgWhenBatchSizeIsNegative() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorOneArg<Object[], String> translator = new OneArgEventTranslator(); try { ringBuffer.publishEvents(translator, 1, -1, new String[]{"Foo", "Foo"}); } finally { assertEmptyRingBuffer(ringBuffer); } }
@Test public void shouldPublishEventsTwoArgWithinBatch() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorTwoArg<Object[], String, String> translator = new TwoArgEventTranslator(); ringBuffer.publishEvents( translator, 1, 2, new String[]{"Foo0", "Foo1", "Foo2"}, new String[]{"Bar0", "Bar1", "Bar2"}); ringBuffer.tryPublishEvents( translator, 1, 2, new String[]{"Foo3", "Foo4", "Foo5"}, new String[]{"Bar3", "Bar4", "Bar5"}); assertThat(ringBuffer, ringBufferWithEvents("Foo1Bar1-0", "Foo2Bar2-1", "Foo4Bar4-2", "Foo5Bar5-3")); }
@Test public void shouldPublishEventsTwoArg() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorTwoArg<Object[], String, String> translator = new TwoArgEventTranslator(); ringBuffer.publishEvents(translator, new String[]{"Foo", "Foo"}, new String[]{"Bar", "Bar"}); ringBuffer.tryPublishEvents(translator, new String[]{"Foo", "Foo"}, new String[]{"Bar", "Bar"}); assertThat(ringBuffer, ringBufferWithEvents("FooBar-0", "FooBar-1", "FooBar-2", "FooBar-3")); }
@Test public void shouldPublishEventsThreeArg() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorThreeArg<Object[], String, String, String> translator = new ThreeArgEventTranslator(); ringBuffer.publishEvents( translator, new String[]{"Foo", "Foo"}, new String[]{"Bar", "Bar"}, new String[]{"Baz", "Baz"}); ringBuffer.tryPublishEvents( translator, new String[]{"Foo", "Foo"}, new String[]{"Bar", "Bar"}, new String[]{"Baz", "Baz"}); assertThat(ringBuffer, ringBufferWithEvents("FooBarBaz-0", "FooBarBaz-1", "FooBarBaz-2", "FooBarBaz-3")); }
@SuppressWarnings("unchecked") @Test public void shouldPublishEvents() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); final EventTranslator<Object[]> eventTranslator = new NoArgEventTranslator(); final EventTranslator<Object[]>[] translators = new EventTranslator[]{eventTranslator, eventTranslator}; ringBuffer.publishEvents(translators); assertTrue(ringBuffer.tryPublishEvents(translators)); assertThat(ringBuffer, ringBufferWithEvents(0L, 1L, 2L, 3L)); }
@Test public void shouldPublishEventsOneArgWithinBatch() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorOneArg<Object[], String> translator = new OneArgEventTranslator(); ringBuffer.publishEvents(translator, 1, 2, new String[]{"Foo", "Foo", "Foo"}); assertTrue(ringBuffer.tryPublishEvents(translator, 1, 2, new String[]{"Foo", "Foo", "Foo"})); assertThat(ringBuffer, ringBufferWithEvents("Foo-0", "Foo-1", "Foo-2", "Foo-3")); }
@SuppressWarnings("unchecked") @Test public void shouldPublishEventsWithinBatch() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); final EventTranslator<Object[]> eventTranslator = new NoArgEventTranslator(); final EventTranslator<Object[]>[] translators = new EventTranslator[]{eventTranslator, eventTranslator, eventTranslator}; ringBuffer.publishEvents(translators, 1, 2); assertTrue(ringBuffer.tryPublishEvents(translators, 1, 2)); assertThat(ringBuffer, ringBufferWithEvents(0L, 1L, 2L, 3L)); }
@Test public void shouldPublishEventsOneArg() throws Exception { RingBuffer<Object[]> ringBuffer = RingBuffer.createSingleProducer(new ArrayFactory(1), 4); EventTranslatorOneArg<Object[], String> translator = new OneArgEventTranslator(); ringBuffer.publishEvents(translator, new String[]{"Foo", "Foo"}); assertTrue(ringBuffer.tryPublishEvents(translator, new String[]{"Foo", "Foo"})); assertThat(ringBuffer, ringBufferWithEvents("Foo-0", "Foo-1", "Foo-2", "Foo-3")); }