How to use

methodReader

method

in

net.openhft.chronicle.queue.ExcerptTailer

  @NotNull
  public MethodReader createReader(JDBCResult result) {
    return out.createTailer().methodReader(result);
  }
}

@NotNull
public MethodReader outputReader(Object... impls) {
  ChronicleQueue queue = outputQueue();
  MethodReader reader = queue.createTailer().methodReader(impls);
  reader.closeIn(true);
  return reader;
}

public EventLoopServiceWrapper(@NotNull ServiceWrapperBuilder<O> builder) {
  this.priority = builder.priority();
  outputQueue = ChronicleQueue.singleBuilder(builder.outputPath())
      .sourceId(builder.outputSourceId())
      .checkInterrupts(false)
      .build();
  serviceOut = outputQueue.acquireAppender()
      .methodWriterBuilder(builder.outClass())
      .recordHistory(builder.outputSourceId() != 0)
      .get();
  serviceImpl = builder.getServiceFunctions().stream()
      .map(f -> f.apply(serviceOut))
      .toArray();
  List<String> paths = builder.inputPath();
  serviceIn = new MethodReader[paths.size()];
  inputQueues = new ChronicleQueue[paths.size()];
  for (int i = 0; i < paths.size(); i++) {
    inputQueues[i] = ChronicleQueue.singleBuilder(paths.get(i))
        .sourceId(builder.inputSourceId())
        .build();
    serviceIn[i] = inputQueues[i].createTailer()
        .afterLastWritten(outputQueue)
        .methodReader(serviceImpl);
  }
  eventLoop = builder.eventLoop();
  eventLoop.addHandler(this);
  createdEventLoop = builder.createdEventLoop();
  if (createdEventLoop)
    eventLoop.start();
}

void runLoop() {
  try {
    JDBCResult result = out.acquireAppender()
        .methodWriterBuilder(JDBCResult.class)
        .recordHistory(true)
        .get();
    JDBCComponent js = new JDBCComponent(connectionSupplier, result);
    MethodReader reader = in.createTailer().afterLastWritten(out).methodReader(js);
    Pauser pauser = Pauser.millis(1, 10);
    while (!closed) {
      if (reader.readOne())
        pauser.reset();
      else
        pauser.pause();
    }
  } catch (Throwable t) {
    LOGGER.warn("Run loop exited", t);
  }
}

@Test
public void shouldAccessMessageHistory() throws Exception {
  try (final ChronicleQueue inputQueue = createQueue(inputQueueDir, 1);
     final ChronicleQueue outputQueue = createQueue(outputQueueDir, 2)) {
    generateTestData(inputQueue, outputQueue);
    final ExcerptTailer tailer = outputQueue.createTailer();
    final ValidatingSecond validatingSecond = new ValidatingSecond();
    final MethodReader validator = tailer.methodReader(validatingSecond);
    assertThat(validator.readOne(), is(true));
    assertThat(validatingSecond.messageHistoryPresent(), is(true));
  }
}

@Test(expected = IllegalArgumentException.class)
public void dontPassQueueToReader() {
  try (ChronicleQueue queue = binary(getTmpDir()).build()) {
    queue.createTailer().afterLastWritten(queue).methodReader();
  }
}

@Test
public void shouldAccessMessageHistoryWhenTailerIsMovedToEnd() throws Exception {
  try (final ChronicleQueue inputQueue = createQueue(inputQueueDir, 1);
     final ChronicleQueue outputQueue = createQueue(outputQueueDir, 2)) {
    generateTestData(inputQueue, outputQueue);
    final ExcerptTailer tailer = outputQueue.createTailer();
    tailer.direction(TailerDirection.BACKWARD).toEnd();
    final ValidatingSecond validatingSecond = new ValidatingSecond();
    final MethodReader validator = tailer.methodReader(validatingSecond);
    assertThat(validator.readOne(), is(true));
    assertThat(validatingSecond.messageHistoryPresent(), is(true));
  }
}

MethodReader methodReader = queue.createTailer().methodReader(new TestMessageListener() {

PingDTO.constructionExpected++;
MethodReader reader = cq.createTailer()
    .methodReader(
        (Pinger) pingDTO -> sb.append("ping ").append(pingDTO));
assertEquals(PingDTO.constructionExpected, PingDTO.constructionCounter);

MethodReader methodReader = inQueue.createTailer().methodReader((Msg) out::msg);
MethodReader methodReader = excerptTailer.methodReader((Msg) actualValue::set);

@Test
public void test() {
  File file = getTmpDir();
  try (ChronicleQueue queue = ChronicleQueue.singleBuilder(file)
      .testBlockSize()
      .rollCycle(TEST_DAILY).build()) {
    SomeListener someListener = queue.acquireAppender().methodWriter(SomeListener.class);
    SomeManager someManager = new SomeManager();
    MethodReader reader = queue.createTailer().methodReader(someManager);
    LOG.debug("Writing to queue");
    someListener.methodWithOneParam(1);
    someListener.methodWithoutParams();
    LOG.debug("Reading from queue");
    assertTrue(reader.readOne());
    assertTrue(reader.readOne());
    assertFalse(reader.readOne());
    assertTrue(someManager.methodWithOneParamInvoked);       // one param method was invoked
    assertTrue(someManager.methodWithoutParamsInvoked);      // no params method was NOT invoked
    LOG.warn(queue.dump());
  }
}

final MethodReader firstMethodReader = firstInputQueue.createTailer().methodReader(outputWriter);
final MethodReader secondMethodReader = secondInputQueue.createTailer().methodReader(outputWriter);

    .build();
MethodReader methodReader = inQueue.createTailer()
    .methodReader((Msg) out::msg);
MethodReader methodReader = excerptTailer.methodReader((Msg) actualValue::set);

MethodReader reader = tailer.methodReader((PersonListener) person -> names.add(person.name));

    .recordHistory(true)
    .build();
MethodReader methodReader = inQueue.createTailer().methodReader((Msg) out::msg);
MethodReader methodReader = excerptTailer.methodReader((Msg) actualValue::set);

  writer.say(msg);
};
MethodReader reader = in.createTailer().methodReader(dummy);
assertTrue(reader.readOne());
assertFalse(reader.readOne());
  writer.say(msg);
};
MethodReader reader = in.createTailer().methodReader(dummy);
assertTrue(reader.readOne());
assertFalse(reader.readOne());

MethodReader reader = in.createTailer().methodReader(orderManager);
for (int i = 0; i < 5; i++)
  assertTrue(reader.readOne());
MethodReader reader = in.createTailer().methodReader((OrderListener) order -> {
  MessageHistory x = MessageHistory.get();

assertEquals(i, in.rollCycle().toSequenceNumber(tailer.index()));
MethodReader reader = tailer
    .methodReader(combiner);

     .testBlockSize()
     .build()) {
MethodReader reader2 = queue1.createTailer().methodReader(ObjectUtils.printAll(MessageListener.class));
MessageListener writer2 = queue2.acquireAppender().methodWriter(MessageListener.class);
MessageListener processor = new MessageProcessor(writer2);
MethodReader reader1 = queue1.createTailer().methodReader(processor);
MessageListener writer1 = queue1.acquireAppender().methodWriter(MessageListener.class);

  @NotNull
  public MethodReader createReader(JDBCResult result) {
    return out.createTailer().methodReader(result);
  }
}