com.lmax.disruptor.EventTranslatorOneArg Java Examples

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> void translateAndPublish(EventTranslatorOneArg<E, A> translator, long sequence, A arg0) {
    try {
        translator.translateTo(get(sequence), sequence, arg0);
    } finally {
        sequencer.publish(sequence);
    }
}
 

private <T extends ApiCommand, R> CompletableFuture<R> submitCommandAsync(final EventTranslatorOneArg<OrderCommand, T> translator,
                                                                          final T apiCommand,
                                                                          final Function<OrderCommand, R> responseTranslator) {
    final CompletableFuture<R> future = new CompletableFuture<>();

    ringBuffer.publishEvent(
            (cmd, seq, apiCmd) -> {
                translator.translateTo(cmd, seq, apiCmd);
                promises.put(seq, orderCommand -> future.complete(responseTranslator.apply(orderCommand)));
            },
            apiCommand);

    return future;
}
 

/**
 * Allows one user supplied argument.
 * 
 * @param translator The user specified translation for each event
 * @param batchStartsAt The first element of the array which is within the batch.
 * @param batchSize The actual size of the batch
 * @param arg0 An array of user supplied arguments, one element per event.
 * @return true if the value was published, false if there was insufficient capacity.
 * @see #tryPublishEvents(EventTranslator[])
 */
public <A> boolean tryPublishEvents(EventTranslatorOneArg<E, A> translator, int batchStartsAt, int batchSize, A[] arg0) {
    checkBounds(arg0, batchStartsAt, batchSize);
    try {
        final long finalSequence = sequencer.tryNext(batchSize);
        translateAndPublishBatch(translator, arg0, batchStartsAt, batchSize, finalSequence);
        return true;
    } catch (InsufficientCapacityException e) {
        return false;
    }
}
 

/**
 * Allows one user supplied argument.
 * 
 * @see #tryPublishEvent(EventTranslator)
 * @param translator The user specified translation for the event
 * @param arg0 A user supplied argument.
 * @return true if the value was published, false if there was insufficient capacity.
 */
public <A> boolean tryPublishEvent(EventTranslatorOneArg<E, A> translator, A arg0) {
    try {
        final long sequence = sequencer.tryNext();
        translateAndPublish(translator, sequence, arg0);
        return true;
    } catch (InsufficientCapacityException e) {
        return false;
    }
}
 

@Bean
public ApplicationListener<DisruptorApplicationEvent> disruptorEventListener(Disruptor<DisruptorEvent> disruptor,
		EventTranslatorOneArg<DisruptorEvent, DisruptorEvent> oneArgEventTranslator) {
	return new ApplicationListener<DisruptorApplicationEvent>() {

		@Override
		public void onApplicationEvent(DisruptorApplicationEvent appEvent) {
			DisruptorEvent event = (DisruptorEvent) appEvent.getSource();
			disruptor.publishEvent(oneArgEventTranslator, event);
		}
		
	};
}
 

private <E> boolean tryAddEventToRingBuffer(E event, EventTranslatorOneArg<ReportingEvent, E> eventTranslator) {
    if (dropTransactionIfQueueFull) {
        boolean queueFull = !disruptor.getRingBuffer().tryPublishEvent(eventTranslator, event);
        if (queueFull) {
            if (logger.isDebugEnabled()) {
                logger.debug("Could not add {} {} to ring buffer as no slots are available", event.getClass().getSimpleName(), event);
            }
            dropped.incrementAndGet();
            return false;
        }
    } else {
        disruptor.getRingBuffer().publishEvent(eventTranslator, event);
    }
    return true;
}
 

@Override
public <A> void publishEvents(EventTranslatorOneArg<ResponseEvent, A> translator, int batchStartsAt, int batchSize, A[] arg0) {
    throw new UnsupportedOperationException();
}
 

@Override
public <A> boolean tryPublishEvents(EventTranslatorOneArg<ResponseEvent, A> translator, int batchStartsAt, int batchSize, A[] arg0) {
    throw new UnsupportedOperationException();
}
 

@Override
public <A> boolean tryPublishEvents(EventTranslatorOneArg<ResponseEvent, A> translator, A[] arg0) {
    throw new UnsupportedOperationException();
}
 

@Override
public <A> void publishEvents(EventTranslatorOneArg<ResponseEvent, A> translator, A[] arg0) {
    throw new UnsupportedOperationException();
}
 

@Override
public <A> boolean tryPublishEvent(EventTranslatorOneArg<ResponseEvent, A> translator, A arg0) {
    throw new UnsupportedOperationException();
}
 

@Override
public <A> void publishEvent(EventTranslatorOneArg<ResponseEvent, A> translator, A arg0) {
    throw new UnsupportedOperationException();
}
 

public void setTranslator(EventTranslatorOneArg<QueueEvent, EventData> translator) {
	this.translator = translator;
}
 

@Bean
@ConditionalOnMissingBean
public EventTranslatorOneArg<DisruptorEvent, DisruptorEvent> oneArgEventTranslator() {
	return new DisruptorEventOneArgTranslator();
}
 

private <T extends ApiCommand> CompletableFuture<OrderCommand> submitCommandAsyncFullResponse(EventTranslatorOneArg<OrderCommand, T> translator, final T apiCommand) {
    return submitCommandAsync(translator, apiCommand, Function.identity());
}
 

private <T extends ApiCommand> CompletableFuture<CommandResultCode> submitCommandAsync(EventTranslatorOneArg<OrderCommand, T> translator, final T apiCommand) {
    return submitCommandAsync(translator, apiCommand, c -> c.resultCode);
}
 

/**
 * Allows one user supplied argument.
 * 
 * @see #publishEvent(EventTranslator)
 * @param translator The user specified translation for the event
 * @param arg0 A user supplied argument.
 */
public <A> void publishEvent(EventTranslatorOneArg<E, A> translator, A arg0) {
    final long sequence = sequencer.next();
    translateAndPublish(translator, sequence, arg0);
}
 

/**
 * Allows one user supplied argument per event.
 * 
 * @param translator The user specified translation for the event
 * @param arg0 A user supplied argument.
 * @see #publishEvents(com.lmax.disruptor.EventTranslator[])
 */
public <A> void publishEvents(EventTranslatorOneArg<E, A> translator, A[] arg0) {
    publishEvents(translator, 0, arg0.length, arg0);
}
 

/**
 * Allows one user supplied argument per event.
 * 
 * @param translator The user specified translation for each event
 * @param batchStartsAt The first element of the array which is within the batch.
 * @param batchSize The actual size of the batch
 * @param arg0 An array of user supplied arguments, one element per event.
 * @see #publishEvents(EventTranslator[])
 */
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);
}
 

/**
 * Allows one user supplied argument.
 * 
 * @param translator The user specified translation for each event
 * @param arg0 An array of user supplied arguments, one element per event.
 * @return true if the value was published, false if there was insufficient capacity.
 * @see #tryPublishEvents(com.lmax.disruptor.EventTranslator[])
 */
public <A> boolean tryPublishEvents(EventTranslatorOneArg<E, A> translator, A[] arg0) {
    return tryPublishEvents(translator, 0, arg0.length, arg0);
}
 

public void onData(T command) {

    ringBuffer.publishEvent((EventTranslatorOneArg) TRANSLATOR, command);

  }