How to use

encode

method

in

uk.co.real_logic.artio.builder.Encoder

@Test
public void canDisableRequiredFloatFieldValidation() throws Exception
{
  final Encoder encoder = (Encoder)heartbeatWithoutValidation.getConstructor().newInstance();
  setOnBehalfOfCompID(encoder);
  setSomeTimeField(encoder, 0);
  encoder.encode(buffer, 1);
}

@Test
public void canDisableRequiredStringFieldValidation() throws Exception
{
  final Encoder encoder = (Encoder)heartbeatWithoutValidation.getConstructor().newInstance();
  setFloatField(encoder);
  setSomeTimeField(encoder, 0);
  encoder.encode(buffer, 1);
}

@Test
public void canDisableRequiredTemporalFieldValidation() throws Exception
{
  final Encoder encoder = (Encoder)heartbeatWithoutValidation.getConstructor().newInstance();
  setOnBehalfOfCompID(encoder);
  setFloatField(encoder);
  encoder.encode(buffer, 1);
}

private void assertEncodesTo(final Encoder encoder, final String expectedValue)
{
  final long result = encoder.encode(buffer, 1);
  final int length = Encoder.length(result);
  final int offset = Encoder.offset(result);
  assertEquals(expectedValue, buffer.getAscii(offset, expectedValue.length()));
  assertEquals(expectedValue.length(), length);
}

@Test(expected = EncodingException.class)
public void shouldValidateMissingRequiredStringFields() throws Exception
{
  final Encoder encoder = newHeartbeat();
  setFloatField(encoder);
  setSomeTimeField(encoder, 0);
  encoder.encode(buffer, 1);
}

@Test(expected = EncodingException.class)
public void shouldValidateMissingRequiredFloatFields() throws Exception
{
  final Encoder encoder = newHeartbeat();
  setOnBehalfOfCompID(encoder);
  setSomeTimeField(encoder, 0);
  encoder.encode(buffer, 1);
}

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);
  }
}

@Test(expected = EncodingException.class)
public void shouldValidateMissingRequiredTemporalFields() throws Exception
{
  final Encoder encoder = newHeartbeat();
  setOnBehalfOfCompID(encoder);
  setFloatField(encoder);
  encoder.encode(buffer, 1);
}

@Test
public void shouldEncodeShorterStringsAfterLongerStrings() throws Exception
{
  final Encoder encoder = newHeartbeat();
  setRequiredFields(encoder);
  encoder.encode(buffer, 1);
  setCharSequence(encoder, ON_BEHALF_OF_COMP_ID, "ab");
  assertEncodesTo(encoder, SHORTER_STRING_MESSAGE);
}

@Test(expected = EncodingException.class)
public void shouldValidateMissingRequiredIntFields() throws Exception
{
  final Encoder encoder = newHeartbeat();
  setOnBehalfOfCompID(encoder);
  setFloatField(encoder);
  setSomeTimeField(encoder, 1);
  encoder.encode(buffer, 1);
}

@Test(expected = EncodingException.class)
public void shouldResetFlagForMissingRequiredIntFields() throws Exception
{
  final Encoder encoder = newHeartbeat();
  setRequiredFields(encoder);
  encoder.reset();
  setOnBehalfOfCompID(encoder);
  setFloatField(encoder);
  setSomeTimeField(encoder, 1);
  encoder.encode(buffer, 1);
}

/**
 * Send a message on this session.
 *
 * @param encoder the encoder of the message to be sent
 * @return the position in the stream that corresponds to the end of this message or a negative
 * number indicating an error status.
 * @throws IndexOutOfBoundsException if the encoded message is too large, if this happens consider
 *                                   increasing {@link CommonConfiguration#sessionBufferSize(int)}
 */
public long send(final Encoder encoder)
{
  validateCanSendMessage();
  final int sentSeqNum = newSentSeqNum();
  final HeaderEncoder header = (HeaderEncoder)encoder.header();
  header
    .msgSeqNum(sentSeqNum)
    .sendingTime(timestampEncoder.buffer(), timestampEncoder.encode(time()));
  if (enableLastMsgSeqNumProcessed)
  {
    header.lastMsgSeqNumProcessed(lastMsgSeqNumProcessed);
  }
  if (!header.hasSenderCompID())
  {
    sessionIdStrategy.setupSession(sessionKey, header);
  }
  final long result = encoder.encode(asciiBuffer, 0);
  final int length = Encoder.length(result);
  final int offset = Encoder.offset(result);
  return send(asciiBuffer, offset, length, sentSeqNum, encoder.messageType());
}

private void bufferContainsMessage(
  final long sessionId,
  final int sequenceNumber,
  final int sequenceIndex,
  final Encoder exampleMessage,
  final HeaderEncoder header,
  final int messageType)
{
  final UtcTimestampEncoder timestampEncoder = new UtcTimestampEncoder();
  final int timestampLength = timestampEncoder.encode(ORIGINAL_SENDING_EPOCH_MS);
  MutableAsciiBuffer asciiBuffer = new MutableAsciiBuffer(new byte[BIG_BUFFER_LENGTH]);
  header
    .sendingTime(timestampEncoder.buffer(), timestampLength)
    .senderCompID(BUFFER_SENDER)
    .targetCompID(BUFFER_TARGET)
    .msgSeqNum(sequenceNumber);
  final long result = exampleMessage.encode(asciiBuffer, 0);
  logEntryLength = Encoder.length(result);
  final int encodedOffset = Encoder.offset(result);
  asciiBuffer = new MutableAsciiBuffer(asciiBuffer, encodedOffset, logEntryLength);
  bufferContainsMessage(sessionId, sequenceIndex, asciiBuffer, messageType);
}