How to use

longValue

method

in

uk.co.real_logic.sbe.PrimitiveValue

private boolean isRepresentableByInt32(final Encoding encoding)
{
  // These min and max values are the same in .NET
  return encoding.applicableMinValue().longValue() >= Integer.MIN_VALUE &&
    encoding.applicableMaxValue().longValue() <= Integer.MAX_VALUE;
}

private static void validateGroupMaxValue(
  final Node node, final PrimitiveType primitiveType, final PrimitiveValue value)
{
  if (null != value)
  {
    final long longValue = value.longValue();
    final long allowedValue = primitiveType.maxValue().longValue();
    if (longValue > allowedValue)
    {
      XmlSchemaParser.handleError(node, String.format(
        "maxValue greater than allowed for type: maxValue=%d allowed=%d", longValue, allowedValue));
    }
    final long maxInt = INT32.maxValue().longValue();
    if (primitiveType == UINT32 && longValue > maxInt)
    {
      XmlSchemaParser.handleError(node, String.format(
        "maxValue greater than allowed for type: maxValue=%d allowed=%d", longValue, maxInt));
    }
  }
  else if (primitiveType == UINT32)
  {
    final long maxInt = INT32.maxValue().longValue();
    XmlSchemaParser.handleError(node, String.format(
      "maxValue must be set for varData UINT32 type: max value allowed=%d", maxInt));
  }
}

public void onBitSet(
  final Token fieldToken,
  final DirectBuffer buffer,
  final int bufferIndex,
  final List<Token> tokens,
  final int beginIndex,
  final int endIndex,
  final int actingVersion)
{
  final Token typeToken = tokens.get(beginIndex + 1);
  final long encodedValue = readEncodingAsLong(buffer, bufferIndex, typeToken, actingVersion);
  printScope();
  out.append(determineName(0, fieldToken, tokens, beginIndex)).append(':');
  for (int i = beginIndex + 1; i < endIndex; i++)
  {
    out.append(' ').append(tokens.get(i).name()).append('=');
    final long bitPosition = tokens.get(i).encoding().constValue().longValue();
    final boolean flag = (encodedValue & (1L << bitPosition)) != 0;
    out.append(Boolean.toString(flag));
  }
  out.println();
}

/**
 * Construct a Choice given the XML node and the encodingType
 *
 * @param node         that contains the validValue
 * @param encodingType for the enum
 */
public Choice(final Node node, final PrimitiveType encodingType)
{
  name = getAttributeValue(node, "name");
  description = getAttributeValueOrNull(node, "description");
  value = PrimitiveValue.parse(node.getFirstChild().getNodeValue(), encodingType);
  sinceVersion = Integer.parseInt(getAttributeValue(node, "sinceVersion", "0"));
  deprecated = Integer.parseInt(getAttributeValue(node, "deprecated", "0"));
  // choice values are bit positions (0, 1, 2, 3, 4, etc.) from LSB to MSB
  if (value.longValue() >= (encodingType.size() * 8))
  {
    throw new IllegalArgumentException("Choice value out of bounds: " + value.longValue());
  }
  checkForValidName(node, name);
}

private static long readEncodingAsLong(
  final DirectBuffer buffer, final int bufferIndex, final Token typeToken, final int actingVersion)
{
  final PrimitiveValue constOrNotPresentValue = constOrNotPresentValue(typeToken, actingVersion);
  if (null != constOrNotPresentValue)
  {
    return constOrNotPresentValue.longValue();
  }
  return Types.getLong(buffer, bufferIndex, typeToken.encoding());
}

  private static long readEncodingAsLong(
    final DirectBuffer buffer, final int bufferIndex, final Token typeToken, final int actingVersion)
  {
    final PrimitiveValue constOrNotPresentValue = constOrNotPresentValue(typeToken, actingVersion);
    if (null != constOrNotPresentValue)
    {
      return constOrNotPresentValue.longValue();
    }

    return Types.getLong(buffer, bufferIndex, typeToken.encoding());
  }
}

public void onBitSet(
  final Token fieldToken,
  final DirectBuffer buffer,
  final int bufferIndex,
  final List<Token> tokens,
  final int fromIndex,
  final int toIndex,
  final int actingVersion)
{
  final Token typeToken = tokens.get(fromIndex + 1);
  final long encodedValue = readEncodingAsLong(buffer, bufferIndex, typeToken, actingVersion);
  property(determineName(0, fieldToken, tokens, fromIndex));
  output.append("{ ");
  for (int i = fromIndex + 1; i < toIndex; i++)
  {
    output.append('"').append(tokens.get(i).name()).append("\": ");
    final long bitPosition = tokens.get(i).encoding().constValue().longValue();
    final boolean flag = (encodedValue & (1L << bitPosition)) != 0;
    output.append(flag);
    if (i < (toIndex - 1))
    {
      output.append(", ");
    }
  }
  output.append(" }");
  next();
}

  dimensionHeaderLength));
final long minCount = numInGroupToken.encoding().applicableMinValue().longValue();
final String minCheck = minCount > 0 ? "count < " + minCount + " || " : "";
  cppTypeForBlockLength, blockLength, cppTypeForNumInGroup, dimensionHeaderLength,
  minCheck,
  numInGroupToken.encoding().applicableMaxValue().longValue()));

if (encodedValue == tokens.get(i).encoding().constValue().longValue())

    buffer.putByte(0, (byte)value.longValue());
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);
return 8;

final byte[] bytes = { (byte)constOrNotPresentValue.longValue() };
return new String(bytes, constOrNotPresentValue.characterEncoding());

indent + INDENT + "}\n",
parentMessageClassName,
numInGroupToken.encoding().applicableMinValue().longValue(),
numInGroupToken.encoding().applicableMaxValue().longValue(),
typeForBlockLength,
blockLength,

if (encodedValue == tokens.get(i).encoding().constValue().longValue())

parentMessageClassName,
mutableBuffer,
numInGroupToken.encoding().applicableMinValue().longValue(),
numInGroupToken.encoding().applicableMaxValue().longValue(),
blockLengthPut,
numInGroupPut));

final int sizeOfLengthField = lengthToken.encodedLength();
final Encoding lengthEncoding = lengthToken.encoding();
final int maxLengthValue = (int)lengthEncoding.applicableMaxValue().longValue();
final String byteOrderStr = byteOrderString(lengthEncoding);

else if (numInGroupMinValue.longValue() < 0)
    numInGroupMaxValue.longValue() : numInGroupType.primitiveType().maxValue().longValue();
  if (numInGroupMinValue.longValue() > max)

lengthCppType,
lengthByteOrderStr,
lengthToken.encoding().applicableMaxValue().longValue()));

private boolean isRepresentableByInt32(final Encoding encoding)
{
  // These min and max values are the same in .NET
  return encoding.applicableMinValue().longValue() >= Integer.MIN_VALUE &&
    encoding.applicableMaxValue().longValue() <= Integer.MAX_VALUE;
}

  private static long readEncodingAsLong(
    final DirectBuffer buffer, final int bufferIndex, final Token typeToken, final int actingVersion)
  {
    final PrimitiveValue constOrNotPresentValue = constOrNotPresentValue(typeToken, actingVersion);
    if (null != constOrNotPresentValue)
    {
      return constOrNotPresentValue.longValue();
    }

    return Types.getLong(buffer, bufferIndex, typeToken.encoding());
  }
}

  private static long readEncodingAsLong(
    final DirectBuffer buffer, final int bufferIndex, final Token typeToken, final int actingVersion)
  {
    final PrimitiveValue constOrNotPresentValue = constOrNotPresentValue(typeToken, actingVersion);
    if (null != constOrNotPresentValue)
    {
      return constOrNotPresentValue.longValue();
    }

    return Types.getLong(buffer, bufferIndex, typeToken.encoding());
  }
}