b3.entrypoint.fixp.sbe.EstablishEncoder Maven / Gradle / Ivy

Go to download
/* Generated SBE (Simple Binary Encoding) message codec. */
package b3.entrypoint.fixp.sbe;

import org.agrona.MutableDirectBuffer;
import org.agrona.DirectBuffer;
import org.agrona.sbe.*;


/**
 * After negotiation level is complete, the client must send an Establish message to start assigning sequence numbers and also to keep the connection active. Once the connection is established, client can submit orders and quotes.
 */
@SuppressWarnings("all")
public final class EstablishEncoder implements MessageEncoderFlyweight
{
    public static final int BLOCK_LENGTH = 41;
    public static final int TEMPLATE_ID = 4;
    public static final int SCHEMA_ID = 1;
    public static final int SCHEMA_VERSION = 5;
    public static final String SEMANTIC_VERSION = "5.6";
    public static final java.nio.ByteOrder BYTE_ORDER = java.nio.ByteOrder.LITTLE_ENDIAN;

    private final EstablishEncoder parentMessage = this;
    private MutableDirectBuffer buffer;
    private int offset;
    private int limit;

    public int sbeBlockLength()
    {
        return BLOCK_LENGTH;
    }

    public int sbeTemplateId()
    {
        return TEMPLATE_ID;
    }

    public int sbeSchemaId()
    {
        return SCHEMA_ID;
    }

    public int sbeSchemaVersion()
    {
        return SCHEMA_VERSION;
    }

    public String sbeSemanticType()
    {
        return "";
    }

    public MutableDirectBuffer buffer()
    {
        return buffer;
    }

    public int offset()
    {
        return offset;
    }

    public EstablishEncoder wrap(final MutableDirectBuffer buffer, final int offset)
    {
        if (buffer != this.buffer)
        {
            this.buffer = buffer;
        }
        this.offset = offset;
        limit(offset + BLOCK_LENGTH);

        return this;
    }

    public EstablishEncoder wrapAndApplyHeader(
        final MutableDirectBuffer buffer, final int offset, final MessageHeaderEncoder headerEncoder)
    {
        headerEncoder
            .wrap(buffer, offset)
            .blockLength(BLOCK_LENGTH)
            .templateId(TEMPLATE_ID)
            .schemaId(SCHEMA_ID)
            .version(SCHEMA_VERSION);

        return wrap(buffer, offset + MessageHeaderEncoder.ENCODED_LENGTH);
    }

    public int encodedLength()
    {
        return limit - offset;
    }

    public int limit()
    {
        return limit;
    }

    public void limit(final int limit)
    {
        this.limit = limit;
    }

    public static int messageTypeId()
    {
        return 35;
    }

    public static int messageTypeSinceVersion()
    {
        return 0;
    }

    public static int messageTypeEncodingOffset()
    {
        return 0;
    }

    public static int messageTypeEncodingLength()
    {
        return 1;
    }

    public static String messageTypeMetaAttribute(final MetaAttribute metaAttribute)
    {
        if (MetaAttribute.PRESENCE == metaAttribute)
        {
            return "constant";
        }

        return "";
    }

    public static int sessionIDId()
    {
        return 35518;
    }

    public static int sessionIDSinceVersion()
    {
        return 0;
    }

    public static int sessionIDEncodingOffset()
    {
        return 0;
    }

    public static int sessionIDEncodingLength()
    {
        return 4;
    }

    public static String sessionIDMetaAttribute(final MetaAttribute metaAttribute)
    {
        if (MetaAttribute.PRESENCE == metaAttribute)
        {
            return "required";
        }

        return "";
    }

    public static long sessionIDNullValue()
    {
        return 4294967295L;
    }

    public static long sessionIDMinValue()
    {
        return 0L;
    }

    public static long sessionIDMaxValue()
    {
        return 4294967294L;
    }

    public EstablishEncoder sessionID(final long value)
    {
        buffer.putInt(offset + 0, (int)value, BYTE_ORDER);
        return this;
    }


    public static int sessionVerIDId()
    {
        return 35519;
    }

    public static int sessionVerIDSinceVersion()
    {
        return 0;
    }

    public static int sessionVerIDEncodingOffset()
    {
        return 4;
    }

    public static int sessionVerIDEncodingLength()
    {
        return 8;
    }

    public static String sessionVerIDMetaAttribute(final MetaAttribute metaAttribute)
    {
        if (MetaAttribute.PRESENCE == metaAttribute)
        {
            return "required";
        }

        return "";
    }

    public static long sessionVerIDNullValue()
    {
        return 0xffffffffffffffffL;
    }

    public static long sessionVerIDMinValue()
    {
        return 0x0L;
    }

    public static long sessionVerIDMaxValue()
    {
        return 0xfffffffffffffffeL;
    }

    public EstablishEncoder sessionVerID(final long value)
    {
        buffer.putLong(offset + 4, value, BYTE_ORDER);
        return this;
    }


    public static int timestampId()
    {
        return 35520;
    }

    public static int timestampSinceVersion()
    {
        return 0;
    }

    public static int timestampEncodingOffset()
    {
        return 12;
    }

    public static int timestampEncodingLength()
    {
        return 8;
    }

    public static String timestampMetaAttribute(final MetaAttribute metaAttribute)
    {
        if (MetaAttribute.PRESENCE == metaAttribute)
        {
            return "required";
        }

        return "";
    }

    private final UTCTimestampNanosEncoder timestamp = new UTCTimestampNanosEncoder();

    /**
     * Time of request. Sent in number of nanoseconds since Unix epoch.
     *
     * @return UTCTimestampNanosEncoder : Time of request. Sent in number of nanoseconds since Unix epoch.
     */
    public UTCTimestampNanosEncoder timestamp()
    {
        timestamp.wrap(buffer, offset + 12);
        return timestamp;
    }

    public static int keepAliveIntervalId()
    {
        return 35525;
    }

    public static int keepAliveIntervalSinceVersion()
    {
        return 0;
    }

    public static int keepAliveIntervalEncodingOffset()
    {
        return 20;
    }

    public static int keepAliveIntervalEncodingLength()
    {
        return 8;
    }

    public static String keepAliveIntervalMetaAttribute(final MetaAttribute metaAttribute)
    {
        if (MetaAttribute.PRESENCE == metaAttribute)
        {
            return "required";
        }

        return "";
    }

    private final DeltaInMillisEncoder keepAliveInterval = new DeltaInMillisEncoder();

    /**
     * Longest time in milliseconds the initiator should remain silent before sending Sequence message.
     *
     * @return DeltaInMillisEncoder : Longest time in milliseconds the initiator should remain silent before sending Sequence message.
     */
    public DeltaInMillisEncoder keepAliveInterval()
    {
        keepAliveInterval.wrap(buffer, offset + 20);
        return keepAliveInterval;
    }

    public static int nextSeqNoId()
    {
        return 35526;
    }

    public static int nextSeqNoSinceVersion()
    {
        return 0;
    }

    public static int nextSeqNoEncodingOffset()
    {
        return 28;
    }

    public static int nextSeqNoEncodingLength()
    {
        return 4;
    }

    public static String nextSeqNoMetaAttribute(final MetaAttribute metaAttribute)
    {
        if (MetaAttribute.PRESENCE == metaAttribute)
        {
            return "required";
        }

        return "";
    }

    public static long nextSeqNoNullValue()
    {
        return 4294967295L;
    }

    public static long nextSeqNoMinValue()
    {
        return 0L;
    }

    public static long nextSeqNoMaxValue()
    {
        return 4294967294L;
    }

    public EstablishEncoder nextSeqNo(final long value)
    {
        buffer.putInt(offset + 28, (int)value, BYTE_ORDER);
        return this;
    }


    public static int cancelOnDisconnectTypeId()
    {
        return 35002;
    }

    public static int cancelOnDisconnectTypeSinceVersion()
    {
        return 0;
    }

    public static int cancelOnDisconnectTypeEncodingOffset()
    {
        return 32;
    }

    public static int cancelOnDisconnectTypeEncodingLength()
    {
        return 1;
    }

    public static String cancelOnDisconnectTypeMetaAttribute(final MetaAttribute metaAttribute)
    {
        if (MetaAttribute.PRESENCE == metaAttribute)
        {
            return "required";
        }

        return "";
    }

    public EstablishEncoder cancelOnDisconnectType(final CancelOnDisconnectType value)
    {
        buffer.putByte(offset + 32, (byte)value.value());
        return this;
    }

    public static int codTimeoutWindowId()
    {
        return 35003;
    }

    public static int codTimeoutWindowSinceVersion()
    {
        return 0;
    }

    public static int codTimeoutWindowEncodingOffset()
    {
        return 33;
    }

    public static int codTimeoutWindowEncodingLength()
    {
        return 8;
    }

    public static String codTimeoutWindowMetaAttribute(final MetaAttribute metaAttribute)
    {
        if (MetaAttribute.PRESENCE == metaAttribute)
        {
            return "required";
        }

        return "";
    }

    private final DeltaInMillisEncoder codTimeoutWindow = new DeltaInMillisEncoder();

    /**
     * Gateway will not trigger CoD if the customer reconnects within the timeout window (milliseconds) which starts when the triggering event is detected. Value = 0 then CoD will not be enabled.
     *
     * @return DeltaInMillisEncoder : Gateway will not trigger CoD if the customer reconnects within the timeout window (milliseconds) which starts when the triggering event is detected. Value = 0 then CoD will not be enabled.
     */
    public DeltaInMillisEncoder codTimeoutWindow()
    {
        codTimeoutWindow.wrap(buffer, offset + 33);
        return codTimeoutWindow;
    }

    public static int credentialsId()
    {
        return 35512;
    }

    public static String credentialsCharacterEncoding()
    {
        return java.nio.charset.StandardCharsets.UTF_8.name();
    }

    public static String credentialsMetaAttribute(final MetaAttribute metaAttribute)
    {
        if (MetaAttribute.PRESENCE == metaAttribute)
        {
            return "required";
        }
        if (MetaAttribute.SEMANTIC_TYPE == metaAttribute)
        {
            return "String";
        }

        return "";
    }

    public static int credentialsHeaderLength()
    {
        return 1;
    }

    public EstablishEncoder putCredentials(final DirectBuffer src, final int srcOffset, final int length)
    {
        if (length > 128)
        {
            throw new IllegalStateException("length > maxValue for type: " + length);
        }

        final int headerLength = 1;
        final int limit = parentMessage.limit();
        parentMessage.limit(limit + headerLength + length);
        buffer.putByte(limit, (byte)length);
        buffer.putBytes(limit + headerLength, src, srcOffset, length);

        return this;
    }

    public EstablishEncoder putCredentials(final byte[] src, final int srcOffset, final int length)
    {
        if (length > 128)
        {
            throw new IllegalStateException("length > maxValue for type: " + length);
        }

        final int headerLength = 1;
        final int limit = parentMessage.limit();
        parentMessage.limit(limit + headerLength + length);
        buffer.putByte(limit, (byte)length);
        buffer.putBytes(limit + headerLength, src, srcOffset, length);

        return this;
    }

    public EstablishEncoder credentials(final String value)
    {
        final byte[] bytes = (null == value || value.isEmpty()) ? org.agrona.collections.ArrayUtil.EMPTY_BYTE_ARRAY : value.getBytes(java.nio.charset.StandardCharsets.UTF_8);

        final int length = bytes.length;
        if (length > 128)
        {
            throw new IllegalStateException("length > maxValue for type: " + length);
        }

        final int headerLength = 1;
        final int limit = parentMessage.limit();
        parentMessage.limit(limit + headerLength + length);
        buffer.putByte(limit, (byte)length);
        buffer.putBytes(limit + headerLength, bytes, 0, length);

        return this;
    }

    public String toString()
    {
        if (null == buffer)
        {
            return "";
        }

        return appendTo(new StringBuilder()).toString();
    }

    public StringBuilder appendTo(final StringBuilder builder)
    {
        if (null == buffer)
        {
            return builder;
        }

        final EstablishDecoder decoder = new EstablishDecoder();
        decoder.wrap(buffer, offset, BLOCK_LENGTH, SCHEMA_VERSION);

        return decoder.appendTo(builder);
    }
}