SingleChronicleQueue (OpenHFT/Chronicle-Queue 5.21.95 API)

java.lang.Object
- net.openhft.chronicle.core.io.AbstractCloseable
- - net.openhft.chronicle.queue.impl.single.SingleChronicleQueue

All Implemented Interfaces:

Closeable, AutoCloseable, net.openhft.chronicle.core.io.CloseableTracer, net.openhft.chronicle.core.io.ManagedCloseable, net.openhft.chronicle.core.io.QueryCloseable, net.openhft.chronicle.core.io.ReferenceOwner, ChronicleQueue, RollingChronicleQueue
```
public class SingleChronicleQueue
extends net.openhft.chronicle.core.io.AbstractCloseable
implements RollingChronicleQueue
```

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`DISK_SPACE_CHECKER_NAME`
`protected boolean`	`doubleBuffer`
`protected @NotNull net.openhft.chronicle.core.threads.EventLoop`	`eventLoop`
`protected @NotNull TableStore<SCQMeta>`	`metaStore`
`protected @NotNull WireStorePool`	`pool`
`static String`	`QUEUE_METADATA_FILE`
`protected int`	`sourceId`
`protected ThreadLocal<ExcerptAppender>`	`strongExcerptAppenderThreadLocal`
`static String`	`SUFFIX`

Fields inherited from class net.openhft.chronicle.core.io.AbstractCloseable
CHECK_THREAD_SAFETY, DISABLE_DISCARD_WARNING, DISABLE_THREAD_SAFETY, STRICT_DISCARD_WARNING, WARN_NS

Fields inherited from interface net.openhft.chronicle.queue.ChronicleQueue
TEST_BLOCK_SIZE

Fields inherited from interface net.openhft.chronicle.core.io.ReferenceOwner
INIT

Constructor Summary

Constructors
Modifier Constructor and Description

protected SingleChronicleQueue(@NotNull SingleChronicleQueueBuilder builder)

Constructors
Modifier	Constructor and Description
`protected`	`SingleChronicleQueue(@NotNull SingleChronicleQueueBuilder builder)`

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`@NotNull ExcerptAppender`	`acquireAppender()` Returns a ExcerptAppender for this ChronicleQueue that is local to the current Thread.
`<T> void`	`addCloseListener(net.openhft.chronicle.core.io.Closeable key)`
`WriteLock`	`appendLock()`
`long`	`blockSize()`
`long`	`bufferCapacity()`
`boolean`	`buffered()`
`void`	`clear()` Removes all the excerpts in the current ChronicleQueue.
`void`	`closeStore(@Nullable SingleChronicleQueueStore store)`
`long`	`countExcerpts(long fromIndex, long toIndex)` Will give you the number of excerpts between 2 index?s ( as exists on the current file system ).
`protected void`	`createAppenderCondition(@NotNull Condition createAppenderCondition)`
`@NotNull ExcerptTailer`	`createTailer()` Creates and returns a new ExcerptTailer for this ChronicleQueue.
`@NotNull ExcerptTailer`	`createTailer(String id)` Creates and returns a new ExcerptTailer for this ChronicleQueue with the given unique `id`.
`int`	`cycle()`
`int`	`cycle(net.openhft.chronicle.core.time.TimeProvider timeProvider)`
`protected CycleCalculator`	`cycleCalculator(ZoneId zoneId)`
`int`	`deltaCheckpointInterval()` Returns the Delta Checkpoint Interval for this ChronicleQueue.
`@NotNull String`	`dump()` Creates and returns a new String representation of this ChronicleQueue in YAML-format.
`void`	`dump(@NotNull Writer writer, long fromIndex, long toIndex)` Dumps a representation of this ChronicleQueue to the provided `writer` in YAML-format.
`@NotNull String`	`dumpLastHeader()` Creates and returns a new String representation of this ChronicleQueue's last header in YAML-format.
`long`	`entryCount()` This method creates a tailer and count the number of messages between the start of the queue ( see @link firstIndex() ) and the end.
`long`	`epoch()`
`@NotNull net.openhft.chronicle.core.threads.EventLoop`	`eventLoop()`
`long`	`exceptsPerCycle(int cycle)`
`@NotNull File`	`file()` Returns the base directory where ChronicleQueue stores its data.
`@NotNull String`	`fileAbsolutePath()` Returns the absolute path of the base directory where ChronicleQueue stores its data.
`protected int`	`fileToCycle(File queueFile)` Deprecated.
`protected void`	`finalize()`
`int`	`firstCycle()`
`long`	`firstIndex()` Returns the lowest valid index available for this ChronicleQueue, or `Long.MAX_VALUE` if no such index exists.
`int`	`indexCount()`
`@NotNull net.openhft.chronicle.core.values.LongValue`	`indexForId(@NotNull String id)`
`int`	`indexSpacing()`
`long`	`lastAcknowledgedIndexReplicated()` when using replication to another host, this is the highest last index that has been confirmed to have been read by all of the remote host(s).
`void`	`lastAcknowledgedIndexReplicated(long newValue)` Sets the last index that has been sent to a remote host.
`int`	`lastCycle()`
`long`	`lastIndex()` Returns the index of the last non-metadata excerpt written to this ChronicleQueue, or -1 if the queue is empty.
`long`	`lastIndexReplicated()` when using replication to another host, this is the maximum last index that has been sent to any of the remote host(s).
`void`	`lastIndexReplicated(long indexReplicated)` Sets the last index that has been sent to a remote host.
`NavigableSet<Long>`	`listCyclesBetween(int lowerCycle, int upperCycle)`
`TableStore`	`metaStore()`
`protected @NotNull ExcerptAppender`	`newAppender()`
`int`	`nextCycle(int cycle, @NotNull TailerDirection direction)` the next available cycle, no cycle will be created by this method, this method is typically used by a tailer to jump to the next cycle when the cycles are not adjacent.
`@NotNull Consumer<net.openhft.chronicle.bytes.BytesRingBufferStats>`	`onRingBufferStats()`
`long`	`overlapSize()`
`protected void`	`performClose()`
`@NotNull QueueLock`	`queueLock()`
`void`	`refreshDirectoryListing()` Refreshed this ChronicleQueue's view of the directory used for storing files.
`@NotNull RollCycle`	`rollCycle()` Returns the `RollCycle` for this ChronicleQueue.
`int`	`sourceId()` Returns the source id.
`protected StoreFileListener`	`storeFileListener()`
`@Nullable SingleChronicleQueueStore`	`storeForCycle(int cycle, long epoch, boolean createIfAbsent, SingleChronicleQueueStore oldStore)`
`protected @Nullable net.openhft.chronicle.core.values.LongValue`	`tableStoreAcquire(CharSequence key, long index)`
`long`	`tableStoreGet(CharSequence key)`
`void`	`tableStorePut(CharSequence key, long index)`
`protected boolean`	`threadSafetyCheck(boolean isUsed)`
`@NotNull net.openhft.chronicle.core.time.TimeProvider`	`time()` Returns the `TimeProvider` for this ChronicleQueue.
`@NotNull String`	`toString()`
`@NotNull net.openhft.chronicle.wire.WireType`	`wireType()` Returns the `WireType` used for this ChronicleQueue.

Methods inherited from class net.openhft.chronicle.core.io.AbstractCloseable
assertCloseablesClosed, clearUsedByThread, close, createdHere, disableCloseableTracing, enableCloseableTracing, isClosed, isClosing, isInUserThread, performCloseInBackground, referenceId, resetUsedByThread, shouldPerformCloseInBackground, shouldWaitForClosed, throwExceptionIfClosed, throwExceptionIfClosedInSetter, unmonitor, waitForCloseablesToClose, waitForClosed, warnAndCloseIfNotClosed

Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface net.openhft.chronicle.queue.ChronicleQueue
dump, methodWriter, methodWriterBuilder, single, singleBuilder, singleBuilder, singleBuilder, singleBuilder

Methods inherited from interface net.openhft.chronicle.core.io.Closeable
close, closeQuietly, closeQuietly, notifyClosing, warnAndCloseIfNotClosed

Methods inherited from interface net.openhft.chronicle.core.io.QueryCloseable
isClosed, isClosing, throwExceptionIfClosed

Methods inherited from interface net.openhft.chronicle.core.io.ReferenceOwner
referenceName, temporary

- Field Detail
  - SUFFIX
```
public static final String SUFFIX
```
    See Also:
    
    Constant Field Values
  - QUEUE_METADATA_FILE
```
public static final String QUEUE_METADATA_FILE
```
    See Also:
    
    Constant Field Values
  - DISK_SPACE_CHECKER_NAME
```
public static final String DISK_SPACE_CHECKER_NAME
```
    See Also:
    
    Constant Field Values
  - eventLoop
```
@NotNull
protected final @NotNull net.openhft.chronicle.core.threads.EventLoop eventLoop
```
  - metaStore
```
@NotNull
protected final @NotNull TableStore<SCQMeta> metaStore
```
  - pool
```
@NotNull
protected final @NotNull WireStorePool pool
```
  - doubleBuffer
```
protected final boolean doubleBuffer
```
  - sourceId
```
protected int sourceId
```
  - strongExcerptAppenderThreadLocal
```
protected final ThreadLocal<ExcerptAppender> strongExcerptAppenderThreadLocal
```
- Constructor Detail
  - SingleChronicleQueue
```
protected SingleChronicleQueue(@NotNull
                               @NotNull SingleChronicleQueueBuilder builder)
```
- Method Detail
  - createAppenderCondition
```
protected void createAppenderCondition(@NotNull
                                       @NotNull Condition createAppenderCondition)
```
  - cycleCalculator
```
protected CycleCalculator cycleCalculator(ZoneId zoneId)
```
  - sourceId
```
public int sourceId()
```
    Description copied from interface: ChronicleQueue
    
    Returns the source id. Source is is used to identify the queue in MessageHistory
    The source id is non-negative.
    
    Specified by:
    
    sourceId in interface ChronicleQueue
    
    Returns:
    
    the source id
  - lastAcknowledgedIndexReplicated
```
public long lastAcknowledgedIndexReplicated()
```
    when using replication to another host, this is the highest last index that has been confirmed to have been read by all of the remote host(s).
    
    Specified by:
    
    lastAcknowledgedIndexReplicated in interface ChronicleQueue
    
    Returns:
    
    the last index that was replicated and acknowledged by all remote hosts
  - lastAcknowledgedIndexReplicated
```
public void lastAcknowledgedIndexReplicated(long newValue)
```
    Description copied from interface: ChronicleQueue
    
    Sets the last index that has been sent to a remote host.
    
    Specified by:
    
    lastAcknowledgedIndexReplicated in interface ChronicleQueue
    
    Parameters:
    
    newValue - last acknowledged index that has been sent to the remote host(s).
    
    See Also:
    
    ChronicleQueue.lastAcknowledgedIndexReplicated()
  - refreshDirectoryListing
```
public void refreshDirectoryListing()
```
    Description copied from interface: ChronicleQueue
    
    Refreshed this ChronicleQueue's view of the directory used for storing files.
    Invoke this method if you delete file from a chronicle-queue directory
    The problem solved by this is that we cache the structure of the queue directory in order to reduce file system adds latency. Calling this method, after deleting .cq4 files, will update the internal caches accordingly,
    
    Specified by:
    
    refreshDirectoryListing in interface ChronicleQueue
  - lastIndexReplicated
```
public long lastIndexReplicated()
```
    when using replication to another host, this is the maximum last index that has been sent to any of the remote host(s).
    
    Specified by:
    
    lastIndexReplicated in interface ChronicleQueue
    
    Returns:
    
    the last index that was replicated to a remote host
  - lastIndexReplicated
```
public void lastIndexReplicated(long indexReplicated)
```
    Description copied from interface: ChronicleQueue
    
    Sets the last index that has been sent to a remote host.
    
    Specified by:
    
    lastIndexReplicated in interface ChronicleQueue
    
    Parameters:
    
    indexReplicated - last index that has been sent to the remote host.
    
    See Also:
    
    ChronicleQueue.lastIndexReplicated()
  - clear
```
public void clear()
```
    Description copied from interface: ChronicleQueue
    
    Removes all the excerpts in the current ChronicleQueue.
    
    Specified by:
    
    clear in interface ChronicleQueue
  - file
```
@NotNull
public @NotNull File file()
```
    Description copied from interface: ChronicleQueue
    
    Returns the base directory where ChronicleQueue stores its data.
    
    Specified by:
    
    file in interface ChronicleQueue
    
    Returns:
    
    the base directory where ChronicleQueue stores its data
  - fileAbsolutePath
```
@NotNull
public @NotNull String fileAbsolutePath()
```
    Description copied from interface: ChronicleQueue
    
    Returns the absolute path of the base directory where ChronicleQueue stores its data.
    This value might be cached, as getAbsolutePath is expensive
    
    Specified by:
    
    fileAbsolutePath in interface ChronicleQueue
    
    Returns:
    
    the absolute path of the base directory where ChronicleQueue stores its data
  - dumpLastHeader
```
@NotNull
public @NotNull String dumpLastHeader()
```
    Description copied from interface: ChronicleQueue
    
    Creates and returns a new String representation of this ChronicleQueue's last header in YAML-format.
    
    Specified by:
    
    dumpLastHeader in interface ChronicleQueue
    
    Returns:
    
    a new String representation of this ChronicleQueue's last header in YAML-format
  - dump
```
@NotNull
public @NotNull String dump()
```
    Description copied from interface: ChronicleQueue
    
    Creates and returns a new String representation of this ChronicleQueue in YAML-format.
    
    Specified by:
    
    dump in interface ChronicleQueue
    
    Returns:
    
    a new String representation of this ChronicleQueue in YAML-format
  - dump
```
public void dump(@NotNull
                 @NotNull Writer writer,
                 long fromIndex,
                 long toIndex)
```
    Description copied from interface: ChronicleQueue
    
    Dumps a representation of this ChronicleQueue to the provided writer in YAML-format. Dumping will be made from the provided (@code fromIndex) (inclusive) to the provided toIndex (inclusive).
    
    Specified by:
    
    dump in interface ChronicleQueue
    
    Parameters:
    
    writer - to write to
    
    fromIndex - first index (inclusive)
    
    toIndex - last index (inclusive)
  - indexCount
```
public int indexCount()
```
    Specified by:
    
    indexCount in interface RollingChronicleQueue
    
    Returns:
    
    the max size of each index and also the number number of index arrays. indexCount^2 is the maximum number of index queue entries.
  - indexSpacing
```
public int indexSpacing()
```
    Specified by:
    
    indexSpacing in interface RollingChronicleQueue
    
    Returns:
    
    the spacing between indexed entries. If 1 then every entry is indexed.
  - epoch
```
public long epoch()
```
    Specified by:
    
    epoch in interface RollingChronicleQueue
  - rollCycle
```
@NotNull
public @NotNull RollCycle rollCycle()
```
    Description copied from interface: ChronicleQueue
    
    Returns the RollCycle for this ChronicleQueue.
    
    Specified by:
    
    rollCycle in interface ChronicleQueue
    
    Specified by:
    
    rollCycle in interface RollingChronicleQueue
    
    Returns:
    
    the RollCycle for this ChronicleQueue
    
    See Also:
    
    RollCycle
  - deltaCheckpointInterval
```
public int deltaCheckpointInterval()
```
    Description copied from interface: ChronicleQueue
    
    Returns the Delta Checkpoint Interval for this ChronicleQueue.
    The value returned is always a power of two.
    
    Specified by:
    
    deltaCheckpointInterval in interface ChronicleQueue
    
    Specified by:
    
    deltaCheckpointInterval in interface RollingChronicleQueue
    
    Returns:
    
    the checkpointInterval used by delta wire
  - buffered
```
public boolean buffered()
```
    Returns:
    
    if we uses a ring buffer to buffer the appends, the Excerpts are written to the Chronicle Queue using a background thread
  - eventLoop
```
@NotNull
public @NotNull net.openhft.chronicle.core.threads.EventLoop eventLoop()
```
  - newAppender
```
@NotNull
protected @NotNull ExcerptAppender newAppender()
```
  - storeFileListener
```
protected StoreFileListener storeFileListener()
```
  - acquireAppender
```
@NotNull
public @NotNull ExcerptAppender acquireAppender()
```
    Description copied from interface: ChronicleQueue
    
    Returns a ExcerptAppender for this ChronicleQueue that is local to the current Thread.
    An Appender can be used to store new excerpts sequentially to the queue.
    An Appender is NOT thread-safe and, in addition to that, confined to be used by the creating thread only.. Sharing an Appender across threads is unsafe and will inevitably lead to errors and unspecified behaviour.
    This method returns a ThreadLocal appender, so does not produce any garbage, hence it's safe to simply call this method every time an appender is needed.
    
    Specified by:
    
    acquireAppender in interface ChronicleQueue
    
    Returns:
    
    Returns a ExcerptAppender for this ChronicleQueue that is local to the current Thread
  - queueLock
```
@NotNull
public @NotNull QueueLock queueLock()
```
    Specified by:
    
    queueLock in interface RollingChronicleQueue
    
    Returns:
    
    the QueueLock This lock is held while the queue replication cluster is back-filling. By Back-filling we mean that, as part of the fail-over process a sink, may actually have more data than a source, hence we need to back copy data from the sinks to the source upon startup. While we are doing this we lock the queue so that new appenders can not be created.
    Queue locks have no impact if you are not using queue replication because the are implemented as a no-op.
  - appendLock
```
public WriteLock appendLock()
```
    Returns:
    
    the WriteLock that is used to lock appends. This is only used by Queue Enterprise sink replication handlers. See Queue Enterprise docs for more details.
  - createTailer
```
@NotNull
public @NotNull ExcerptTailer createTailer(String id)
```
    Description copied from interface: ChronicleQueue
    
    Creates and returns a new ExcerptTailer for this ChronicleQueue with the given unique id.
    The id is used to persistently store the latest index for the Tailer. Any new Tailer with a previously used id will continue where the old one left off. A Tailer is NOT thread-safe. A Tailer can be created by one Thread and might be used by at most one other Thread.. Sharing a Tailer across threads is unsafe and will inevitably lead to errors and unspecified behaviour.
    If the provided id is null, the Tailer will be unnamed and this is equivalent to invoking ChronicleQueue.createTailer().
    
    Specified by:
    
    createTailer in interface ChronicleQueue
    
    Parameters:
    
    id - unique id for a tailer which uses to track where it was up to
    
    Returns:
    
    a new ExcerptTailer for this ChronicleQueue with the given unique id
    
    See Also:
    
    ChronicleQueue.createTailer()
  - indexForId
```
@NotNull
public @NotNull net.openhft.chronicle.core.values.LongValue indexForId(@NotNull
                                                                                @NotNull String id)
```
    Specified by:
    
    indexForId in interface ChronicleQueue
  - createTailer
```
@NotNull
public @NotNull ExcerptTailer createTailer()
```
    Description copied from interface: ChronicleQueue
    
    Creates and returns a new ExcerptTailer for this ChronicleQueue. A Tailer is NOT thread-safe. A Tailer can be created by one Thread and might be used by at most one other Thread.. Sharing a Tailer across threads is unsafe and will inevitably lead to errors and unspecified behaviour.
    The tailor is created at the start, so unless you are using named tailors, this method is the same as calling `net.openhft.chronicle.queue.ChronicleQueue#createTailer(java.lang.String).toStart()`
    
    Specified by:
    
    createTailer in interface ChronicleQueue
    
    Returns:
    
    a new ExcerptTailer to read sequentially.
    
    See Also:
    
    ChronicleQueue.createTailer(String)
  - storeForCycle
```
@Nullable
public final @Nullable SingleChronicleQueueStore storeForCycle(int cycle,
                                                                         long epoch,
                                                                         boolean createIfAbsent,
                                                                         SingleChronicleQueueStore oldStore)
```
    Specified by:
    
    storeForCycle in interface RollingChronicleQueue
    
    Parameters:
    
    cycle - the cycle
    
    epoch - an epoch offset as the number of number of milliseconds since January 1, 1970, 00:00:00 GMT
    
    createIfAbsent - create missing stores if true, or return null if missing
    
    Returns:
    
    the WireStore associated with this cycle, or null if !createIfAbsent is false and absent
  - nextCycle
```
public int nextCycle(int cycle,
                     @NotNull
                     @NotNull TailerDirection direction)
              throws ParseException
```
    Description copied from interface: RollingChronicleQueue
    
    the next available cycle, no cycle will be created by this method, this method is typically used by a tailer to jump to the next cycle when the cycles are not adjacent.
    
    Specified by:
    
    nextCycle in interface RollingChronicleQueue
    
    Parameters:
    
    cycle - the current cycle
    
    direction - the direction
    
    Returns:
    
    the next available cycle from the current cycle, or -1 if there is no next cycle
    
    Throws:
    
    ParseException
  - exceptsPerCycle
```
public long exceptsPerCycle(int cycle)
```
  - countExcerpts
```
public long countExcerpts(long fromIndex,
                          long toIndex)
```
    Will give you the number of excerpts between 2 index?s ( as exists on the current file system ). If intermediate chronicle files are removed this will effect the result.
    
    Specified by:
    
    countExcerpts in interface RollingChronicleQueue
    
    Parameters:
    
    fromIndex - the lower index
    
    toIndex - the higher index
    
    Returns:
    
    will give you the number of excerpts between 2 index?s. It?s not as simple as just subtracting one number from the other.
    
    Throws:
    
    IllegalStateException - if we are not able to read the chronicle files
  - listCyclesBetween
```
public NavigableSet<Long> listCyclesBetween(int lowerCycle,
                                            int upperCycle)
                                     throws ParseException
```
    Throws:
    
    ParseException
  - addCloseListener
```
public <T> void addCloseListener(net.openhft.chronicle.core.io.Closeable key)
```
  - performClose
```
protected void performClose()
```
    Specified by:
    
    performClose in class net.openhft.chronicle.core.io.AbstractCloseable
  - finalize
```
protected void finalize()
                 throws Throwable
```
    Overrides:
    
    finalize in class Object
    
    Throws:
    
    Throwable
  - closeStore
```
public final void closeStore(@Nullable
                             @Nullable SingleChronicleQueueStore store)
```
  - cycle
```
public final int cycle()
```
    Specified by:
    
    cycle in interface RollingChronicleQueue
    
    Returns:
    
    the current cycle
  - cycle
```
public final int cycle(net.openhft.chronicle.core.time.TimeProvider timeProvider)
```
  - firstIndex
```
public long firstIndex()
```
    Description copied from interface: ChronicleQueue
    
    Returns the lowest valid index available for this ChronicleQueue, or Long.MAX_VALUE if no such index exists.
    
    Specified by:
    
    firstIndex in interface ChronicleQueue
    
    Returns:
    
    the lowest valid index available for this ChronicleQueue, or Long.MAX_VALUE if no such index exists
  - lastIndex
```
public long lastIndex()
```
    Description copied from interface: ChronicleQueue
    
    Returns the index of the last non-metadata excerpt written to this ChronicleQueue, or -1 if the queue is empty.
    The value returned by this method will not be reliable in the event the queue is being written to concurrently, as subsequent excerpts may have been written by the time it is returned.
    
    Specified by:
    
    lastIndex in interface ChronicleQueue
    
    Returns:
    
    The highest non-metadata index available for this ChronicleQueue, or -1 if the queue is empty
  - entryCount
```
public long entryCount()
```
    This method creates a tailer and count the number of messages between the start of the queue ( see @link firstIndex() ) and the end.
    
    Specified by:
    
    entryCount in interface RollingChronicleQueue
    
    Returns:
    
    the number of messages in the queue
  - firstCycle
```
public int firstCycle()
```
    Specified by:
    
    firstCycle in interface RollingChronicleQueue
    
    Returns:
    
    the first cycle number found, or Integer.MAX_VALUE is none found.
  - lastCycle
```
public int lastCycle()
```
    Specified by:
    
    lastCycle in interface RollingChronicleQueue
    
    Returns:
    
    the lastCycle available or Integer.MIN_VALUE if none is found.
  - fileToCycle
```
@Deprecated
protected int fileToCycle(File queueFile)
```
    Deprecated.
  - onRingBufferStats
```
@NotNull
public @NotNull Consumer<net.openhft.chronicle.bytes.BytesRingBufferStats> onRingBufferStats()
```
  - blockSize
```
public long blockSize()
```
  - overlapSize
```
public long overlapSize()
```
  - wireType
```
@NotNull
public @NotNull net.openhft.chronicle.wire.WireType wireType()
```
    Description copied from interface: ChronicleQueue
    
    Returns the WireType used for this ChronicleQueue.
    For example, the WireType could be WireTypes.TEXT or WireTypes.BINARY.
    
    Specified by:
    
    wireType in interface ChronicleQueue
    
    Returns:
    
    Returns the wire type used for this ChronicleQueue
    
    See Also:
    
    WireType
  - bufferCapacity
```
public long bufferCapacity()
```
  - toString
```
@NotNull
public @NotNull String toString()
```
    Overrides:
    
    toString in class net.openhft.chronicle.core.io.AbstractCloseable
  - time
```
@NotNull
public @NotNull net.openhft.chronicle.core.time.TimeProvider time()
```
    Description copied from interface: ChronicleQueue
    
    Returns the TimeProvider for this ChronicleQueue.
    
    Specified by:
    
    time in interface ChronicleQueue
    
    Returns:
    
    the TimeProvider for this ChronicleQueue
    
    See Also:
    
    TimeProvider
  - metaStore
```
public TableStore metaStore()
```
  - threadSafetyCheck
```
protected boolean threadSafetyCheck(boolean isUsed)
```
    Overrides:
    
    threadSafetyCheck in class net.openhft.chronicle.core.io.AbstractCloseable
  - tableStorePut
```
public void tableStorePut(CharSequence key,
                          long index)
```
  - tableStoreAcquire
```
@Nullable
protected @Nullable net.openhft.chronicle.core.values.LongValue tableStoreAcquire(CharSequence key,
                                                                                            long index)
```
  - tableStoreGet
```
public long tableStoreGet(CharSequence key)
```

Class SingleChronicleQueue

Field Summary

Fields inherited from class net.openhft.chronicle.core.io.AbstractCloseable

Fields inherited from interface net.openhft.chronicle.queue.ChronicleQueue

Fields inherited from interface net.openhft.chronicle.core.io.ReferenceOwner

Constructor Summary

Method Summary

Methods inherited from class net.openhft.chronicle.core.io.AbstractCloseable

Methods inherited from class java.lang.Object

Methods inherited from interface net.openhft.chronicle.queue.ChronicleQueue

Methods inherited from interface net.openhft.chronicle.core.io.Closeable

Methods inherited from interface net.openhft.chronicle.core.io.QueryCloseable

Methods inherited from interface net.openhft.chronicle.core.io.ReferenceOwner

Field Detail

SUFFIX

QUEUE_METADATA_FILE

DISK_SPACE_CHECKER_NAME

eventLoop

metaStore

pool

doubleBuffer

sourceId

strongExcerptAppenderThreadLocal

Constructor Detail

SingleChronicleQueue

Method Detail

createAppenderCondition

cycleCalculator

sourceId

lastAcknowledgedIndexReplicated

lastAcknowledgedIndexReplicated

refreshDirectoryListing

lastIndexReplicated

lastIndexReplicated

clear

file

fileAbsolutePath

dumpLastHeader

dump

dump

indexCount

indexSpacing

epoch

rollCycle

deltaCheckpointInterval

buffered

eventLoop

newAppender

storeFileListener

acquireAppender

queueLock

appendLock

createTailer

indexForId

createTailer

storeForCycle

nextCycle

exceptsPerCycle

countExcerpts

listCyclesBetween

addCloseListener

performClose

finalize

closeStore

cycle

cycle

firstIndex

lastIndex

entryCount

firstCycle

lastCycle

fileToCycle

onRingBufferStats

blockSize

overlapSize

wireType

bufferCapacity

toString

time

metaStore