/** * @see com.lmax.disruptor.EventSink#publishEvent(com.lmax.disruptor.EventTranslatorOneArg, Object) * com.lmax.disruptor.EventSink#publishEvent(com.lmax.disruptor.EventTranslatorOneArg, A) */ @Override public <A> void publishEvent(EventTranslatorOneArg<E, A> translator, A arg0) { final long sequence = sequencer.next(); translateAndPublish(translator, sequence, arg0); }
/** * @see com.lmax.disruptor.EventSink#publishEvent(com.lmax.disruptor.EventTranslatorVararg, java.lang.Object...) */ @Override public void publishEvent(EventTranslatorVararg<E> translator, Object... args) { final long sequence = sequencer.next(); translateAndPublish(translator, sequence, args); }
/** * @see com.lmax.disruptor.EventSink#publishEvent(com.lmax.disruptor.EventTranslatorTwoArg, Object, Object) * com.lmax.disruptor.EventSink#publishEvent(com.lmax.disruptor.EventTranslatorTwoArg, A, B) */ @Override public <A, B> void publishEvent(EventTranslatorTwoArg<E, A, B> translator, A arg0, B arg1) { final long sequence = sequencer.next(); translateAndPublish(translator, sequence, arg0, arg1); }
/** * @see com.lmax.disruptor.EventSink#publishEvent(com.lmax.disruptor.EventTranslatorThreeArg, Object, Object, Object) * com.lmax.disruptor.EventSink#publishEvent(com.lmax.disruptor.EventTranslatorThreeArg, A, B, C) */ @Override public <A, B, C> void publishEvent(EventTranslatorThreeArg<E, A, B, C> translator, A arg0, B arg1, C arg2) { final long sequence = sequencer.next(); translateAndPublish(translator, sequence, arg0, arg1, arg2); }
/** * @see com.lmax.disruptor.EventSink#publishEvent(com.lmax.disruptor.EventTranslator) */ @Override public void publishEvent(EventTranslator<E> translator) { final long sequence = sequencer.next(); translateAndPublish(translator, sequence); }
/** * @see com.lmax.disruptor.EventSink#publishEvents(com.lmax.disruptor.EventTranslatorOneArg, int, int, Object[]) * com.lmax.disruptor.EventSink#publishEvents(com.lmax.disruptor.EventTranslatorOneArg, int, int, A[]) */ @Override public <A> void publishEvents(EventTranslatorOneArg<E, A> translator, int batchStartsAt, int batchSize, A[] arg0) { checkBounds(arg0, batchStartsAt, batchSize); final long finalSequence = sequencer.next(batchSize); translateAndPublishBatch(translator, arg0, batchStartsAt, batchSize, finalSequence); }
/** * @see com.lmax.disruptor.EventSink#publishEvents(com.lmax.disruptor.EventTranslator[], int, int) */ @Override public void publishEvents(EventTranslator<E>[] translators, int batchStartsAt, int batchSize) { checkBounds(translators, batchStartsAt, batchSize); final long finalSequence = sequencer.next(batchSize); translateAndPublishBatch(translators, batchStartsAt, batchSize, finalSequence); }
/** * @see com.lmax.disruptor.EventSink#publishEvents(com.lmax.disruptor.EventTranslatorVararg, int, int, java.lang.Object[][]) */ @Override public void publishEvents(EventTranslatorVararg<E> translator, int batchStartsAt, int batchSize, Object[]... args) { checkBounds(batchStartsAt, batchSize, args); final long finalSequence = sequencer.next(batchSize); translateAndPublishBatch(translator, batchStartsAt, batchSize, finalSequence, args); }
/** * @see com.lmax.disruptor.EventSink#publishEvents(com.lmax.disruptor.EventTranslatorTwoArg, int, int, Object[], Object[]) * com.lmax.disruptor.EventSink#publishEvents(com.lmax.disruptor.EventTranslatorTwoArg, int, int, A[], B[]) */ @Override public <A, B> void publishEvents( EventTranslatorTwoArg<E, A, B> translator, int batchStartsAt, int batchSize, A[] arg0, B[] arg1) { checkBounds(arg0, arg1, batchStartsAt, batchSize); final long finalSequence = sequencer.next(batchSize); translateAndPublishBatch(translator, arg0, arg1, batchStartsAt, batchSize, finalSequence); }
/** * @see com.lmax.disruptor.EventSink#publishEvents(com.lmax.disruptor.EventTranslatorThreeArg, int, int, Object[], Object[], Object[]) * com.lmax.disruptor.EventSink#publishEvents(com.lmax.disruptor.EventTranslatorThreeArg, int, int, A[], B[], C[]) */ @Override public <A, B, C> void publishEvents( EventTranslatorThreeArg<E, A, B, C> translator, int batchStartsAt, int batchSize, A[] arg0, B[] arg1, C[] arg2) { checkBounds(arg0, arg1, arg2, batchStartsAt, batchSize); final long finalSequence = sequencer.next(batchSize); translateAndPublishBatch(translator, arg0, arg1, arg2, batchStartsAt, batchSize, finalSequence); }
@Test(expected = IllegalArgumentException.class) public void shouldNotAllowBulkNextLessThanZero() throws Exception { sequencer.next(-1); }
@Test(expected = IllegalArgumentException.class) public void shouldNotAllowBulkNextOfZero() throws Exception { sequencer.next(0); }
@Override public void run() { waitingLatch.countDown(); long next = sequencer.next(); sequencer.publish(next); doneLatch.countDown(); } });
@Test public void shouldBatchClaim() { assertEquals(3, sequencer.next(4)); }
@Test public void shouldStartWithInitialValue() { assertEquals(0, sequencer.next()); }
@Test public void shouldClaimSpecificSequence() throws Exception { long sequence = 14L; sequencer.claim(sequence); sequencer.publish(sequence); assertThat(sequencer.next(), is(sequence + 1)); }
@Test(expected = InsufficientCapacityException.class) public void shouldThrowInsufficientCapacityExceptionWhenSequencerIsFull() throws Exception { sequencer.addGatingSequences(gatingSequence); for (int i = 0; i < BUFFER_SIZE; i++) { sequencer.next(); } sequencer.tryNext(); }
@Test public void shouldCalculateRemainingCapacity() throws Exception { sequencer.addGatingSequences(gatingSequence); assertThat(sequencer.remainingCapacity(), is((long) BUFFER_SIZE)); for (int i = 1; i < BUFFER_SIZE; i++) { sequencer.next(); assertThat(sequencer.remainingCapacity(), is((long) BUFFER_SIZE - i)); } }
@Test public void shouldIndicateNoAvailableCapacity() { sequencer.addGatingSequences(gatingSequence); long sequence = sequencer.next(BUFFER_SIZE); sequencer.publish(sequence - (BUFFER_SIZE - 1), sequence); assertFalse(sequencer.hasAvailableCapacity(1)); }
@Test public void shouldIndicateHasAvailableCapacity() { sequencer.addGatingSequences(gatingSequence); assertTrue(sequencer.hasAvailableCapacity(1)); assertTrue(sequencer.hasAvailableCapacity(BUFFER_SIZE)); assertFalse(sequencer.hasAvailableCapacity(BUFFER_SIZE + 1)); sequencer.publish(sequencer.next()); assertTrue(sequencer.hasAvailableCapacity(BUFFER_SIZE - 1)); assertFalse(sequencer.hasAvailableCapacity(BUFFER_SIZE)); }