/** * Publish the specified sequence. This action marks this particular * message as being available to be read. * * @param sequence the sequence to publish. */ @Override public void publish(long sequence) { sequencer.publish(sequence); }
/** * Publish the specified sequences. This action marks these particular * messages as being available to be read. * * @param lo the lowest sequence number to be published * @param hi the highest sequence number to be published * @see Sequencer#next(int) */ @Override public void publish(long lo, long hi) { sequencer.publish(lo, hi); }
/** * Publish the specified sequences. This action marks these particular messages as being available to be read. * * @see Sequencer#next(int) * @param lo the lowest sequence number to be published * @param hi the highest sequence number to be published */ public void publish(long lo, long hi) { sequencer.publish(lo, hi); }
/** * Resets the cursor to a specific value. This can be applied at any time, but it is worth noting * that it can cause a data race and should only be used in controlled circumstances. E.g. during * initialisation. * * @param sequence The sequence to reset too. * @throws IllegalStateException If any gating sequences have already been specified. */ @Deprecated public void resetTo(long sequence) { sequencer.claim(sequence); sequencer.publish(sequence); }
private <A> void translateAndPublish(EventTranslatorOneArg<E, A> translator, long sequence, A arg0) { try { translator.translateTo(get(sequence), sequence, arg0); } finally { sequencer.publish(sequence); } }
private <A, B> void translateAndPublish(EventTranslatorTwoArg<E, A, B> translator, long sequence, A arg0, B arg1) { try { translator.translateTo(get(sequence), sequence, arg0, arg1); } finally { sequencer.publish(sequence); } }
private void translateAndPublish(EventTranslator<E> translator, long sequence) { try { translator.translateTo(get(sequence), sequence); } finally { sequencer.publish(sequence); } }
private void translateAndPublish(EventTranslatorVararg<E> translator, long sequence, Object... args) { try { translator.translateTo(get(sequence), sequence, args); } finally { sequencer.publish(sequence); } }
private <A, B, C> void translateAndPublish( EventTranslatorThreeArg<E, A, B, C> translator, long sequence, A arg0, B arg1, C arg2) { try { translator.translateTo(get(sequence), sequence, arg0, arg1, arg2); } finally { sequencer.publish(sequence); } }
private <A> void translateAndPublish(EventTranslatorOneArg<E, A> translator, long sequence, A arg0) { try { translator.translateTo(get(sequence), sequence, arg0); } finally { sequencer.publish(sequence); } }
private <A> void translateAndPublishBatch( final EventTranslatorOneArg<E, A> translator, final A[] arg0, int batchStartsAt, final int batchSize, final long finalSequence) { final long initialSequence = finalSequence - (batchSize - 1); try { long sequence = initialSequence; final int batchEndsAt = batchStartsAt + batchSize; for (int i = batchStartsAt; i < batchEndsAt; i++) { translator.translateTo(get(sequence), sequence++, arg0[i]); } } finally { sequencer.publish(initialSequence, finalSequence); } }
private <A, B> void translateAndPublish(EventTranslatorTwoArg<E, A, B> translator, long sequence, A arg0, B arg1) { try { translator.translateTo(get(sequence), sequence, arg0, arg1); } finally { sequencer.publish(sequence); } }
private <A, B, C> void translateAndPublish(EventTranslatorThreeArg<E, A, B, C> translator, long sequence, A arg0, B arg1, C arg2) { try { translator.translateTo(get(sequence), sequence, arg0, arg1, arg2); } finally { sequencer.publish(sequence); } }
@Override public void run() { waitingLatch.countDown(); long next = sequencer.next(); sequencer.publish(next); doneLatch.countDown(); } });
@Test public void shouldClaimSpecificSequence() throws Exception { long sequence = 14L; sequencer.claim(sequence); sequencer.publish(sequence); assertThat(sequencer.next(), is(sequence + 1)); }
@Test public void shouldWaitOnPublication() throws Exception { SequenceBarrier barrier = sequencer.newBarrier(); long next = sequencer.next(10); long lo = next - (10 - 1); long mid = next - 5; for (long l = lo; l < mid; l++) { sequencer.publish(l); } assertThat(barrier.waitFor(-1), is(mid - 1)); for (long l = mid; l <= next; l++) { sequencer.publish(l); } assertThat(barrier.waitFor(-1), is(next)); }
@Test public void shouldOnlyAllowMessagesToBeAvailableIfSpecificallyPublished() throws Exception { publisher.publish(3); publisher.publish(5); assertThat(publisher.isAvailable(0), is(false)); assertThat(publisher.isAvailable(1), is(false)); assertThat(publisher.isAvailable(2), is(false)); assertThat(publisher.isAvailable(3), is(true)); assertThat(publisher.isAvailable(4), is(false)); assertThat(publisher.isAvailable(5), is(true)); assertThat(publisher.isAvailable(6), is(false)); } }
@Test public void shouldNotBeAvailableUntilPublished() throws Exception { long next = sequencer.next(6); for (int i = 0; i <= 5; i++) { assertThat(sequencer.isAvailable(i), is(false)); } sequencer.publish(next - (6 - 1), next); for (int i = 0; i <= 5; i++) { assertThat(sequencer.isAvailable(i), is(true)); } assertThat(sequencer.isAvailable(6), is(false)); }
@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)); }