How to use

rollCycle

method

in

net.openhft.chronicle.queue.ChronicleQueue

private boolean indexIsCloseToAndAheadOfLastIndexMove(
    final long index, final TailerState state, final TailerDirection direction,
    final ChronicleQueue queue) {
  return lastMovedToIndex != Long.MIN_VALUE &&
      index - lastMovedToIndex < INDEXING_LINEAR_SCAN_THRESHOLD &&
      state == FOUND_CYCLE &&
      direction == directionAtLastMoveTo &&
      queue.rollCycle().toCycle(index) == queue.rollCycle().toCycle(lastMovedToIndex) &&
      index > lastMovedToIndex;
}

private boolean canReuseLastIndexMove(
    final long index, final TailerState state, final TailerDirection direction,
    final ChronicleQueue queue, final Wire wire) {
  return ((wire == null) || wire.bytes().readPosition() == readPositionAtLastMove) &&
      index == this.lastMovedToIndex && index != 0 && state == FOUND_CYCLE &&
      direction == directionAtLastMoveTo &&
      queue.rollCycle().toCycle(index) == queue.rollCycle().toCycle(lastMovedToIndex);
}

private static long findCycleLinearSearch(@NotNull NavigableSet<Long> cycles, Wire key,
                     @NotNull Comparator<Wire> c,
                     @NotNull ExcerptTailer tailer,
                     @NotNull final ChronicleQueue queue) {
  final Iterator<Long> iterator = cycles.iterator();
  if (!iterator.hasNext())
    return -1;
  final RollCycle rollCycle = queue.rollCycle();
  long prevIndex = iterator.next();
  while (iterator.hasNext()) {
    final Long current = iterator.next();
    final boolean b = tailer.moveToIndex(rollCycle.toIndex((int) (long) current, 0));
    if (!b)
      return prevIndex;
    try (final DocumentContext dc = tailer.readingDocument()) {
      final int compare = c.compare(dc.wire(), key);
      if (compare == 0)
        return current;
      else if (compare > 0)
        return prevIndex;
      prevIndex = current;
    }
  }
  return prevIndex;
}

@NotNull
private String toTextIndex(ChronicleQueue q, long index) {
  return Long.toHexString(q.rollCycle().toCycle(index)) + "_" + Long.toHexString(q.rollCycle().toSequenceNumber(index));
}

private long toSeq(final ChronicleQueue q, final long index) {
  return q.rollCycle().toSequenceNumber(index);
}

@Ignore("long running test")
@Test
public void testReadAtIndex4MB() {
  try (final ChronicleQueue queue = SingleChronicleQueueBuilder.builder(getTmpDir(), this.wireType).rollCycle(SMALL_DAILY)
      .build()) {
    final ExcerptAppender appender = queue.acquireAppender();
    System.out.print("Percent written=");
    for (long i = 0; i < TIMES; i++) {
      final long j = i;
      appender.writeDocument(wire -> wire.write(() -> "key").text("value=" + j));
      if (i % (TIMES / 20) == 0) {
        System.out.println("" + (i * 100 / TIMES) + "%, ");
      }
    }
    long lastIndex = appender.lastIndexAppended();
    final int cycle = queue.rollCycle().toCycle(lastIndex);
    final ExcerptTailer tailer = queue.createTailer();
    //   QueueDumpMain.dump(file, new PrintWriter(System.out));
    StringBuilder sb = new StringBuilder();
    for (long i = 0; i < (4L << 20L); i++) {
      assertTrue(tailer.moveToIndex(queue.rollCycle().toIndex(cycle, i)));
      tailer.readDocument(wire -> wire.read(() -> "key").text(sb));
      Assert.assertEquals("value=" + i, sb.toString());
      if (i % (TIMES / 20) == 0) {
        System.out.println("Percent read= " + (i * 100 / TIMES) + "%");
      }
    }
  }
}

@Test
public void testAppendAndReadAtIndex() {
  try (final ChronicleQueue queue = builder(getTmpDir(), this.wireType)
      .rollCycle(TEST2_DAILY)
      .build()) {
    final ExcerptAppender appender = queue.acquireAppender();
    appender.cycle();
    for (int i = 0; i < 5; i++) {
      final int n = i;
      appender.writeDocument(w -> w.write(TestKey.test).int32(n));
      assertEquals(i, queue.rollCycle().toSequenceNumber(appender.lastIndexAppended()));
    }
    final ExcerptTailer tailer = queue.createTailer();
    for (int i = 0; i < 5; i++) {
      final long index = queue.rollCycle().toIndex(appender.cycle(), i);
      assertTrue(tailer.moveToIndex(index));
      final int n = i;
      assertTrue(tailer.readDocument(r -> assertEquals(n, queue.rollCycle().toSequenceNumber(r.read(TestKey.test)
          .int32()))));
      long index2 = tailer.index();
      long sequenceNumber = queue.rollCycle().toSequenceNumber(index2);
      assertEquals(n + 1, sequenceNumber);
    }
  }
}

@Test
public void testAppend() {
  try (final ChronicleQueue queue =
         builder(getTmpDir(), wireType)
             .build()) {
    final ExcerptAppender appender = queue.acquireAppender();
    for (int i = 0; i < 10; i++) {
      final int n = i;
      appender.writeDocument(w -> w.write(TestKey.test).int32(n));
      assertEquals(n, queue.rollCycle().toSequenceNumber(appender.lastIndexAppended()));
    }
    assertThat(countEntries(queue), is(10L));
  }
}

Assert.assertEquals(0, chronicle.rollCycle().toSequenceNumber(index));
dc.wire().write(() -> "FirstName").text("Quartilla");
Assert.assertEquals(1, chronicle.rollCycle().toSequenceNumber(dc.index()));
dc.wire().write(() -> "FirstName").text("Rob");
Assert.assertEquals(2, chronicle.rollCycle().toSequenceNumber(dc.index()));
dc.wire().write(() -> "FirstName").text("Rob");
Assert.assertEquals(0, chronicle.rollCycle().toSequenceNumber(index));
Assert.assertEquals(1, chronicle.rollCycle().toSequenceNumber(dc.index()));
Assert.assertEquals(2, chronicle.rollCycle().toSequenceNumber(dc.index()));

@Test
public void testHeaderIndexReadAtIndex() {
  try (final ChronicleQueue queue = builder(getTmpDir(), this.wireType)
      .build()) {
    final ExcerptAppender appender = queue.acquireAppender();
    final int cycle = appender.cycle();
    // create 100 documents
    for (int i = 0; i < 100; i++) {
      final int j = i;
      appender.writeDocument(wire -> wire.write(() -> "key").text("value=" + j));
    }
    final ExcerptTailer tailer = queue.createTailer();
    assertTrue(tailer.moveToIndex(queue.rollCycle().toIndex(cycle, 0)));
    StringBuilder sb = new StringBuilder();
    tailer.readDocument(wire -> wire.read(() -> "key").text(sb));
    Assert.assertEquals("value=0", sb.toString());
  }
}

@Test
public void testIndex() {
  try (final ChronicleQueue queue = builder(getTmpDir(), this.wireType)
      .rollCycle(RollCycles.HOURLY)
      .build()) {
    final ExcerptAppender appender = queue.acquireAppender();
    int cycle = appender.cycle();
    // create 100 documents
    for (int i = 0; i < 5; i++) {
      final int j = i;
      appender.writeDocument(wire -> wire.write(() -> "key").text("value=" + j));
      if (i == 2) {
        final long cycle1 = queue.rollCycle().toCycle(appender.lastIndexAppended());
        Assert.assertEquals(cycle1, cycle);
      }
    }
    final ExcerptTailer tailer = queue.createTailer();
    assertTrue(tailer.moveToIndex(queue.rollCycle().toIndex(cycle, 2)));
    StringBuilder sb = new StringBuilder();
    tailer.readDocument(wire -> wire.read(() -> "key").text(sb));
    Assert.assertEquals("value=2", sb.toString());
    tailer.readDocument(wire -> wire.read(() -> "key").text(sb));
    Assert.assertEquals("value=3", sb.toString());
    tailer.readDocument(wire -> wire.read(() -> "key").text(sb));
    Assert.assertEquals("value=4", sb.toString());
  }
}

@Test
public void testLastWrittenIndexPerAppender() {
  try (final ChronicleQueue queue = builder(getTmpDir(), this.wireType)
      .build()) {
    final ExcerptAppender appender = queue.acquireAppender();
    appender.writeDocument(wire -> wire.write(() -> "key").text("test"));
    Assert.assertEquals(0, queue.rollCycle().toSequenceNumber(appender.lastIndexAppended()));
  }
}

@Test
public void testSomeMessages() {
  try (ChronicleQueue chronicle = builder(getTmpDir(), wireType)
      .rollCycle(TEST2_DAILY)
      .build()) {
    ExcerptAppender appender = chronicle.acquireAppender();
    ExcerptTailer tailer = chronicle.createTailer();
    int entries = chronicle.rollCycle().defaultIndexSpacing() * 2 + 2;
    for (long i = 0; i < entries; i++) {
      long finalI = i;
      appender.writeDocument(w -> w.writeEventName("hello").int64(finalI));
      long seq = chronicle.rollCycle().toSequenceNumber(appender.lastIndexAppended());
      assertEquals(i, seq);
      //      System.out.println(chronicle.dump());
      tailer.readDocument(w -> w.read().int64(finalI, (a, b) -> Assert.assertEquals((long) a, b)));
    }
  }
}

@Test
public void testAppendAndRead() {
  try (final ChronicleQueue queue = builder(getTmpDir(), this.wireType)
      .build()) {
    final ExcerptAppender appender = queue.acquireAppender();
    final int cycle = appender.cycle();
    for (int i = 0; i < 10; i++) {
      final int n = i;
      appender.writeDocument(w -> w.write(TestKey.test).int32(n));
      assertEquals(n, queue.rollCycle().toSequenceNumber(appender.lastIndexAppended()));
    }
    final ExcerptTailer tailer = queue.createTailer();
    // Sequential read
    for (int i = 0; i < 10; i++) {
      final int n = i;
      assertTrue(tailer.readDocument(r -> assertEquals(n, r.read(TestKey.test).int32())));
      assertEquals(n + 1, queue.rollCycle().toSequenceNumber(tailer.index()));
    }
    // Random read
    for (int i = 0; i < 10; i++) {
      final int n = i;
      assertTrue("n: " + n, tailer.moveToIndex(queue.rollCycle().toIndex(cycle, n)));
      assertTrue("n: " + n, tailer.readDocument(r -> assertEquals(n, r.read(TestKey.test).int32())));
      assertEquals(n + 1, queue.rollCycle().toSequenceNumber(tailer.index()));
    }
  }
}

/**
 * if one appender if much further ahead than the other, then the new append should jump
 * straight to the end rather than attempting to write a positions that are already occupied
 */
@Test
public void testAppendedSkipToEnd() {
  try (ChronicleQueue q = builder(getTmpDir(), this.wireType)
      .build()) {
    ExcerptAppender appender = q.acquireAppender();
    ExcerptAppender appender2 = q.acquireAppender();
    int indexCount = 100;
    for (int i = 0; i < indexCount; i++) {
      try (DocumentContext dc = appender.writingDocument()) {
        dc.wire().write("key").text("some more " + 1);
        Assert.assertEquals(i, q.rollCycle().toSequenceNumber(dc.index()));
      }
    }
    try (DocumentContext dc = appender2.writingDocument()) {
      dc.wire().write("key").text("some data " + indexCount);
      Assert.assertEquals(indexCount, q.rollCycle().toSequenceNumber(dc.index()));
    }
  }
}

@Test
public void testForwardFollowedBackBackwardTailer() {
  try (ChronicleQueue chronicle = builder(getTmpDir(), this.wireType)
      .rollCycle(TEST2_DAILY)
      .build()) {
    ExcerptAppender appender = chronicle.acquireAppender();
    int entries = chronicle.rollCycle().defaultIndexSpacing() + 2;
    for (int i = 0; i < entries; i++) {
      int finalI = i;
      appender.writeDocument(w -> w.writeEventName("hello").text("world" + finalI));
    }
    for (int i = 0; i < 3; i++) {
      readForward(chronicle, entries);
      readBackward(chronicle, entries);
    }
  }
}

assertEquals(10, queue.rollCycle().toSequenceNumber(atEnd.index()));
checkOneFile(baseDir);
fillResults(atEnd, results);

@Test
public void shouldNotBlowUpIfTryingToCreateQueueWithIncorrectRollCycle() {
  File tmpDir = getTmpDir();
  try (final ChronicleQueue queue = builder(tmpDir, wireType).rollCycle(DAILY).build()) {
    try (DocumentContext documentContext = queue.acquireAppender().writingDocument()) {
      documentContext.wire().write("somekey").text("somevalue");
    }
  }
  // we don't store which RollCycles enum was used and we try and match by format string, we
  // match the first RollCycles with the same format string, which may not
  // be the RollCycles it was written with
  try (final ChronicleQueue ignored = builder(tmpDir, wireType).rollCycle(HOURLY).build()) {
    assertEquals(TEST_DAILY, ignored.rollCycle());
  }
}

@Test
public void testToEndBeforeWrite() {
  try (ChronicleQueue chronicle = builder(getTmpDir(), wireType)
      .rollCycle(TEST2_DAILY)
      .build()) {
    ExcerptAppender appender = chronicle.acquireAppender();
    ExcerptTailer tailer = chronicle.createTailer();
    int entries = chronicle.rollCycle().defaultIndexSpacing() * 2 + 2;
    for (int i = 0; i < entries; i++) {
      tailer.toEnd();
      int finalI = i;
      appender.writeDocument(w -> w.writeEventName("hello").text("world" + finalI));
      tailer.readDocument(w -> w.read().text("world" + finalI, Assert::assertEquals));
    }
  }
}

try (DocumentContext dc = appender.writingDocument()) {
  dc.wire().getValueOut().text("hi-" + i);
  lastCycle = wqueue.rollCycle().toCycle(dc.index());