How to use

typeOffset

method

in

io.zeebe.dispatcher.impl.log.DataFrameDescriptor

@Override
public int getType() {
 return buffer.getShort(typeOffset(fragmentOffset), Protocol.ENDIANNESS);
}

@Override
public int getType() {
 return buffer.getShort(typeOffset(fragmentOffset), Protocol.ENDIANNESS);
}

/** Commit the fragment and mark it as failed. It will be ignored by subscriptions. */
public void abort() {
 // abort the message by setting type to padding and writing the positive framed length
 buffer.putInt(typeOffset(0), TYPE_PADDING);
 buffer.putIntOrdered(lengthOffset(0), buffer.capacity());
 onCompleteHandler.run();
 reset();
}

/** Commit the fragment and mark it as failed. It will be ignored by subscriptions. */
public void abort() {
 // abort the message by setting type to padding and writing the positive framed length
 buffer.putInt(typeOffset(0), TYPE_PADDING);
 buffer.putIntOrdered(lengthOffset(0), buffer.capacity());
 onCompleteHandler.run();
 reset();
}

private void fillRemainingBatchSize() {
 // since the claimed batch size can be longer than the written fragment
 // size, we need to fill the rest with a padding fragment
 final int remainingLength = buffer.capacity() - nextOffset;
 if (remainingLength >= HEADER_LENGTH) {
  buffer.putInt(lengthOffset(nextOffset), remainingLength);
  buffer.putShort(typeOffset(nextOffset), TYPE_PADDING);
 }
}

private void fillRemainingBatchSize() {
 // since the claimed batch size can be longer than the written fragment
 // size, we need to fill the rest with a padding fragment
 final int remainingLength = buffer.capacity() - nextOffset;
 if (remainingLength >= HEADER_LENGTH) {
  buffer.putInt(lengthOffset(nextOffset), remainingLength);
  buffer.putShort(typeOffset(nextOffset), TYPE_PADDING);
 }
}

/**
 * Commit all fragments of the batch and mark them as failed. They will be ignored by
 * subscriptions.
 */
public void abort() {
 // discard all fragments by set the type to padding
 int fragmentOffset = 0;
 while (fragmentOffset < nextOffset) {
  final int fragmentLength = -buffer.getInt(lengthOffset(fragmentOffset));
  buffer.putInt(typeOffset(fragmentOffset), TYPE_PADDING);
  buffer.putIntOrdered(lengthOffset(fragmentOffset), fragmentLength);
  fragmentOffset += DataFrameDescriptor.alignedLength(fragmentLength);
 }
 fillRemainingBatchSize();
 onCompleteHandler.run();
 reset();
}

/**
 * Commit all fragments of the batch and mark them as failed. They will be ignored by
 * subscriptions.
 */
public void abort() {
 // discard all fragments by set the type to padding
 int fragmentOffset = 0;
 while (fragmentOffset < nextOffset) {
  final int fragmentLength = -buffer.getInt(lengthOffset(fragmentOffset));
  buffer.putInt(typeOffset(fragmentOffset), TYPE_PADDING);
  buffer.putIntOrdered(lengthOffset(fragmentOffset), fragmentLength);
  fragmentOffset += DataFrameDescriptor.alignedLength(fragmentLength);
 }
 fillRemainingBatchSize();
 onCompleteHandler.run();
 reset();
}

/**
 * Add a new fragment to the batch.
 *
 * @param length the length of the fragment
 * @param streamId the stream id of the fragment
 * @return the position of the fragment
 * @throws IllegalArgumentException if the given length is greater than the remaining capacity. In
 *     this case, you should try with smaller length, or abort the whole batch.
 */
@SuppressWarnings("restriction")
public long nextFragment(int length, int streamId) {
 currentOffset = nextOffset;
 final int framedLength = framedLength(length);
 nextOffset += alignedLength(framedLength);
 // ensure that there is enough capacity for padding message, or less than frame alignment which
 // omits the padding message
 final int remainingCapacity = buffer.capacity() - nextOffset;
 if (remainingCapacity < 0
   || (FRAME_ALIGNMENT <= remainingCapacity && remainingCapacity < HEADER_LENGTH)) {
  throw new IllegalArgumentException(
    String.format(ERROR_MESSAGE, currentOffset, length, buffer.capacity()));
 }
 // set negative length => uncommitted fragment
 buffer.putIntOrdered(lengthOffset(currentOffset), -framedLength);
 UNSAFE.storeFence();
 buffer.putShort(typeOffset(currentOffset), TYPE_MESSAGE);
 buffer.putInt(streamIdOffset(currentOffset), streamId);
 return position(partitionId, partitionOffset + nextOffset);
}

/**
 * Add a new fragment to the batch.
 *
 * @param length the length of the fragment
 * @param streamId the stream id of the fragment
 * @return the position of the fragment
 * @throws IllegalArgumentException if the given length is greater than the remaining capacity. In
 *     this case, you should try with smaller length, or abort the whole batch.
 */
@SuppressWarnings("restriction")
public long nextFragment(int length, int streamId) {
 currentOffset = nextOffset;
 final int framedLength = framedLength(length);
 nextOffset += alignedLength(framedLength);
 // ensure that there is enough capacity for padding message, or less than frame alignment which
 // omits the padding message
 final int remainingCapacity = buffer.capacity() - nextOffset;
 if (remainingCapacity < 0
   || (FRAME_ALIGNMENT <= remainingCapacity && remainingCapacity < HEADER_LENGTH)) {
  throw new IllegalArgumentException(
    String.format(ERROR_MESSAGE, currentOffset, length, buffer.capacity()));
 }
 // set negative length => uncommitted fragment
 buffer.putIntOrdered(lengthOffset(currentOffset), -framedLength);
 UNSAFE.storeFence();
 buffer.putShort(typeOffset(currentOffset), TYPE_MESSAGE);
 buffer.putInt(streamIdOffset(currentOffset), streamId);
 return position(partitionId, partitionOffset + nextOffset);
}

 @SuppressWarnings("restriction")
 protected int onEndOfPartition(final LogBufferPartition partition, final int partitionOffset) {
  int newTail = RESULT_END_OF_PARTITION;

  final int padLength = partition.getPartitionSize() - partitionOffset;

  if (padLength >= HEADER_LENGTH) {
   // this message tripped the end of the partition, fill buffer with padding
   final UnsafeBuffer buffer = partition.getDataBuffer();
   buffer.putIntOrdered(lengthOffset(partitionOffset), -padLength);
   UNSAFE.storeFence();
   buffer.putShort(typeOffset(partitionOffset), TYPE_PADDING);
   buffer.putIntOrdered(lengthOffset(partitionOffset), padLength);

   newTail = RESULT_PADDING_AT_END_OF_PARTITION;
  }

  return newTail;
 }
}

 @SuppressWarnings("restriction")
 protected int onEndOfPartition(final LogBufferPartition partition, final int partitionOffset) {
  int newTail = RESULT_END_OF_PARTITION;

  final int padLength = partition.getPartitionSize() - partitionOffset;

  if (padLength >= HEADER_LENGTH) {
   // this message tripped the end of the partition, fill buffer with padding
   final UnsafeBuffer buffer = partition.getDataBuffer();
   buffer.putIntOrdered(lengthOffset(partitionOffset), -padLength);
   UNSAFE.storeFence();
   buffer.putShort(typeOffset(partitionOffset), TYPE_PADDING);
   buffer.putIntOrdered(lengthOffset(partitionOffset), padLength);

   newTail = RESULT_PADDING_AT_END_OF_PARTITION;
  }

  return newTail;
 }
}

@SuppressWarnings("restriction")
public int claim(
  final LogBufferPartition partition,
  final int activePartitionId,
  final ClaimedFragment claim,
  final int length,
  final int streamId,
  Runnable onComplete) {
 final int partitionSize = partition.getPartitionSize();
 final int framedMessageLength = framedLength(length);
 final int alignedFrameLength = alignedLength(framedMessageLength);
 // move the tail of the partition
 final int frameOffset = partition.getAndAddTail(alignedFrameLength);
 int newTail = frameOffset + alignedFrameLength;
 if (newTail <= (partitionSize - HEADER_LENGTH)) {
  final UnsafeBuffer buffer = partition.getDataBuffer();
  // write negative length field
  buffer.putIntOrdered(lengthOffset(frameOffset), -framedMessageLength);
  UNSAFE.storeFence();
  buffer.putShort(typeOffset(frameOffset), TYPE_MESSAGE);
  buffer.putInt(streamIdOffset(frameOffset), streamId);
  claim.wrap(buffer, frameOffset, framedMessageLength, onComplete);
  // Do not commit the message
 } else {
  newTail = onEndOfPartition(partition, frameOffset);
 }
 return newTail;
}

@SuppressWarnings("restriction")
public int claim(
  final LogBufferPartition partition,
  final int activePartitionId,
  final ClaimedFragment claim,
  final int length,
  final int streamId,
  Runnable onComplete) {
 final int partitionSize = partition.getPartitionSize();
 final int framedMessageLength = framedLength(length);
 final int alignedFrameLength = alignedLength(framedMessageLength);
 // move the tail of the partition
 final int frameOffset = partition.getAndAddTail(alignedFrameLength);
 int newTail = frameOffset + alignedFrameLength;
 if (newTail <= (partitionSize - HEADER_LENGTH)) {
  final UnsafeBuffer buffer = partition.getDataBuffer();
  // write negative length field
  buffer.putIntOrdered(lengthOffset(frameOffset), -framedMessageLength);
  UNSAFE.storeFence();
  buffer.putShort(typeOffset(frameOffset), TYPE_MESSAGE);
  buffer.putInt(streamIdOffset(frameOffset), streamId);
  claim.wrap(buffer, frameOffset, framedMessageLength, onComplete);
  // Do not commit the message
 } else {
  newTail = onEndOfPartition(partition, frameOffset);
 }
 return newTail;
}

@SuppressWarnings("restriction")
public int appendFrame(
  final LogBufferPartition partition,
  final int activePartitionId,
  final DirectBuffer msg,
  final int start,
  final int length,
  final int streamId) {
 final int partitionSize = partition.getPartitionSize();
 final int framedLength = framedLength(length);
 final int alignedFrameLength = alignedLength(framedLength);
 // move the tail of the partition
 final int frameOffset = partition.getAndAddTail(alignedFrameLength);
 int newTail = frameOffset + alignedFrameLength;
 if (newTail <= (partitionSize - HEADER_LENGTH)) {
  final UnsafeBuffer buffer = partition.getDataBuffer();
  // write negative length field
  buffer.putIntOrdered(lengthOffset(frameOffset), -framedLength);
  UNSAFE.storeFence();
  buffer.putShort(typeOffset(frameOffset), TYPE_MESSAGE);
  buffer.putInt(streamIdOffset(frameOffset), streamId);
  buffer.putBytes(messageOffset(frameOffset), msg, start, length);
  // commit the message
  buffer.putIntOrdered(lengthOffset(frameOffset), framedLength);
 } else {
  newTail = onEndOfPartition(partition, frameOffset);
 }
 return newTail;
}

@SuppressWarnings("restriction")
public int appendFrame(
  final LogBufferPartition partition,
  final int activePartitionId,
  final DirectBuffer msg,
  final int start,
  final int length,
  final int streamId) {
 final int partitionSize = partition.getPartitionSize();
 final int framedLength = framedLength(length);
 final int alignedFrameLength = alignedLength(framedLength);
 // move the tail of the partition
 final int frameOffset = partition.getAndAddTail(alignedFrameLength);
 int newTail = frameOffset + alignedFrameLength;
 if (newTail <= (partitionSize - HEADER_LENGTH)) {
  final UnsafeBuffer buffer = partition.getDataBuffer();
  // write negative length field
  buffer.putIntOrdered(lengthOffset(frameOffset), -framedLength);
  UNSAFE.storeFence();
  buffer.putShort(typeOffset(frameOffset), TYPE_MESSAGE);
  buffer.putInt(streamIdOffset(frameOffset), streamId);
  buffer.putBytes(messageOffset(frameOffset), msg, start, length);
  // commit the message
  buffer.putIntOrdered(lengthOffset(frameOffset), framedLength);
 } else {
  newTail = onEndOfPartition(partition, frameOffset);
 }
 return newTail;
}

final short type = buffer.getShort(typeOffset(fragmentOffset));
if (type == TYPE_PADDING) {
 fragmentOffset += alignedLength(framedLength);

final short type = buffer.getShort(typeOffset(fragmentOffset));
if (type == TYPE_PADDING) {
 fragmentOffset += alignedLength(framedLength);

final short type = buffer.getShort(typeOffset(partitionOffset));
if (type == TYPE_PADDING) {
 partitionOffset += alignedLength(framedLength);

final short type = buffer.getShort(typeOffset(partitionOffset));
if (type == TYPE_PADDING) {
 partitionOffset += alignedLength(framedLength);