::max)()
typedef union sbe_float_as_uint_u
{
float fp_value;
std::uint32_t uint_value;
}
sbe_float_as_uint_t;
typedef union sbe_double_as_uint_u
{
double fp_value;
std::uint64_t uint_value;
}
sbe_double_as_uint_t;
namespace MetaAttribute
{
enum Attribute
{
EPOCH,
TIME_UNIT,
SEMANTIC_TYPE,
PRESENCE
};
}
}
#endif
simple-binary-encoding-1.8.9/sbe-tool/src/main/java/ 0000775 0000000 0000000 00000000000 13355512467 0022263 5 ustar 00root root 0000000 0000000 simple-binary-encoding-1.8.9/sbe-tool/src/main/java/overview.html 0000664 0000000 0000000 00000000403 13355512467 0025014 0 ustar 00root root 0000000 0000000
Simple Binary Encoding
Documentation about how the encoders and decoders should be used.
simple-binary-encoding-1.8.9/sbe-tool/src/main/java/uk/ 0000775 0000000 0000000 00000000000 13355512467 0022702 5 ustar 00root root 0000000 0000000 simple-binary-encoding-1.8.9/sbe-tool/src/main/java/uk/co/ 0000775 0000000 0000000 00000000000 13355512467 0023303 5 ustar 00root root 0000000 0000000 simple-binary-encoding-1.8.9/sbe-tool/src/main/java/uk/co/real_logic/ 0000775 0000000 0000000 00000000000 13355512467 0025403 5 ustar 00root root 0000000 0000000 simple-binary-encoding-1.8.9/sbe-tool/src/main/java/uk/co/real_logic/sbe/ 0000775 0000000 0000000 00000000000 13355512467 0026154 5 ustar 00root root 0000000 0000000 simple-binary-encoding-1.8.9/sbe-tool/src/main/java/uk/co/real_logic/sbe/PrimitiveType.java 0000664 0000000 0000000 00000011275 13355512467 0031637 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013-2018 Real Logic Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package uk.co.real_logic.sbe;
import static uk.co.real_logic.sbe.PrimitiveValue.*;
/**
* Primitive types from which all other types are composed.
*/
public enum PrimitiveType
{
CHAR("char", 1, MIN_VALUE_CHAR, MAX_VALUE_CHAR, NULL_VALUE_CHAR),
INT8("int8", 1, MIN_VALUE_INT8, MAX_VALUE_INT8, NULL_VALUE_INT8),
INT16("int16", 2, MIN_VALUE_INT16, MAX_VALUE_INT16, NULL_VALUE_INT16),
INT32("int32", 4, MIN_VALUE_INT32, MAX_VALUE_INT32, NULL_VALUE_INT32),
INT64("int64", 8, MIN_VALUE_INT64, MAX_VALUE_INT64, NULL_VALUE_INT64),
UINT8("uint8", 1, MIN_VALUE_UINT8, MAX_VALUE_UINT8, NULL_VALUE_UINT8),
UINT16("uint16", 2, MIN_VALUE_UINT16, MAX_VALUE_UINT16, NULL_VALUE_UINT16),
UINT32("uint32", 4, MIN_VALUE_UINT32, MAX_VALUE_UINT32, NULL_VALUE_UINT32),
UINT64("uint64", 8, MIN_VALUE_UINT64, MAX_VALUE_UINT64, NULL_VALUE_UINT64),
FLOAT("float", 4, MIN_VALUE_FLOAT, MAX_VALUE_FLOAT, NULL_VALUE_FLOAT),
DOUBLE("double", 8, MIN_VALUE_DOUBLE, MAX_VALUE_DOUBLE, NULL_VALUE_DOUBLE);
private final String name;
private final int size;
private final PrimitiveValue minValue;
private final PrimitiveValue maxValue;
private final PrimitiveValue nullValue;
PrimitiveType(final String name, final int size, final long minValue, final long maxValue, final long nullValue)
{
this.name = name;
this.size = size;
this.minValue = new PrimitiveValue(minValue, size);
this.maxValue = new PrimitiveValue(maxValue, size);
this.nullValue = new PrimitiveValue(nullValue, size);
}
PrimitiveType(
final String name, final int size, final double minValue, final double maxValue, final double nullValue)
{
this.name = name;
this.size = size;
this.minValue = new PrimitiveValue(minValue, size);
this.maxValue = new PrimitiveValue(maxValue, size);
this.nullValue = new PrimitiveValue(nullValue, size);
}
/**
* The name of the primitive type as a String.
*
* @return the name as a String
*/
public String primitiveName()
{
return name;
}
/**
* The encodedLength of the primitive type in octets.
*
* @return encodedLength (in octets) of the primitive type
*/
public int size()
{
return size;
}
/**
* The minValue of the primitive type.
*
* @return default minValue of the primitive type
*/
public PrimitiveValue minValue()
{
return minValue;
}
/**
* The maxValue of the primitive type.
*
* @return default maxValue of the primitive type
*/
public PrimitiveValue maxValue()
{
return maxValue;
}
/**
* The nullValue of the primitive type.
*
* @return default nullValue of the primitive type
*/
public PrimitiveValue nullValue()
{
return nullValue;
}
/**
* Is the type an unsigned type like in C.
*
* @param type to be tested.
* @return true if unsigned otherwise false.
*/
public static boolean isUnsigned(final PrimitiveType type)
{
switch (type)
{
case UINT8:
case UINT16:
case UINT32:
case UINT64:
return true;
default:
return false;
}
}
/**
* Lookup PrimitiveType by String name and return Enum.
*
* @param name of primitiveType to get
* @return the {@link PrimitiveType} matching the name
* @throws IllegalArgumentException if name not found
*/
public static PrimitiveType get(final String name)
{
for (final PrimitiveType p : Singleton.VALUES)
{
if (p.name.equals(name))
{
return p;
}
}
throw new IllegalArgumentException("No PrimitiveType for name: " + name);
}
/**
* Used to hold a reference to the values array without having it defensively copied
* on every call to {@link Enum} values().
*/
static class Singleton
{
public static final PrimitiveType[] VALUES = PrimitiveType.values();
}
}
simple-binary-encoding-1.8.9/sbe-tool/src/main/java/uk/co/real_logic/sbe/PrimitiveValue.java 0000664 0000000 0000000 00000035340 13355512467 0031771 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013-2018 Real Logic Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package uk.co.real_logic.sbe;
import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.util.Arrays;
import static java.lang.Double.doubleToLongBits;
import static java.nio.charset.Charset.forName;
import static java.nio.charset.StandardCharsets.US_ASCII;
/**
* Class used to encapsulate values for primitives. Used for nullValue, minValue, maxValue, and constants
*/
public class PrimitiveValue
{
public enum Representation
{
/**
* Value is stored in a long value.
*/
LONG,
/**
* Value is stored in a double value.
*/
DOUBLE,
/**
* Value is stored in a byte[].
*/
BYTE_ARRAY
}
public static final long MIN_VALUE_CHAR = 0x20;
public static final long MAX_VALUE_CHAR = 0x7E;
public static final long NULL_VALUE_CHAR = 0;
public static final long MIN_VALUE_INT8 = -127;
public static final long MAX_VALUE_INT8 = 127;
public static final long NULL_VALUE_INT8 = -128;
public static final long MIN_VALUE_UINT8 = 0;
public static final long MAX_VALUE_UINT8 = 254;
public static final long NULL_VALUE_UINT8 = 255;
public static final long MIN_VALUE_INT16 = -32767;
public static final long MAX_VALUE_INT16 = 32767;
public static final long NULL_VALUE_INT16 = -32768;
public static final long MIN_VALUE_UINT16 = 0;
public static final long MAX_VALUE_UINT16 = 65534;
public static final long NULL_VALUE_UINT16 = 65535;
public static final long MIN_VALUE_INT32 = -2147483647;
public static final long MAX_VALUE_INT32 = 2147483647;
public static final long NULL_VALUE_INT32 = -2147483648;
public static final long MIN_VALUE_UINT32 = 0;
public static final long MAX_VALUE_UINT32 = 0xFFFF_FFFFL - 1;
public static final long NULL_VALUE_UINT32 = 0xFFFF_FFFFL;
public static final long MIN_VALUE_INT64 = Long.MIN_VALUE + 1; // (-2 ^ 63) + 1
public static final long MAX_VALUE_INT64 = Long.MAX_VALUE; // ( 2 ^ 63) - 1
public static final long NULL_VALUE_INT64 = Long.MIN_VALUE; // (-2 ^ 63)
public static final long MIN_VALUE_UINT64 = 0;
public static final BigInteger BI_MAX_VALUE_UINT64 = new BigInteger("18446744073709551614");
public static final long MAX_VALUE_UINT64 = BI_MAX_VALUE_UINT64.longValue(); // (2 ^ 64) - 2
public static final BigInteger BI_NULL_VALUE_UINT64 = new BigInteger("18446744073709551615");
public static final long NULL_VALUE_UINT64 = BI_NULL_VALUE_UINT64.longValue(); // (2 ^ 64) - 1
public static final float MIN_VALUE_FLOAT = Float.MIN_VALUE;
public static final float MAX_VALUE_FLOAT = Float.MAX_VALUE;
public static final float NULL_VALUE_FLOAT = Float.NaN;
public static final double MIN_VALUE_DOUBLE = Double.MIN_VALUE;
public static final double MAX_VALUE_DOUBLE = Double.MAX_VALUE;
public static final double NULL_VALUE_DOUBLE = Double.NaN;
private final Representation representation;
private final long longValue;
private final double doubleValue;
private final byte[] byteArrayValue;
private final String characterEncoding;
private final int size;
private final byte[] byteArrayValueForLong = new byte[1];
/**
* Construct and fill in value as a long.
*
* @param value in long format
* @param size of the type in bytes
*/
public PrimitiveValue(final long value, final int size)
{
representation = Representation.LONG;
longValue = value;
doubleValue = 0.0;
byteArrayValue = null;
characterEncoding = null;
this.size = size;
}
/**
* Construct and fill in value as a long.
*
* @param value in long format
* @param characterEncoding of the char type.
*/
public PrimitiveValue(final byte value, final String characterEncoding)
{
representation = Representation.LONG;
longValue = value;
doubleValue = 0.0;
byteArrayValue = null;
this.characterEncoding = characterEncoding;
this.size = 1;
}
/**
* Construct and fill in value as a double.
*
* @param value in double format
* @param size of the type in bytes
*/
public PrimitiveValue(final double value, final int size)
{
representation = Representation.DOUBLE;
longValue = 0;
doubleValue = value;
byteArrayValue = null;
characterEncoding = null;
this.size = size;
}
/**
* Construct and fill in value as a byte array.
*
* @param value as a byte array
* @param characterEncoding of the characters
* @param size of string in characters
*/
public PrimitiveValue(final byte[] value, final String characterEncoding, final int size)
{
representation = Representation.BYTE_ARRAY;
longValue = 0;
doubleValue = 0.0;
byteArrayValue = value;
this.characterEncoding = characterEncoding;
this.size = size;
}
/**
* Get the {@link Representation} of the value.
*
* @return the {@link Representation} of the value.
*/
public Representation representation()
{
return representation;
}
/**
* Parse constant value string and set representation based on type
*
* @param value expressed as a String
* @param primitiveType that this is supposed to be
* @return a new {@link PrimitiveValue} for the value.
* @throws IllegalArgumentException if parsing malformed type
*/
public static PrimitiveValue parse(final String value, final PrimitiveType primitiveType)
{
switch (primitiveType)
{
case CHAR:
if (value.length() > 1)
{
throw new IllegalArgumentException("Constant char value malformed: " + value);
}
return new PrimitiveValue((long)value.getBytes(US_ASCII)[0], 1);
case INT8:
return new PrimitiveValue(Byte.parseByte(value), 1);
case INT16:
return new PrimitiveValue(Short.parseShort(value), 2);
case INT32:
return new PrimitiveValue(Integer.parseInt(value), 4);
case INT64:
return new PrimitiveValue(Long.parseLong(value), 8);
case UINT8:
return new PrimitiveValue(Short.parseShort(value), 1);
case UINT16:
return new PrimitiveValue(Integer.parseInt(value), 2);
case UINT32:
return new PrimitiveValue(Long.parseLong(value), 4);
case UINT64:
final BigInteger biValue = new BigInteger(value);
if (biValue.compareTo(BI_NULL_VALUE_UINT64) > 0)
{
throw new IllegalArgumentException("Value greater than UINT64 allows: value=" + value);
}
return new PrimitiveValue(biValue.longValue(), 8);
case FLOAT:
return new PrimitiveValue(Float.parseFloat(value), 4);
case DOUBLE:
return new PrimitiveValue(Double.parseDouble(value), 8);
default:
throw new IllegalArgumentException("Unknown PrimitiveType: " + primitiveType);
}
}
/**
* Parse constant value string and set representation based on type
*
* @param value expressed as a String
* @param primitiveType that this is supposed to be
* @param characterEncoding of the constant value.
* @return a new {@link PrimitiveValue} for the value.
* @throws IllegalArgumentException if parsing malformed type
*/
public static PrimitiveValue parse(
final String value, final PrimitiveType primitiveType, final String characterEncoding)
{
if (PrimitiveType.CHAR != primitiveType)
{
throw new IllegalArgumentException("primitiveType must be char: " + primitiveType);
}
if (value.length() > 1)
{
throw new IllegalArgumentException("Constant char value malformed: " + value);
}
return new PrimitiveValue(value.getBytes(forName(characterEncoding))[0], characterEncoding);
}
/**
* Parse constant value string and set representation based on type, length, and characterEncoding
*
* @param value expressed as a String
* @param length of the type
* @param characterEncoding of the String
* @return a new {@link PrimitiveValue} for the value.
* @throws IllegalArgumentException if parsing malformed type
*/
public static PrimitiveValue parse(
final String value, final int length, final String characterEncoding)
{
if (value.length() > length)
{
throw new IllegalStateException("value.length=" + value.length() + " greater than length=" + length);
}
byte[] bytes = value.getBytes(forName(characterEncoding));
if (bytes.length < length)
{
bytes = Arrays.copyOf(bytes, length);
}
return new PrimitiveValue(bytes, characterEncoding, length);
}
/**
* Return long value for this PrimitiveValue
*
* @return value expressed as a long
* @throws IllegalStateException if not a long value representation
*/
public long longValue()
{
if (representation != Representation.LONG)
{
throw new IllegalStateException(
"Not a long representation: representation=" + representation + " value=" + toString());
}
return longValue;
}
/**
* Return double value for this PrimitiveValue.
*
* @return value expressed as a double
* @throws IllegalStateException if not a double value representation
*/
public double doubleValue()
{
if (representation != Representation.DOUBLE)
{
throw new IllegalStateException(
"Not a double representation: representation=" + representation + " value=" + toString());
}
return doubleValue;
}
/**
* Return byte array value for this PrimitiveValue.
*
* @return value expressed as a byte array
* @throws IllegalStateException if not a byte array value representation
*/
public byte[] byteArrayValue()
{
if (representation != Representation.BYTE_ARRAY)
{
throw new IllegalStateException(
"Not a byte[] representation: representation=" + representation + " value=" + toString());
}
return byteArrayValue;
}
/**
* Return byte array value for this PrimitiveValue given a particular type
*
* @param type of this value
* @return value expressed as a byte array
* @throws IllegalStateException if not a byte array value representation
*/
public byte[] byteArrayValue(final PrimitiveType type)
{
if (representation == Representation.BYTE_ARRAY)
{
return byteArrayValue;
}
else if (representation == Representation.LONG && size == 1 && type == PrimitiveType.CHAR)
{
byteArrayValueForLong[0] = (byte)longValue;
return byteArrayValueForLong;
}
throw new IllegalStateException("PrimitiveValue is not a byte[] representation");
}
/**
* Return encodedLength for this PrimitiveValue for serialization purposes.
*
* @return encodedLength for serialization
*/
public int size()
{
return size;
}
/**
* The character encoding of the byte array representation.
*
* @return the character encoding of te byte array representation.
*/
public String characterEncoding()
{
return characterEncoding;
}
/**
* Return String representation of this object
*
* @return String representing object value
*/
public String toString()
{
switch (representation)
{
case LONG:
return Long.toString(longValue);
case DOUBLE:
return Double.toString(doubleValue);
case BYTE_ARRAY:
try
{
return null == characterEncoding ?
new String(byteArrayValue) : new String(byteArrayValue, characterEncoding);
}
catch (final UnsupportedEncodingException ex)
{
throw new IllegalStateException(ex);
}
default:
throw new IllegalStateException("Unsupported Representation: " + representation);
}
}
/**
* Determine if two values are equivalent.
*
* @param value to compare this value with
* @return equivalence of values
*/
public boolean equals(final Object value)
{
if (null != value && value instanceof PrimitiveValue)
{
final PrimitiveValue rhs = (PrimitiveValue)value;
if (representation == rhs.representation)
{
switch (representation)
{
case LONG:
return longValue == rhs.longValue;
case DOUBLE:
return doubleToLongBits(doubleValue) == doubleToLongBits(rhs.doubleValue);
case BYTE_ARRAY:
return Arrays.equals(byteArrayValue, rhs.byteArrayValue);
}
}
}
return false;
}
/**
* Return hashCode for value. This is the underlying representations hashCode for the value
*
* @return int value of the hashCode
*/
public int hashCode()
{
final long bits;
switch (representation)
{
case LONG:
bits = longValue;
break;
case DOUBLE:
bits = doubleToLongBits(doubleValue);
break;
case BYTE_ARRAY:
return Arrays.hashCode(byteArrayValue);
default:
throw new IllegalStateException("Unrecognised representation: " + representation);
}
return (int)(bits ^ (bits >>> 32));
}
}
simple-binary-encoding-1.8.9/sbe-tool/src/main/java/uk/co/real_logic/sbe/SbeTool.java 0000664 0000000 0000000 00000026670 13355512467 0030401 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013-2018 Real Logic Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package uk.co.real_logic.sbe;
import org.agrona.DirectBuffer;
import org.agrona.MutableDirectBuffer;
import uk.co.real_logic.sbe.generation.CodeGenerator;
import uk.co.real_logic.sbe.generation.TargetCodeGenerator;
import uk.co.real_logic.sbe.generation.TargetCodeGeneratorLoader;
import uk.co.real_logic.sbe.ir.Ir;
import uk.co.real_logic.sbe.ir.IrDecoder;
import uk.co.real_logic.sbe.ir.IrEncoder;
import uk.co.real_logic.sbe.xml.IrGenerator;
import uk.co.real_logic.sbe.xml.MessageSchema;
import uk.co.real_logic.sbe.xml.ParserOptions;
import uk.co.real_logic.sbe.xml.XmlSchemaParser;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Paths;
/**
* A tool for running the SBE parser, validator, and code generator.
*
* Usage:
*
* $ java -jar sbe.jar <filename.xml>
* $ java -Doption=value -jar sbe.jar <filename.xml>
* $ java -Doption=value -jar sbe.jar <filename.sbeir>
*
*
* System Properties:
*
* - sbe.validation.xsd: Use XSD to validate or not.
* - sbe.validation.stop.on.error: Should the parser stop on first error encountered? Defaults to false.
* - sbe.validation.warnings.fatal: Are warnings in parsing considered fatal? Defaults to false.
* -
* sbe.validation.suppress.output: Should the parser suppress output during validation? Defaults to false.
*
* - sbe.generate.stubs: Generate stubs or not. Defaults to true.
* - sbe.target.language: Target language for code generation, defaults to Java.
* - sbe.generate.ir: Generate IR or not. Defaults to false.
* - sbe.output.dir: Target directory for code generation, defaults to current directory.
* - sbe.java.generate.interfaces: Generate interface hierarchy or not. Defaults to false.
* - sbe.java.encoding.buffer.type: Type of the Java interface for the encoding buffer to wrap.
* - sbe.java.decoding.buffer.type: Type of the Java interface for the decoding buffer to wrap.
* - sbe.target.namespace: Namespace for the generated code to override schema package.
* - sbe.cpp.namespaces.collapse: Namespace for the generated code to override schema package.
* -
* sbe.java.generate.group-order.annotation: Should the GroupOrder annotation be added to generated stubs.
*
* - sbe.keyword.append.token: Token to be appended to keywords.
* - sbe.decode.unknown.enum.values: Support unknown decoded enum values.
*
*/
public class SbeTool
{
/**
* Package in which the generated Java interfaces will be placed.
*/
public static final String JAVA_INTERFACE_PACKAGE = "org.agrona.sbe";
/**
* Default class to use as the buffer mutable implementation in generated code.
*/
public static final String JAVA_DEFAULT_ENCODING_BUFFER_TYPE = MutableDirectBuffer.class.getName();
/**
* Default class to use as the buffer read only implementation in generated code.
*/
public static final String JAVA_DEFAULT_DECODING_BUFFER_TYPE = DirectBuffer.class.getName();
/**
* Boolean system property to control throwing exceptions on all errors
*/
public static final String VALIDATION_STOP_ON_ERROR = "sbe.validation.stop.on.error";
/**
* Boolean system property to control whether to consider warnings fatal and treat them as errors
*/
public static final String VALIDATION_WARNINGS_FATAL = "sbe.validation.warnings.fatal";
/**
* System property to hold XSD to validate message specification against
*/
public static final String VALIDATION_XSD = "sbe.validation.xsd";
/**
* Boolean system property to control suppressing output on all errors and warnings
*/
public static final String VALIDATION_SUPPRESS_OUTPUT = "sbe.validation.suppress.output";
/**
* Boolean system property to turn on or off generation of stubs. Defaults to true.
*/
public static final String GENERATE_STUBS = "sbe.generate.stubs";
/**
* Target language for generated code.
*/
public static final String TARGET_LANGUAGE = "sbe.target.language";
/**
* Boolean system property to turn on or off generation of IR. Defaults to false.
*/
public static final String GENERATE_IR = "sbe.generate.ir";
/**
* Output directory for generated code
*/
public static final String OUTPUT_DIR = "sbe.output.dir";
/**
* String system property of the namespace for generated code.
*/
public static final String TARGET_NAMESPACE = "sbe.target.namespace";
/**
* Boolean system property to toggle collapsing of nested namespaces in generated C++ stubs. Defaults to false.
*/
public static final String CPP_NAMESPACES_COLLAPSE = "sbe.cpp.namespaces.collapse";
/**
* Boolean system property to turn on or off generation of the interface hierarchy. Defaults to false.
*/
public static final String JAVA_GENERATE_INTERFACES = "sbe.java.generate.interfaces";
/**
* Specifies the name of the Java mutable buffer to wrap
*/
public static final String JAVA_ENCODING_BUFFER_TYPE = "sbe.java.encoding.buffer.type";
/**
* Specifies the name of the Java read only buffer to wrap
*/
public static final String JAVA_DECODING_BUFFER_TYPE = "sbe.java.decoding.buffer.type";
/**
* Should the {@link uk.co.real_logic.sbe.codec.java.GroupOrder} annotation be added to generated stubs.
*/
public static final String JAVA_GROUP_ORDER_ANNOTATION = "sbe.java.generate.group-order.annotation";
/**
* Specifies token that should be appended to keywords to avoid compilation errors.
*
* If none is supplied then use of keywords results in an error during schema parsing. The
* underscore character is a good example fo a token to use.
*/
public static final String KEYWORD_APPEND_TOKEN = "sbe.keyword.append.token";
/**
* Should unknown enum values be decoded to support extension. Defaults to false.
*
* If an unknown enum value is decoded then a language specific SBE_UNKNOWN enum value will be returned
* rather than throwing an error.
*/
public static final String DECODE_UNKNOWN_ENUM_VALUES = "sbe.decode.unknown.enum.values";
/**
* Main entry point for the SBE Tool.
*
* @param args command line arguments. A single filename is expected.
* @throws Exception if an error occurs during process of the message schema.
*/
public static void main(final String[] args) throws Exception
{
if (args.length == 0)
{
System.err.format("Usage: %s ...%n", SbeTool.class.getName());
System.exit(-1);
}
for (final String fileName : args)
{
final Ir ir;
if (fileName.endsWith(".xml"))
{
final String xsdFilename = System.getProperty(SbeTool.VALIDATION_XSD);
if (xsdFilename != null)
{
validateAgainstSchema(fileName, xsdFilename);
}
ir = new IrGenerator().generate(parseSchema(fileName), System.getProperty(TARGET_NAMESPACE));
}
else if (fileName.endsWith(".sbeir"))
{
ir = new IrDecoder(fileName).decode();
}
else
{
System.err.println("Input file format not supported: " + fileName);
System.exit(-1);
return;
}
final String outputDirName = System.getProperty(OUTPUT_DIR, ".");
if (Boolean.parseBoolean(System.getProperty(GENERATE_STUBS, "true")))
{
final String targetLanguage = System.getProperty(TARGET_LANGUAGE, "Java");
generate(ir, outputDirName, targetLanguage);
}
if (Boolean.parseBoolean(System.getProperty(GENERATE_IR, "false")))
{
final File inputFile = new File(fileName);
final String inputFilename = inputFile.getName();
final int nameEnd = inputFilename.lastIndexOf('.');
final String namePart = inputFilename.substring(0, nameEnd);
final File fullPath = new File(outputDirName, namePart + ".sbeir");
try (IrEncoder irEncoder = new IrEncoder(fullPath.getAbsolutePath(), ir))
{
irEncoder.encode();
}
}
}
}
/**
* Validate the SBE Schema against the XSD.
*
* @param sbeSchemaFilename to be validated
* @param xsdFilename XSD against which to validate
* @throws Exception if an error occurs while validating
*/
public static void validateAgainstSchema(final String sbeSchemaFilename, final String xsdFilename)
throws Exception
{
try (InputStream in = new BufferedInputStream(Files.newInputStream(Paths.get(sbeSchemaFilename))))
{
XmlSchemaParser.validate(xsdFilename, in);
}
}
/**
* Parse the message schema specification.
*
* @param sbeSchemaFilename file containing the SBE specification for the
* @return the parsed {@link MessageSchema} for the specification found in the file.
* @throws Exception if an error occurs when parsing the specification.
*/
public static MessageSchema parseSchema(final String sbeSchemaFilename)
throws Exception
{
final ParserOptions.Builder optionsBuilder = ParserOptions.builder()
.xsdFilename(System.getProperty(VALIDATION_XSD))
.stopOnError(Boolean.parseBoolean(System.getProperty(VALIDATION_STOP_ON_ERROR)))
.warningsFatal(Boolean.parseBoolean(System.getProperty(VALIDATION_WARNINGS_FATAL)))
.suppressOutput(Boolean.parseBoolean(System.getProperty(VALIDATION_SUPPRESS_OUTPUT)));
try (InputStream in = new BufferedInputStream(Files.newInputStream(Paths.get(sbeSchemaFilename))))
{
return XmlSchemaParser.parse(in, optionsBuilder.build());
}
}
/**
* Generate SBE encoding and decoding stubs for a target language.
*
* @param ir for the parsed specification.
* @param outputDirName directory into which code will be generated.
* @param targetLanguage for the generated code.
* @throws Exception if an error occurs while generating the code.
*/
public static void generate(final Ir ir, final String outputDirName, final String targetLanguage)
throws Exception
{
final TargetCodeGenerator targetCodeGenerator = TargetCodeGeneratorLoader.get(targetLanguage);
final CodeGenerator codeGenerator = targetCodeGenerator.newInstance(ir, outputDirName);
codeGenerator.generate();
}
}
simple-binary-encoding-1.8.9/sbe-tool/src/main/java/uk/co/real_logic/sbe/codec/ 0000775 0000000 0000000 00000000000 13355512467 0027231 5 ustar 00root root 0000000 0000000 simple-binary-encoding-1.8.9/sbe-tool/src/main/java/uk/co/real_logic/sbe/codec/java/ 0000775 0000000 0000000 00000000000 13355512467 0030152 5 ustar 00root root 0000000 0000000 simple-binary-encoding-1.8.9/sbe-tool/src/main/java/uk/co/real_logic/sbe/codec/java/GroupOrder.java 0000664 0000000 0000000 00000001740 13355512467 0033107 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013-2018 Real Logic Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package uk.co.real_logic.sbe.codec.java;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Group order for repeating groups in encoded messages.
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE })
public @interface GroupOrder
{
Class[] value();
}
MethodSelector.java 0000664 0000000 0000000 00000010032 13355512467 0033653 0 ustar 00root root 0000000 0000000 simple-binary-encoding-1.8.9/sbe-tool/src/main/java/uk/co/real_logic/sbe/codec/java /*
* Copyright 2013-2018 Real Logic Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package uk.co.real_logic.sbe.codec.java;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class MethodSelector
{
private final Set ignoredMethods;
private final Map, Set> sortedMethods = new HashMap<>();
public static Set objectAndIteratorMethods()
{
return new HashSet<>(
Arrays.asList("hashCode", "clone", "toString", "getClass", "next", "hasNext", "remove", "iterator"));
}
public MethodSelector(final Set ignoredMethods)
{
this.ignoredMethods = ignoredMethods;
}
public List select(final Class clazz)
{
final Method[] methods = clazz.getMethods();
final Set sortedMethodNames = getSortedMethods(clazz, methods);
final Map sortedMethods = new HashMap<>();
final List unsortedMethods = new ArrayList<>();
for (final Method method : methods)
{
selectMethod(sortedMethodNames, sortedMethods, unsortedMethods, method);
}
for (final String name : sortedMethodNames)
{
unsortedMethods.add(sortedMethods.get(name));
}
return unsortedMethods;
}
private Set getSortedMethods(final Class clazz, final Method[] methods)
{
final Set sortedMethodNames = sortedMethods.get(clazz);
if (sortedMethodNames == null)
{
final GroupOrder order = clazz.getAnnotation(GroupOrder.class);
if (order == null)
{
sortedMethods.put(clazz, Collections.emptySet());
return Collections.emptySet();
}
else
{
final Set result = new LinkedHashSet<>();
for (final Class groupClazz : order.value())
{
for (final Method method : methods)
{
if (method.getReturnType() == groupClazz && method.getParameterTypes().length == 0)
{
result.add(method.getName());
}
}
}
sortedMethods.put(clazz, result);
return result;
}
}
return sortedMethodNames;
}
private void selectMethod(
final Set sortedMethodNames,
final Map sortedMethods,
final List unsortedMethods,
final Method method)
{
final int mods = method.getModifiers();
if (!Modifier.isPublic(mods) ||
Modifier.isStatic(mods) ||
method.getParameterTypes().length != 0 ||
method.getReturnType().equals(Void.TYPE) ||
ignoredMethods.contains(method.getName()))
{
return;
}
if (sortedMethodNames == null)
{
unsortedMethods.add(method);
}
else
{
if (sortedMethodNames.contains(method.getName()))
{
sortedMethods.put(method.getName(), method);
}
else
{
unsortedMethods.add(method);
}
}
}
}
simple-binary-encoding-1.8.9/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/ 0000775 0000000 0000000 00000000000 13355512467 0030307 5 ustar 00root root 0000000 0000000 CodeGenerator.java 0000664 0000000 0000000 00000002276 13355512467 0033623 0 ustar 00root root 0000000 0000000 simple-binary-encoding-1.8.9/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation /*
* Copyright 2013-2018 Real Logic Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package uk.co.real_logic.sbe.generation;
import java.io.IOException;
/**
* Abstraction for code generators to implement.
*/
public interface CodeGenerator
{
/**
* Class name to be used for visitor pattern that accesses the message headerStructure.
*/
String MESSAGE_HEADER_ENCODER_TYPE = "MessageHeaderEncoder";
String MESSAGE_HEADER_DECODER_TYPE = "MessageHeaderDecoder";
/**
* Generate the complete set of types and messages for a schema.
*
* @throws IOException if an error is encountered when writing the output.
*/
void generate() throws IOException;
}
simple-binary-encoding-1.8.9/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/Generators.java 0000664 0000000 0000000 00000004723 13355512467 0033271 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013-2018 Real Logic Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package uk.co.real_logic.sbe.generation;
import uk.co.real_logic.sbe.ir.Signal;
import uk.co.real_logic.sbe.ir.Token;
import java.util.List;
import java.util.function.BiConsumer;
public class Generators
{
/**
* For each field found in a list of field {@link Token}s take the field token and following type token to
* a {@link BiConsumer}.
*
* @param tokens to be iterated over.
* @param consumer to for the field and encoding token pair.
*/
public static void forEachField(final List tokens, final BiConsumer consumer)
{
for (int i = 0, size = tokens.size(); i < size;)
{
final Token fieldToken = tokens.get(i);
if (fieldToken.signal() == Signal.BEGIN_FIELD)
{
final Token typeToken = tokens.get(i + 1);
consumer.accept(fieldToken, typeToken);
i += fieldToken.componentTokenCount();
}
else
{
++i;
}
}
}
/**
* Uppercase the first character of a given String.
*
* @param s to have the first character upper cased.
* @return a new String with the first character in uppercase.
*/
public static String toUpperFirstChar(final String s)
{
if (Character.isUpperCase(s.charAt(0)))
{
return s;
}
return Character.toUpperCase(s.charAt(0)) + s.substring(1);
}
/**
* Lowercase the first character of a given String.
*
* @param s to have the first character upper cased.
* @return a new String with the first character in uppercase.
*/
public static String toLowerFirstChar(final String s)
{
if (Character.isLowerCase(s.charAt(0)))
{
return s;
}
return Character.toLowerCase(s.charAt(0)) + s.substring(1);
}
}
simple-binary-encoding-1.8.9/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/NamedToken.java 0000664 0000000 0000000 00000003026 13355512467 0033200 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013-2018 Real Logic Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package uk.co.real_logic.sbe.generation;
import uk.co.real_logic.sbe.ir.Token;
import java.util.ArrayList;
import java.util.List;
import static uk.co.real_logic.sbe.generation.Generators.forEachField;
public class NamedToken
{
private final String name;
private final Token typeToken;
public NamedToken(final String name, final Token typeToken)
{
this.name = name;
this.typeToken = typeToken;
}
public String name()
{
return name;
}
public Token typeToken()
{
return typeToken;
}
public static List gatherNamedNonConstantFieldTokens(final List fields)
{
final List namedTokens = new ArrayList<>();
forEachField(fields, (f, t) ->
{
if (!f.isConstantEncoding())
{
namedTokens.add(new NamedToken(f.name(), t));
}
});
return namedTokens;
}
}
TargetCodeGenerator.java 0000664 0000000 0000000 00000002223 13355512467 0034762 0 ustar 00root root 0000000 0000000 simple-binary-encoding-1.8.9/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation /*
* Copyright 2013-2018 Real Logic Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package uk.co.real_logic.sbe.generation;
import uk.co.real_logic.sbe.ir.Ir;
/**
* Target a code generator for a given language.
*/
public interface TargetCodeGenerator
{
/**
* Get a new {@link CodeGenerator} for the given target language.
*
* @param ir describing the message schemas from which code should generated.
* @param outputDir to which the generated code with be written.
* @return a new instance of a {@link CodeGenerator} for the given target language.
*/
CodeGenerator newInstance(Ir ir, String outputDir);
}
TargetCodeGeneratorLoader.java 0000664 0000000 0000000 00000005740 13355512467 0036120 0 ustar 00root root 0000000 0000000 simple-binary-encoding-1.8.9/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation /*
* Copyright 2013-2018 Real Logic Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package uk.co.real_logic.sbe.generation;
import org.agrona.generation.PackageOutputManager;
import uk.co.real_logic.sbe.generation.cpp.CppGenerator;
import uk.co.real_logic.sbe.generation.cpp.NamespaceOutputManager;
import uk.co.real_logic.sbe.generation.golang.GolangGenerator;
import uk.co.real_logic.sbe.generation.golang.GolangOutputManager;
import uk.co.real_logic.sbe.generation.java.JavaGenerator;
import uk.co.real_logic.sbe.ir.Ir;
import static uk.co.real_logic.sbe.SbeTool.*;
public enum TargetCodeGeneratorLoader implements TargetCodeGenerator
{
JAVA()
{
public CodeGenerator newInstance(final Ir ir, final String outputDir)
{
return new JavaGenerator(
ir,
System.getProperty(JAVA_ENCODING_BUFFER_TYPE, JAVA_DEFAULT_ENCODING_BUFFER_TYPE),
System.getProperty(JAVA_DECODING_BUFFER_TYPE, JAVA_DEFAULT_DECODING_BUFFER_TYPE),
Boolean.getBoolean(JAVA_GROUP_ORDER_ANNOTATION),
Boolean.getBoolean(JAVA_GENERATE_INTERFACES),
Boolean.getBoolean(DECODE_UNKNOWN_ENUM_VALUES),
new PackageOutputManager(outputDir, ir.applicableNamespace()));
}
},
CPP()
{
public CodeGenerator newInstance(final Ir ir, final String outputDir)
{
return new CppGenerator(ir, new NamespaceOutputManager(outputDir, ir.applicableNamespace()));
}
},
GOLANG()
{
public CodeGenerator newInstance(final Ir ir, final String outputDir)
{
return new GolangGenerator(ir, new GolangOutputManager(outputDir, ir.applicableNamespace()));
}
};
/**
* Do a case insensitive lookup of a target language for code generation.
*
* @param name of the target language to lookup.
* @return the {@link TargetCodeGenerator} for the given language name.
*/
public static TargetCodeGenerator get(final String name)
{
for (final TargetCodeGeneratorLoader target : values())
{
if (target.name().equalsIgnoreCase(name))
{
return target;
}
}
try
{
return (TargetCodeGenerator)Class.forName(name).getConstructor().newInstance();
}
catch (final Exception ex)
{
throw new IllegalArgumentException("No code generator for name: " + name, ex);
}
}
}
simple-binary-encoding-1.8.9/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/cpp/ 0000775 0000000 0000000 00000000000 13355512467 0031071 5 ustar 00root root 0000000 0000000 CppGenerator.java 0000775 0000000 0000000 00000234252 13355512467 0034261 0 ustar 00root root 0000000 0000000 simple-binary-encoding-1.8.9/sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/cpp /*
* Copyright 2013-2018 Real Logic Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package uk.co.real_logic.sbe.generation.cpp;
import org.agrona.Verify;
import org.agrona.generation.OutputManager;
import uk.co.real_logic.sbe.PrimitiveType;
import uk.co.real_logic.sbe.generation.CodeGenerator;
import uk.co.real_logic.sbe.ir.Encoding;
import uk.co.real_logic.sbe.ir.Ir;
import uk.co.real_logic.sbe.ir.Signal;
import uk.co.real_logic.sbe.ir.Token;
import java.io.IOException;
import java.io.Writer;
import java.nio.ByteOrder;
import java.util.ArrayList;
import java.util.List;
import static uk.co.real_logic.sbe.generation.cpp.CppUtil.*;
import static uk.co.real_logic.sbe.ir.GenerationUtil.*;
@SuppressWarnings("MethodLength")
public class CppGenerator implements CodeGenerator
{
private static final String BASE_INDENT = "";
private static final String INDENT = " ";
private final Ir ir;
private final OutputManager outputManager;
public CppGenerator(final Ir ir, final OutputManager outputManager)
{
Verify.notNull(ir, "ir");
Verify.notNull(outputManager, "outputManager");
this.ir = ir;
this.outputManager = outputManager;
}
public void generateMessageHeaderStub() throws IOException
{
generateComposite(ir.headerStructure().tokens());
}
public List generateTypeStubs() throws IOException
{
final List typesToInclude = new ArrayList<>();
for (final List tokens : ir.types())
{
switch (tokens.get(0).signal())
{
case BEGIN_ENUM:
generateEnum(tokens);
break;
case BEGIN_SET:
generateChoiceSet(tokens);
break;
case BEGIN_COMPOSITE:
generateComposite(tokens);
break;
}
typesToInclude.add(tokens.get(0).applicableTypeName());
}
return typesToInclude;
}
public List generateTypesToIncludes(final List tokens)
{
final List typesToInclude = new ArrayList<>();
for (final Token token : tokens)
{
switch (token.signal())
{
case BEGIN_ENUM:
case BEGIN_SET:
case BEGIN_COMPOSITE:
typesToInclude.add(token.applicableTypeName());
break;
}
}
return typesToInclude;
}
public void generate() throws IOException
{
generateMessageHeaderStub();
final List typesToInclude = generateTypeStubs();
for (final List tokens : ir.messages())
{
final Token msgToken = tokens.get(0);
final String className = formatClassName(msgToken.name());
try (Writer out = outputManager.createOutput(className))
{
out.append(generateFileHeader(ir.namespaces(), className, typesToInclude));
out.append(generateClassDeclaration(className));
out.append(generateMessageFlyweightCode(className, msgToken));
final List messageBody = tokens.subList(1, tokens.size() - 1);
int i = 0;
final List fields = new ArrayList<>();
i = collectFields(messageBody, i, fields);
final List groups = new ArrayList<>();
i = collectGroups(messageBody, i, groups);
final List varData = new ArrayList<>();
collectVarData(messageBody, i, varData);
final StringBuilder sb = new StringBuilder();
out.append(generateFields(className, fields, BASE_INDENT));
generateGroups(sb, groups, BASE_INDENT);
out.append(sb);
out.append(generateVarData(className, varData, BASE_INDENT));
out.append("};\n");
out.append(CppUtil.closingBraces(ir.namespaces().length)).append("#endif\n");
}
}
}
private void generateGroups(final StringBuilder sb, final List