/** * set position counter id field * * @param positionCounterId field value * @return flyweight */ public PublicationBuffersReadyFlyweight publicationLimitCounterId(final int positionCounterId) { buffer.putInt(offset + PUBLICATION_LIMIT_COUNTER_ID_OFFSET, positionCounterId); return this; }
/** * Set the correlation id field * * @param registrationId field value * @return flyweight */ public PublicationBuffersReadyFlyweight registrationId(final long registrationId) { buffer.putLong(offset + REGISTRATION_ID_OFFSET, registrationId); return this; }
/** * Write a byte to buffer. * * @param b to be written. */ public void write(final int b) { buffer.putByte(offset + position, (byte)b); ++position; }
/** * Get the channel field as ASCII * * @return channel field */ public String channel() { final int length = buffer.getInt(offset + CHANNEL_OFFSET); lengthOfChannel = SIZE_OF_INT + length; return buffer.getStringAscii(offset + CHANNEL_OFFSET, length); }
public TokenCodecEncoder putNullValue(final byte[] src, final int srcOffset, final int length) { if (length > 65534) { throw new IllegalStateException("length > maxValue for type: " + length); } final int headerLength = 2; final int limit = parentMessage.limit(); parentMessage.limit(limit + headerLength + length); buffer.putShort(limit, (short)length, java.nio.ByteOrder.LITTLE_ENDIAN); buffer.putBytes(limit + headerLength, src, srcOffset, length); return this; }
private void testAlignedWriteMethods(final MutableDirectBuffer buffer, final int offset) { buffer.putLong(offset + SIZE_OF_LONG, Long.MAX_VALUE); buffer.putLong(offset + SIZE_OF_LONG, Long.MAX_VALUE, BIG_ENDIAN); buffer.putDouble(offset + SIZE_OF_DOUBLE, Double.MAX_VALUE); buffer.putDouble(offset + SIZE_OF_DOUBLE, Double.MAX_VALUE, BIG_ENDIAN); buffer.putInt(offset + SIZE_OF_INT, Integer.MAX_VALUE); buffer.putInt(offset + SIZE_OF_INT, Integer.MAX_VALUE, BIG_ENDIAN); buffer.putFloat(offset + SIZE_OF_FLOAT, Float.MAX_VALUE); buffer.putFloat(offset + SIZE_OF_FLOAT, Float.MAX_VALUE, BIG_ENDIAN); buffer.putShort(offset + SIZE_OF_SHORT, Short.MAX_VALUE); buffer.putShort(offset + SIZE_OF_SHORT, Short.MAX_VALUE, BIG_ENDIAN); buffer.putChar(offset + SIZE_OF_CHAR, Character.MAX_VALUE); buffer.putChar(offset + SIZE_OF_CHAR, Character.MAX_VALUE, BIG_ENDIAN); buffer.putByte(offset + SIZE_OF_BYTE, Byte.MAX_VALUE); buffer.putByte(offset + SIZE_OF_BYTE, Byte.MAX_VALUE); buffer.putStringUtf8(offset + SIZE_OF_INT, TEST_STRING); buffer.putStringUtf8(offset + SIZE_OF_INT, TEST_STRING, BIG_ENDIAN); buffer.putStringUtf8(offset + SIZE_OF_INT, TEST_STRING, Integer.MAX_VALUE); buffer.putStringUtf8(offset + SIZE_OF_INT, TEST_STRING, BIG_ENDIAN, Integer.MAX_VALUE); buffer.putStringAscii(offset + SIZE_OF_INT, TEST_STRING); buffer.putStringAscii(offset + SIZE_OF_INT, TEST_STRING, BIG_ENDIAN); // string size is not read for these method => no need for 4-bytes // alignment buffer.putStringWithoutLengthUtf8(offset + SIZE_OF_BYTE, TEST_STRING); buffer.putStringWithoutLengthAscii(offset + SIZE_OF_BYTE, TEST_STRING); }
buffer.putByte(0, (byte)value.longValue()); buffer.putByte(0, value.byteArrayValue()[0]); buffer.putBytes(0, value.byteArrayValue(), 0, value.byteArrayValue().length); return value.byteArrayValue().length; buffer.putByte(0, (byte)value.longValue()); return 1; buffer.putShort(0, (short)value.longValue(), ByteOrder.LITTLE_ENDIAN); return 2; buffer.putInt(0, (int)value.longValue(), ByteOrder.LITTLE_ENDIAN); return 4; buffer.putLong(0, value.longValue(), ByteOrder.LITTLE_ENDIAN); return 8; buffer.putByte(0, (byte)value.longValue()); return 1; buffer.putShort(0, (short)value.longValue(), ByteOrder.LITTLE_ENDIAN); return 2; buffer.putInt(0, (int)value.longValue(), ByteOrder.LITTLE_ENDIAN); return 4; buffer.putLong(0, value.longValue(), ByteOrder.LITTLE_ENDIAN);
final String channel) tempBuffer.putLong(REGISTRATION_ID_OFFSET, registrationId); tempBuffer.putInt(SESSION_ID_OFFSET, sessionId); tempBuffer.putInt(STREAM_ID_OFFSET, streamId); final int channelLength = tempBuffer.putStringWithoutLengthAscii( CHANNEL_OFFSET + SIZE_OF_INT, channel, 0, MAX_CHANNEL_LENGTH); tempBuffer.putInt(CHANNEL_OFFSET, channelLength); final int keyLength = CHANNEL_OFFSET + SIZE_OF_INT + channelLength; labelLength += tempBuffer.putStringWithoutLengthAscii(labelOffset + labelLength, name); labelLength += tempBuffer.putStringWithoutLengthAscii(labelOffset + labelLength, ": "); labelLength += tempBuffer.putLongAscii(labelOffset + labelLength, registrationId); labelLength += tempBuffer.putStringWithoutLengthAscii(labelOffset + labelLength, " "); labelLength += tempBuffer.putIntAscii(labelOffset + labelLength, sessionId); labelLength += tempBuffer.putStringWithoutLengthAscii(labelOffset + labelLength, " "); labelLength += tempBuffer.putIntAscii(labelOffset + labelLength, streamId); labelLength += tempBuffer.putStringWithoutLengthAscii(labelOffset + labelLength, " "); labelLength += tempBuffer.putStringWithoutLengthAscii( labelOffset + labelLength, channel, 0, MAX_LABEL_LENGTH - labelLength);
/** * Fill the key buffer. * * @param keyBuffer containing the optional key for the counter. * @param keyOffset within the keyBuffer at which the key begins. * @param keyLength of the key in the keyBuffer. * @return flyweight */ public CounterMessageFlyweight keyBuffer(final DirectBuffer keyBuffer, final int keyOffset, final int keyLength) { buffer.putInt(KEY_LENGTH_OFFSET, keyLength); if (null != keyBuffer && keyLength > 0) { buffer.putBytes(keyBufferOffset(), keyBuffer, keyOffset, keyLength); } return this; }
@Test public void shouldGenerateCompositeEncoder() throws Exception { final int bufferOffset = 64; final int capacityFieldOffset = bufferOffset; final int numCylindersOffset = bufferOffset + 2; final int expectedEngineCapacity = 2000; final int manufacturerCodeOffset = bufferOffset + 3; final byte[] manufacturerCode = { 'A', 'B', 'C' }; final String className = "EngineEncoder"; final String fqClassName = ir.applicableNamespace() + "." + className; when(mockBuffer.getShort(capacityFieldOffset, BYTE_ORDER)) .thenReturn((short)expectedEngineCapacity); generateTypeStubs(); final Class<?> clazz = compile(fqClassName); assertNotNull(clazz); final Object flyweight = clazz.getConstructor().newInstance(); wrap(bufferOffset, flyweight, mockBuffer, BUFFER_CLASS); final short numCylinders = (short)4; clazz.getDeclaredMethod("numCylinders", short.class).invoke(flyweight, numCylinders); clazz.getDeclaredMethod("putManufacturerCode", byte[].class, int.class) .invoke(flyweight, manufacturerCode, 0); verify(mockBuffer).putByte(numCylindersOffset, (byte)numCylinders); verify(mockBuffer).putBytes(manufacturerCodeOffset, manufacturerCode, 0, manufacturerCode.length); }
final int capacity = scratchBuffer.capacity(); if (length > capacity && !scratchBuffer.isExpandable()) scratchBuffer.putBytes(0, receiver.buffer(), receiver.offset(), length);
public static int encode( final MutableDirectBuffer encodingBuffer, final DirectBuffer buffer, final int offset, final int length) { final int captureLength = determineCaptureLength(length); int relativeOffset = encodeLogHeader(encodingBuffer, captureLength, length); encodingBuffer.putBytes(relativeOffset, buffer, offset, captureLength); relativeOffset += captureLength; return relativeOffset; }
/** * Allocate a counter to represent the heartbeat of a clustered service. * * @param aeron to allocate the counter. * @param tempBuffer to use for building the key and label without allocation. * @param serviceId of the service heartbeat. * @return the {@link Counter} for the commit position. */ public static Counter allocate( final Aeron aeron, final MutableDirectBuffer tempBuffer, final int serviceId) { tempBuffer.putInt(SERVICE_ID_OFFSET, serviceId); final int labelOffset = BitUtil.align(KEY_LENGTH, SIZE_OF_INT); int labelLength = 0; labelLength += tempBuffer.putStringWithoutLengthAscii(labelOffset + labelLength, NAME); labelLength += tempBuffer.putIntAscii(labelOffset + labelLength, serviceId); return aeron.addCounter( SERVICE_HEARTBEAT_TYPE_ID, tempBuffer, 0, KEY_LENGTH, tempBuffer, labelOffset, labelLength); }
public static int allocateCounterId( final MutableDirectBuffer tempBuffer, final String name, final int typeId, final CountersManager countersManager, final long registrationId) { tempBuffer.putLong(REGISTRATION_ID_OFFSET, registrationId); final int keyLength = REGISTRATION_ID_OFFSET + SIZE_OF_LONG; final int labelOffset = BitUtil.align(keyLength, SIZE_OF_INT); int labelLength = 0; labelLength += tempBuffer.putStringWithoutLengthAscii(labelOffset + labelLength, name); labelLength += tempBuffer.putStringWithoutLengthAscii(labelOffset + labelLength, ": "); labelLength += tempBuffer.putLongAscii(labelOffset + labelLength, registrationId); return countersManager.allocate( typeId, tempBuffer, 0, keyLength, tempBuffer, labelOffset, labelLength); } }
public static int writePartition( PartitionInfo partition, RaftState state, MutableDirectBuffer writeBuffer, int offset) { writeBuffer.putInt(offset, partition.getPartitionId(), ByteOrder.LITTLE_ENDIAN); offset += SIZE_OF_INT; writeBuffer.putInt(offset, partition.getReplicationFactor(), ByteOrder.LITTLE_ENDIAN); offset += SIZE_OF_INT; writeBuffer.putByte(offset, (byte) (state == RaftState.LEADER ? 1 : 0)); offset += SIZE_OF_BYTE; return offset; }
/** * Allocate an indicator for tracking the status of a channel endpoint. * * @param tempBuffer to be used for labels and metadata. * @param name of the counter for the label. * @param typeId of the counter for classification. * @param countersManager from which to allocated the underlying storage. * @param channel for the stream of messages. * @return a new {@link AtomicCounter} for tracking the status. */ public static AtomicCounter allocate( final MutableDirectBuffer tempBuffer, final String name, final int typeId, final CountersManager countersManager, final String channel) { final int keyLength = tempBuffer.putStringWithoutLengthAscii( CHANNEL_OFFSET + SIZE_OF_INT, channel, 0, MAX_CHANNEL_LENGTH); tempBuffer.putInt(CHANNEL_OFFSET, keyLength); int labelLength = 0; labelLength += tempBuffer.putStringWithoutLengthAscii(keyLength + labelLength, name); labelLength += tempBuffer.putStringWithoutLengthAscii(keyLength + labelLength, ": "); labelLength += tempBuffer.putStringWithoutLengthAscii( keyLength + labelLength, channel, 0, MAX_LABEL_LENGTH - labelLength); return countersManager.newCounter(typeId, tempBuffer, 0, keyLength, tempBuffer, keyLength, labelLength); } }
@Theory public void shouldAppendAsciiStringInParts(final MutableDirectBuffer buffer) { final String value = "Hello World Test"; int stringIndex = 0; int bufferIndex = INDEX + SIZE_OF_INT; bufferIndex += buffer.putStringWithoutLengthAscii(bufferIndex, value, stringIndex, 5); stringIndex += 5; bufferIndex += buffer.putStringWithoutLengthAscii(bufferIndex, value, stringIndex, 5); stringIndex += 5; bufferIndex += buffer.putStringWithoutLengthAscii( bufferIndex, value, stringIndex, value.length() - stringIndex); assertThat(bufferIndex, is(value.length() + INDEX + SIZE_OF_INT)); buffer.putInt(INDEX, value.length()); assertThat(buffer.getStringWithoutLengthAscii(INDEX + SIZE_OF_INT, value.length()), is(value)); assertThat(buffer.getStringAscii(INDEX), is(value)); }
@Test public void shouldStoreRawData() { final int typeIdOne = 333; final long keyOne = 777L; final MutableDirectBuffer keyOneBuffer = new UnsafeBuffer(ByteBuffer.allocateDirect(8)); keyOneBuffer.putLong(0, keyOne); final DirectBuffer labelOneBuffer = new UnsafeBuffer("Test Label One".getBytes(US_ASCII)); final int typeIdTwo = 222; final long keyTwo = 444; final MutableDirectBuffer keyTwoBuffer = new UnsafeBuffer(ByteBuffer.allocateDirect(8)); keyTwoBuffer.putLong(0, keyTwo); final DirectBuffer labelTwoBuffer = new UnsafeBuffer("Test Label Two".getBytes(US_ASCII)); final int counterIdOne = manager.allocate( typeIdOne, keyOneBuffer, 0, keyOneBuffer.capacity(), labelOneBuffer, 0, labelOneBuffer.capacity()); final int counterIdTwo = manager.allocate( typeIdTwo, keyTwoBuffer, 0, keyTwoBuffer.capacity(), labelTwoBuffer, 0, labelTwoBuffer.capacity()); manager.forEach(metaData); final ArgumentCaptor<DirectBuffer> argCaptorOne = ArgumentCaptor.forClass(DirectBuffer.class); final ArgumentCaptor<DirectBuffer> argCaptorTwo = ArgumentCaptor.forClass(DirectBuffer.class); final InOrder inOrder = Mockito.inOrder(metaData); inOrder.verify(metaData).accept(eq(counterIdOne), eq(typeIdOne), argCaptorOne.capture(), eq("Test Label One")); inOrder.verify(metaData).accept(eq(counterIdTwo), eq(typeIdTwo), argCaptorTwo.capture(), eq("Test Label Two")); inOrder.verifyNoMoreInteractions(); final DirectBuffer keyOneBufferCapture = argCaptorOne.getValue(); assertThat(keyOneBufferCapture.getLong(0), is(keyOne)); final DirectBuffer keyTwoBufferCapture = argCaptorTwo.getValue(); assertThat(keyTwoBufferCapture.getLong(0), is(keyTwo)); }
/** * The channel status counter id. * * @return channel status counter id. */ public int channelStatusCounterId() { return buffer.getInt(offset + CHANNEL_STATUS_INDICATOR_ID_OFFSET); }