import org.agrona.LangUtil; //导入依赖的package包/类
private static Journalling newJournalStrategy(final String journallingClassName)
{
    final Path journalDir = Paths.get(JOURNAL_DIR_NAME);

    Journalling journalling = null;

    if (journallingClassName == null)
    {
        journalling = new PositionalJournalling(journalDir, JOURNAL_FILE_SIZE, JOURNAL_PAGE_SIZE, JOURNAL_FILE_COUNT);
    }
    else
    {
        try
        {
            journalling = (Journalling)Class.forName(journallingClassName)
                .getConstructor(Path.class, Long.class, Integer.class)
                    .newInstance(journalDir, JOURNAL_FILE_SIZE, JOURNAL_FILE_COUNT);
        }
        catch (final Exception ex)
        {
            LangUtil.rethrowUnchecked(ex);
        }
    }

    return journalling;
}
 

import org.agrona.LangUtil; //导入依赖的package包/类
@Override
public Journalling open(final AllocationMode allocationMode)
{
    try
    {
        journalAllocator.preallocate(fileSize, allocationMode);

        assignJournal(0);
    }
    catch (IOException ioe)
    {
        LangUtil.rethrowUnchecked(ioe);
    }

    return this;
}
 

import org.agrona.LangUtil; //导入依赖的package包/类
@Override
public void onMessage(int msgTypeId, MutableDirectBuffer buffer, int index, int length)
{
    try
    {
        while (replicaPublication.offer(buffer, index, length) < 0L)
        {
            idleStrategy.idle(0);
        }

        UNSAFE.putOrderedLong(this, MSG_REPLICATED_OFFSET, msgReplicated + 1);
        UNSAFE.putOrderedLong(this, BYTES_REPLICATED_OFFSET, bytesReplicated + length);
    }
    catch (Exception ex)
    {
        LangUtil.rethrowUnchecked(ex);
    }
    finally
    {
        while (!nextRingBuffer.write(msgTypeId, buffer, index, length))
        {
            idleStrategy.idle(0);
        }
    }
}
 

import org.agrona.LangUtil; //导入依赖的package包/类
private void assertFilesEqual(
    final String logFileDir, final String otherLogFileDir, final String path)
{
    final File file = new File(logFileDir, path);
    assertTrue(file.getAbsolutePath(), file.exists());

    final File otherFile = new File(otherLogFileDir, path);
    assertTrue(otherFile.getAbsolutePath(), otherFile.exists());

    assertEquals("lengths differ", file.length(), otherFile.length());

    try
    {
        final byte[] bytes = Files.readAllBytes(file.toPath());
        final byte[] otherBytes = Files.readAllBytes(otherFile.toPath());

        assertArrayEquals("For file: " + path, bytes, otherBytes);
    }
    catch (final IOException ex)
    {
        LangUtil.rethrowUnchecked(ex);
    }
}
 

import org.agrona.LangUtil; //导入依赖的package包/类
void readMessage(final Decoder decoder)
{
    final ByteBuffer buffer = ByteBuffer.allocateDirect(BUFFER_SIZE);
    final MutableAsciiBuffer asciiBuffer = new MutableAsciiBuffer(buffer);

    try
    {
        final int read = socket.read(buffer);
        DebugLogger.log(FIX_TEST, "< [" + asciiBuffer.getAscii(OFFSET, read) + "]");
        decoder.decode(asciiBuffer, OFFSET, read);
    }
    catch (final IOException ex)
    {
        LangUtil.rethrowUnchecked(ex);
    }
}
 

import org.agrona.LangUtil; //导入依赖的package包/类
private void send(final Encoder encoder)
{
    try
    {
        final long result = encoder.encode(writeAsciiBuffer, OFFSET);
        final int offset = Encoder.offset(result);
        final int length = Encoder.length(result);
        encoder.reset();
        writeBuffer.position(offset).limit(offset + length);
        final int written = socket.write(writeBuffer);
        assertEquals(length, written);
        DebugLogger.log(FIX_TEST, "> [" + writeAsciiBuffer.getAscii(OFFSET, length) + "]");
        writeBuffer.clear();
    }
    catch (final IOException ex)
    {
        LangUtil.rethrowUnchecked(ex);
    }
}
 

import org.agrona.LangUtil; //导入依赖的package包/类
public static MappedFile map(final File bufferFile, final int size)
{
    final FileChannel fileChannel;
    try
    {
        if (bufferFile.exists())
        {
            // NB: closing RAF or FileChannel closes them both
            fileChannel = new RandomAccessFile(bufferFile, "rw").getChannel();
        }
        else
        {
            fileChannel = IoUtil.createEmptyFile(bufferFile, (long)size);
        }

        final MappedByteBuffer mappedBuffer = fileChannel.map(READ_WRITE, 0, fileChannel.size());
        return new MappedFile(bufferFile, fileChannel, new UnsafeBuffer(mappedBuffer));
    }
    catch (final IOException ex)
    {
        LangUtil.rethrowUnchecked(ex);
        return null;
    }
}
 

import org.agrona.LangUtil; //导入依赖的package包/类
public TcpChannelSupplier(final EngineConfiguration configuration)
{
    final boolean hasBindAddress = configuration.hasBindAddress();
    this.configuration = configuration;
    try
    {
        selector = Selector.open();

        if (hasBindAddress)
        {

            listeningChannel = ServerSocketChannel.open();
            listeningChannel.bind(configuration.bindAddress()).configureBlocking(false);
            listeningChannel.register(selector, SelectionKey.OP_ACCEPT);
        }
        else
        {
            listeningChannel = null;
        }
    }
    catch (final IOException ex)
    {
        LangUtil.rethrowUnchecked(ex);
    }
}
 

import org.agrona.LangUtil; //导入依赖的package包/类
public Reply<?> resetSessionIds(final File backupLocation, final IdleStrategy idleStrategy)
{
    if (backupLocation != null && !backupLocation.exists())
    {
        try
        {
            if (!backupLocation.createNewFile())
            {
                throw new IllegalStateException("Could not create: " + backupLocation);
            }
        }
        catch (final IOException ex)
        {
            LangUtil.rethrowUnchecked(ex);
        }
    }

    final ResetSessionIdsCommand command = new ResetSessionIdsCommand(backupLocation);
    if (adminCommands.offer(command))
    {
        return command;
    }

    return null;
}
 

import org.agrona.LangUtil; //导入依赖的package包/类
private void endpointBufferUpdatedWith(final ToIntFunction<ByteBuffer> bufferUpdater)
{
    try
    {
        doAnswer(
            (invocation) ->
            {
                final ByteBuffer buffer = (ByteBuffer)invocation.getArguments()[0];
                return bufferUpdater.applyAsInt(buffer);
            }).when(mockChannel).read(any(ByteBuffer.class));
    }
    catch (final IOException ex)
    {
        // Should never happen, test in error
        LangUtil.rethrowUnchecked(ex);
    }
}
 

import org.agrona.LangUtil; //导入依赖的package包/类
@Parameterized.Parameters(name = "Acceptance: {1}")
public static Collection<Object[]> data()
{
    try
    {
        final List<Object[]> tests = new ArrayList<>();
        tests.addAll(fix42Tests());
        tests.addAll(fix42CustomisedTests());
        return tests;
    }
    catch (Exception e)
    {
        LangUtil.rethrowUnchecked(e);
        return null;
    }
}
 

import org.agrona.LangUtil; //导入依赖的package包/类
private void onMessage(final Message message, final SessionID sessionID)
{
    messages.add(message);
    try
    {
        final String msgType = message.getHeader().getField(new MsgType()).getValue();
        if (MsgType.LOGOUT.equals(msgType))
        {
            logouts.add(sessionID);
        }
    }
    catch (FieldNotFound fieldNotFound)
    {
        LangUtil.rethrowUnchecked(fieldNotFound);
    }
}
 

import org.agrona.LangUtil; //导入依赖的package包/类
private int record()
{
    int workCount = 1;
    try
    {
        workCount = image.rawPoll(recordingWriter, blockLengthLimit);
        if (0 != workCount)
        {
            recordingEventsProxy.progress(recordingId, image.joinPosition(), position.getWeak());
        }

        if (image.isClosed() || recordingWriter.isClosed())
        {
            abort();
        }
    }
    catch (final Exception ex)
    {
        abort();
        LangUtil.rethrowUnchecked(ex);
    }

    return workCount;
}
 

import org.agrona.LangUtil; //导入依赖的package包/类
private void closeOnError(final Throwable ex, final String errorMessage)
{
    state = State.INACTIVE;
    CloseHelper.quietClose(replayPublication);

    if (null != cursor)
    {
        cursor.close();
    }

    if (!controlSession.isDone())
    {
        controlSession.sendResponse(
            correlationId,
            ControlResponseCode.ERROR,
            errorMessage,
            threadLocalControlResponseProxy);
    }

    if (ex != null)
    {
        LangUtil.rethrowUnchecked(ex);
    }
}
 

import org.agrona.LangUtil; //导入依赖的package包/类
private void newRecordingSegmentFile()
{
    final File file = new File(archiveDir, segmentFileName(recordingId, segmentIndex));

    RandomAccessFile recordingFile = null;
    try
    {
        recordingFile = new RandomAccessFile(file, "rw");
        recordingFile.setLength(segmentFileLength + DataHeaderFlyweight.HEADER_LENGTH);
        recordingFileChannel = recordingFile.getChannel();
        if (forceWrites && null != archiveDirChannel)
        {
            archiveDirChannel.force(forceMetadata);
        }
    }
    catch (final IOException ex)
    {
        CloseHelper.quietClose(recordingFile);
        close();
        LangUtil.rethrowUnchecked(ex);
    }
}
 

import org.agrona.LangUtil; //导入依赖的package包/类
/**
 * Receive a datagram from the media layer.
 *
 * @param buffer into which the datagram will be received.
 * @return the source address of the datagram if one is available otherwise false.
 */
public InetSocketAddress receive(final ByteBuffer buffer)
{
    buffer.clear();

    InetSocketAddress address = null;
    try
    {
        address = (InetSocketAddress)receiveDatagramChannel.receive(buffer);
    }
    catch (final PortUnreachableException | ClosedChannelException ignored)
    {
        // do nothing
    }
    catch (final Exception ex)
    {
        LangUtil.rethrowUnchecked(ex);
    }

    return address;
}
 

import org.agrona.LangUtil; //导入依赖的package包/类
/**
 * Send contents of {@link java.nio.ByteBuffer} to remote address
 *
 * @param buffer        to send
 * @param remoteAddress to send to
 * @return number of bytes sent
 */
public int sendTo(final ByteBuffer buffer, final InetSocketAddress remoteAddress)
{
    int bytesSent = 0;
    try
    {
        if (null != sendDatagramChannel)
        {
            bytesSent = sendDatagramChannel.send(buffer, remoteAddress);
        }
    }
    catch (final IOException ex)
    {
        LangUtil.rethrowUnchecked(ex);
    }

    return bytesSent;
}
 

import org.agrona.LangUtil; //导入依赖的package包/类
private static NetworkInterface newNetworkInterface(final String name)
{
    NetworkInterface networkInterface = null;
    try
    {
        final Constructor<NetworkInterface> ctor = NetworkInterface.class.getDeclaredConstructor();
        ctor.setAccessible(true);
        final Field nameField = NetworkInterface.class.getDeclaredField("name");
        nameField.setAccessible(true);

        networkInterface = ctor.newInstance();
        nameField.set(networkInterface, name);

    }
    catch (final Exception ex)
    {
        LangUtil.rethrowUnchecked(ex);
    }

    return networkInterface;
}
 

import org.agrona.LangUtil; //导入依赖的package包/类
private static InterfaceAddress newInterfaceAddress(final InetAddress inetAddress, final short maskLength)
{
    InterfaceAddress interfaceAddress = null;
    try
    {
        final Constructor<InterfaceAddress> ctor = InterfaceAddress.class.getDeclaredConstructor();
        ctor.setAccessible(true);
        final Field addressField = InterfaceAddress.class.getDeclaredField("address");
        addressField.setAccessible(true);
        final Field maskLengthField = InterfaceAddress.class.getDeclaredField("maskLength");
        maskLengthField.setAccessible(true);

        interfaceAddress = ctor.newInstance();
        addressField.set(interfaceAddress, inetAddress);
        maskLengthField.set(interfaceAddress, maskLength);
    }
    catch (final Exception ex)
    {
        LangUtil.rethrowUnchecked(ex);
    }

    return interfaceAddress;
}
 

import org.agrona.LangUtil; //导入依赖的package包/类
/**
 * Allocate a new counter with a given label and type.
 *
 * @param label  to describe the counter.
 * @param typeId for the type of counter.
 * @return the id allocated for the counter.
 */
public int allocate(final String label, final int typeId)
{
    final int counterId = nextCounterId();
    checkCountersCapacity(counterId);

    final int recordOffset = metaDataOffset(counterId);
    checkMetaDataCapacity(recordOffset);

    try
    {
        metaDataBuffer.putInt(recordOffset + TYPE_ID_OFFSET, typeId);
        metaDataBuffer.putLong(recordOffset + FREE_FOR_REUSE_DEADLINE_OFFSET, NOT_FREE_TO_REUSE);
        putLabel(recordOffset, label);

        metaDataBuffer.putIntOrdered(recordOffset, RECORD_ALLOCATED);
    }
    catch (final Exception ex)
    {
        freeList.pushInt(counterId);
        LangUtil.rethrowUnchecked(ex);
    }

    return counterId;
}